@globalpayments/vega 2.73.0 → 2.76.0

package/dist/collection/polyfill/prism/languages/jsx.js

@@ -0,0 +1,46 @@
+import { javascriptGrammar } from './javascript';
+import { markupGrammar } from './markup';
+/**
+ * Grammar definition for JSX syntax highlighting.
+ * Extends JavaScript grammar with JSX tag syntax for React components,
+ * including self-closing tags, expressions in braces, and embedded markup attributes.
+ */
+export const jsxGrammar = Object.assign(Object.assign({ 
+  // Tag must come before JS spread so operator pattern doesn't consume < and >
+  tag: {
+    pattern: /<\/?(?:[\w.:-]+(?:\s+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}))?|\{\.{3}[a-z_$][\w$]*(?:\.[\w$]+)*\}))*\s*\/?)?>/i,
+    greedy: true,
+    inside: {
+      'tag': {
+        pattern: /^<\/?[^\s>/]*/,
+        inside: {
+          punctuation: { pattern: /^<\/?/ },
+          namespace: { pattern: /^[^\s>/:]+:/ },
+        },
+      },
+      'attr-value': {
+        pattern: /=\s*(?:"[^"]*"|'[^']*'|\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\})/,
+        inside: {
+          punctuation: [{ pattern: /^=/ }, { pattern: /^(\s*)["'{]|[}"']$/, lookbehind: true }],
+          script: {
+            pattern: /[\s\S]+/,
+            inside: javascriptGrammar,
+          },
+        },
+      },
+      'spread': {
+        pattern: /\{\.{3}[a-z_$][\w$]*(?:\.[\w$]+)*\}/,
+        inside: {
+          'punctuation': { pattern: /^\{\.{3}|\}$/ },
+          'attr-name': { pattern: /[\s\S]+/ },
+        },
+      },
+      'attr-name': {
+        pattern: /[^\s>/]+/,
+        inside: {
+          namespace: { pattern: /^[^\s>/:]+:/ },
+        },
+      },
+      'punctuation': { pattern: /\/?>/ },
+    },
+  } }, javascriptGrammar), { entity: markupGrammar.entity });

package/dist/collection/polyfill/prism/languages/language-registry.js

@@ -0,0 +1,41 @@
+import { cssGrammar } from './css';
+import { markupGrammar } from './markup';
+import { javascriptGrammar } from './javascript';
+import { typescriptGrammar } from './typescript';
+import { jsxGrammar } from './jsx';
+import { tsxGrammar } from './tsx';
+/**
+ * A registry that maps language identifiers to their grammar definitions.
+ * Supports common aliases (e.g., 'html' -> markup, 'js' -> javascript).
+ *
+ * The registry provides grammars for:
+ * - CSS
+ * - HTML / Markup
+ * - JavaScript (JS)
+ * - TypeScript (TS)
+ * - JSX
+ * - TSX
+ * - C / C-like (falls back to JavaScript grammar for basic C-family highlighting)
+ */
+const languageRegistry = {
+  css: cssGrammar,
+  html: markupGrammar,
+  markup: markupGrammar,
+  javascript: javascriptGrammar,
+  js: javascriptGrammar,
+  typescript: typescriptGrammar,
+  ts: typescriptGrammar,
+  jsx: jsxGrammar,
+  tsx: tsxGrammar,
+  c: javascriptGrammar,
+  clike: javascriptGrammar,
+};
+/**
+ * Retrieve the grammar for a given language identifier.
+ *
+ * @param {string} language - The language identifier (e.g., 'js', 'css', 'html', 'ts', 'jsx', 'tsx').
+ * @returns {Grammar | undefined} The grammar definition, or undefined if the language is not registered.
+ */
+export function getLanguageGrammar(language) {
+  return languageRegistry[language];
+}

package/dist/collection/polyfill/prism/languages/markup.js

@@ -0,0 +1,71 @@
+/**
+ * Grammar definition for HTML/Markup syntax highlighting.
+ * Handles tags, attributes, comments, doctypes, CDATA, entities, and embedded content.
+ */
+export const markupGrammar = {
+  comment: {
+    pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+    greedy: true,
+  },
+  prolog: {
+    pattern: /<\?[\s\S]+?\?>/,
+    greedy: true,
+  },
+  doctype: {
+    pattern: /<!DOCTYPE(?:[^>"']|"[^"]*"|'[^']*')+(?:>|$)/i,
+    greedy: true,
+    inside: {
+      'internal-subset': {
+        pattern: /(^[^[]*\[)[\s\S]+(?=\]>$)/,
+        lookbehind: true,
+        greedy: true,
+      },
+      'punctuation': { pattern: /^<!|>$|[[\]]/ },
+      'doctype-tag': { pattern: /^DOCTYPE/i },
+      'name': { pattern: /[^\s<>'"/]+/ },
+      'string': {
+        pattern: /("|')[\s\S]*?\1/,
+        greedy: true,
+      },
+    },
+  },
+  cdata: {
+    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+    greedy: true,
+  },
+  tag: {
+    pattern: /<\/?(?!\d)[^\s>/=$<%]+(?:\s(?:\s*[^\s>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+    greedy: true,
+    inside: {
+      'tag': {
+        pattern: /^<\/?[^\s>/]+/,
+        inside: {
+          punctuation: { pattern: /^<\/?/ },
+          namespace: { pattern: /^[^\s>/:]+:/ },
+        },
+      },
+      'special-attr': [],
+      'attr-value': {
+        pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+        inside: {
+          punctuation: [{ pattern: /^=/ }, { pattern: /^(\s*)["']|["']$/, lookbehind: true }],
+        },
+      },
+      'punctuation': { pattern: /\/?>/ },
+      'attr-name': {
+        pattern: /[^\s>/]+/,
+        inside: {
+          namespace: { pattern: /^[^\s>/:]+:/ },
+        },
+      },
+    },
+  },
+  entity: [
+    {
+      pattern: /&[\da-z]{1,8};/i,
+    },
+    {
+      pattern: /&#x?[\da-f]{1,8};/i,
+    },
+  ],
+};

package/dist/collection/polyfill/prism/languages/tsx.js

@@ -0,0 +1,10 @@
+import { typescriptGrammar } from './typescript';
+import { jsxGrammar } from './jsx';
+/**
+ * Grammar definition for TSX (TypeScript + JSX) syntax highlighting.
+ * Merges TypeScript and JSX grammars, supporting both type annotations
+ * and JSX tag syntax in the same file.
+ */
+export const tsxGrammar = Object.assign(Object.assign({ 
+  // Tag must come before TS spread so operator pattern doesn't consume < and >
+  tag: jsxGrammar['tag'] }, typescriptGrammar), { entity: jsxGrammar['entity'] });

package/dist/collection/polyfill/prism/languages/typescript.js

@@ -0,0 +1,64 @@
+var __rest = (this && this.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+import { javascriptGrammar } from './javascript';
+/**
+ * Grammar definition for TypeScript syntax highlighting.
+ * Extends JavaScript grammar with TypeScript-specific constructs such as
+ * type annotations, generics, interfaces, enums, decorators, and access modifiers.
+ *
+ * Note: We destructure `keyword`, `function`, `operator`, and `punctuation` out
+ * of the JS grammar and re-add them in the correct order. This ensures:
+ * - `builtin` is matched before `keyword` (both contain words like void, null, etc.)
+ * - `function` is matched before `operator` and `punctuation` (the function
+ *   pattern uses a lookahead for `(` which must still be an unmatched string)
+ */
+const { 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+keyword: _jsKeyword, function: jsFunction, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+operator: _jsOperator, punctuation: jsPunctuation } = javascriptGrammar, jsGrammarBase = __rest(javascriptGrammar, ["keyword", "function", "operator", "punctuation"]);
+export const typescriptGrammar = Object.assign(Object.assign({}, jsGrammarBase), { 'class-name': [
+    {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        punctuation: { pattern: /[<>.,]/ },
+      },
+    },
+  ], 'builtin': {
+    pattern: /\b(?:Array|Boolean|Date|Function|Map|Number|Object|Promise|RegExp|Set|String|WeakMap|WeakSet|bigint|boolean|never|null|number|string|symbol|undefined|unknown|void)\b/,
+  }, 'keyword': [
+    {
+      pattern: /\b(?:abstract|as|asserts|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|infer|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|undefined|var|void|while|with|yield)\b/,
+    },
+  ], 'function': jsFunction, 'generic-function': {
+    pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+    greedy: true,
+    inside: {
+      function: {
+        pattern: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+      },
+      generic: {
+        pattern: /<[\s\S]+/,
+        inside: {
+          punctuation: { pattern: /[<>(),.]/ },
+          keyword: { pattern: /\b(?:extends|infer|keyof)\b/ },
+          builtin: {
+            pattern: /\b(?:boolean|never|null|number|string|symbol|undefined|unknown|void)\b/,
+          },
+        },
+      },
+    },
+  }, 'operator': {
+    pattern: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%|&^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]|!(?=\s*[^=])/,
+  }, 'punctuation': jsPunctuation });

package/dist/collection/polyfill/prism/test/css.test.js

@@ -0,0 +1,61 @@
+import { tokenize } from '../tokenizer';
+import { cssGrammar } from '../languages/css';
+import { findTokensByType } from './test-utils';
+describe('CSS Language Grammar', () => {
+  it('should tokenize CSS comments', () => {
+    const code = '/* This is a comment */';
+    const tokens = tokenize(code, cssGrammar);
+    const comments = findTokensByType(tokens, 'comment');
+    expect(comments.length).toBe(1);
+    expect(comments[0].content).toBe('/* This is a comment */');
+  });
+  it('should tokenize CSS strings', () => {
+    const code = 'content: "hello";';
+    const tokens = tokenize(code, cssGrammar);
+    const strings = findTokensByType(tokens, 'string');
+    expect(strings.length).toBe(1);
+    expect(strings[0].content).toBe('"hello"');
+  });
+  it('should tokenize CSS properties', () => {
+    const code = 'color: red;';
+    const tokens = tokenize(code, cssGrammar);
+    const properties = findTokensByType(tokens, 'property');
+    expect(properties.length).toBe(1);
+    expect(properties[0].content).toBe('color');
+  });
+  it('should tokenize CSS numbers', () => {
+    const code = 'width: 100px;';
+    const tokens = tokenize(code, cssGrammar);
+    const numbers = findTokensByType(tokens, 'number');
+    expect(numbers.length).toBe(1);
+  });
+  it('should tokenize CSS punctuation', () => {
+    const code = '{ color: red; }';
+    const tokens = tokenize(code, cssGrammar);
+    const punctuation = findTokensByType(tokens, 'punctuation');
+    expect(punctuation.length).toBeGreaterThan(0);
+  });
+  it('should tokenize !important', () => {
+    const code = 'color: red !important;';
+    const tokens = tokenize(code, cssGrammar);
+    const important = findTokensByType(tokens, 'important');
+    expect(important.length).toBe(1);
+  });
+  it('should tokenize CSS functions', () => {
+    const code = 'background: rgb(255, 0, 0);';
+    const tokens = tokenize(code, cssGrammar);
+    const functions = findTokensByType(tokens, 'function');
+    expect(functions.length).toBeGreaterThanOrEqual(1);
+  });
+  it('should tokenize multi-line CSS block', () => {
+    const code = `.container {
+  display: flex;
+  /* centered */
+  justify-content: center;
+}`;
+    const tokens = tokenize(code, cssGrammar);
+    expect(tokens.length).toBeGreaterThan(1);
+    const comments = findTokensByType(tokens, 'comment');
+    expect(comments.length).toBe(1);
+  });
+});

package/dist/collection/polyfill/prism/test/javascript.test.js

@@ -0,0 +1,113 @@
+import { tokenize } from '../tokenizer';
+import { javascriptGrammar } from '../languages/javascript';
+import { findTokensByType } from './test-utils';
+describe('JavaScript Language Grammar', () => {
+  it('should tokenize single-line comments', () => {
+    const code = '// This is a comment';
+    const tokens = tokenize(code, javascriptGrammar);
+    const comments = findTokensByType(tokens, 'comment');
+    expect(comments.length).toBe(1);
+  });
+  it('should tokenize multi-line comments', () => {
+    const code = '/* multi\nline\ncomment */';
+    const tokens = tokenize(code, javascriptGrammar);
+    const comments = findTokensByType(tokens, 'comment');
+    expect(comments.length).toBe(1);
+  });
+  it('should tokenize string literals', () => {
+    const code = 'const x = "hello world";';
+    const tokens = tokenize(code, javascriptGrammar);
+    const strings = findTokensByType(tokens, 'string');
+    expect(strings.length).toBeGreaterThanOrEqual(1);
+  });
+  it('should tokenize single-quoted strings', () => {
+    const code = "const x = 'hello';";
+    const tokens = tokenize(code, javascriptGrammar);
+    const strings = findTokensByType(tokens, 'string');
+    expect(strings.length).toBeGreaterThanOrEqual(1);
+  });
+  it('should tokenize template strings', () => {
+    const code = 'const x = `hello ${name}`;';
+    const tokens = tokenize(code, javascriptGrammar);
+    const templateStrings = findTokensByType(tokens, 'template-string');
+    expect(templateStrings.length).toBe(1);
+  });
+  it('should tokenize keywords', () => {
+    const code = 'const x = 1; let y = 2; var z = 3;';
+    const tokens = tokenize(code, javascriptGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    expect(keywords.length).toBe(3);
+  });
+  it('should tokenize control flow keywords', () => {
+    const code = 'if (true) { return x; } else { throw err; }';
+    const tokens = tokenize(code, javascriptGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    expect(keywords.length).toBeGreaterThanOrEqual(3);
+  });
+  it('should tokenize boolean values', () => {
+    const code = 'const a = true; const b = false;';
+    const tokens = tokenize(code, javascriptGrammar);
+    const booleans = findTokensByType(tokens, 'boolean');
+    expect(booleans.length).toBe(2);
+  });
+  it('should tokenize numbers', () => {
+    const code = 'const x = 42; const y = 3.14;';
+    const tokens = tokenize(code, javascriptGrammar);
+    const numbers = findTokensByType(tokens, 'number');
+    expect(numbers.length).toBe(2);
+  });
+  it('should tokenize function calls', () => {
+    const code = 'console.log("hello"); alert("world");';
+    const tokens = tokenize(code, javascriptGrammar);
+    const functions = findTokensByType(tokens, 'function');
+    expect(functions.length).toBeGreaterThanOrEqual(2);
+  });
+  it('should tokenize arrow functions', () => {
+    const code = 'const fn = (x) => x + 1;';
+    const tokens = tokenize(code, javascriptGrammar);
+    const operators = findTokensByType(tokens, 'operator');
+    const arrowOp = operators.find((t) => t.content === '=>');
+    expect(arrowOp).toBeDefined();
+  });
+  it('should tokenize operators', () => {
+    const code = 'x === y && a !== b || c >= d';
+    const tokens = tokenize(code, javascriptGrammar);
+    const operators = findTokensByType(tokens, 'operator');
+    expect(operators.length).toBeGreaterThanOrEqual(4);
+  });
+  it('should tokenize punctuation', () => {
+    const code = 'const obj = { a: 1, b: [2, 3] };';
+    const tokens = tokenize(code, javascriptGrammar);
+    const punctuation = findTokensByType(tokens, 'punctuation');
+    expect(punctuation.length).toBeGreaterThan(0);
+  });
+  it('should tokenize a complete function declaration', () => {
+    const code = `function greet(name) {
+  const message = "Hello, " + name;
+  return message;
+}`;
+    const tokens = tokenize(code, javascriptGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    const functions = findTokensByType(tokens, 'function');
+    expect(keywords.length).toBeGreaterThanOrEqual(2);
+    expect(functions.length).toBeGreaterThanOrEqual(1);
+  });
+  it('should tokenize class declarations', () => {
+    const code = 'class Foo extends Bar { constructor() { super(); } }';
+    const tokens = tokenize(code, javascriptGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    const classKw = keywords.find((t) => t.content === 'class');
+    const extendsKw = keywords.find((t) => t.content === 'extends');
+    expect(classKw).toBeDefined();
+    expect(extendsKw).toBeDefined();
+  });
+  it('should tokenize async/await', () => {
+    const code = 'async function fetchData() { await fetch(url); }';
+    const tokens = tokenize(code, javascriptGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    const asyncKw = keywords.find((t) => t.content === 'async');
+    const awaitKw = keywords.find((t) => t.content === 'await');
+    expect(asyncKw).toBeDefined();
+    expect(awaitKw).toBeDefined();
+  });
+});

package/dist/collection/polyfill/prism/test/jsx.test.js

@@ -0,0 +1,48 @@
+import { tokenize } from '../tokenizer';
+import { jsxGrammar } from '../languages/jsx';
+import { findTokensByType } from './test-utils';
+describe('JSX Language Grammar', () => {
+  it('should tokenize JSX tags', () => {
+    const code = '<div>Hello</div>';
+    const tokens = tokenize(code, jsxGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(2);
+  });
+  it('should tokenize self-closing JSX tags', () => {
+    const code = '<Component />';
+    const tokens = tokenize(code, jsxGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(1);
+  });
+  it('should tokenize JSX tags with props', () => {
+    const code = '<Button onClick={handleClick} size="large">Click</Button>';
+    const tokens = tokenize(code, jsxGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(2);
+  });
+  it('should still tokenize JS keywords in JSX context', () => {
+    const code = 'const element = <div>Hello</div>;';
+    const tokens = tokenize(code, jsxGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    const constKw = keywords.find((t) => t.content === 'const');
+    expect(constKw).toBeDefined();
+  });
+  it('should tokenize JSX with nested tags', () => {
+    const code = `<div>
+  <span>inner</span>
+</div>`;
+    const tokens = tokenize(code, jsxGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(4);
+  });
+  it('should tokenize JSX function component', () => {
+    const code = `function App() {
+  return <div className="app">Hello</div>;
+}`;
+    const tokens = tokenize(code, jsxGrammar);
+    const keywords = findTokensByType(tokens, 'keyword');
+    const tags = findTokensByType(tokens, 'tag');
+    expect(keywords.length).toBeGreaterThanOrEqual(2);
+    expect(tags.length).toBe(2);
+  });
+});

package/dist/collection/polyfill/prism/test/language-registry.test.js

@@ -0,0 +1,77 @@
+import { getLanguageGrammar } from '../languages/language-registry';
+describe('Language Registry', () => {
+  it('should return CSS grammar for "css"', () => {
+    const grammar = getLanguageGrammar('css');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('comment');
+    expect(grammar).toHaveProperty('property');
+  });
+  it('should return markup grammar for "html"', () => {
+    const grammar = getLanguageGrammar('html');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('tag');
+    expect(grammar).toHaveProperty('comment');
+  });
+  it('should return markup grammar for "markup"', () => {
+    const grammar = getLanguageGrammar('markup');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('tag');
+  });
+  it('should return same grammar for "html" and "markup" aliases', () => {
+    expect(getLanguageGrammar('html')).toBe(getLanguageGrammar('markup'));
+  });
+  it('should return JavaScript grammar for "js"', () => {
+    const grammar = getLanguageGrammar('js');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('keyword');
+    expect(grammar).toHaveProperty('string');
+  });
+  it('should return same grammar for "js" and "javascript" aliases', () => {
+    expect(getLanguageGrammar('js')).toBe(getLanguageGrammar('javascript'));
+  });
+  it('should return TypeScript grammar for "ts"', () => {
+    const grammar = getLanguageGrammar('ts');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('builtin');
+    expect(grammar).toHaveProperty('keyword');
+  });
+  it('should return same grammar for "ts" and "typescript" aliases', () => {
+    expect(getLanguageGrammar('ts')).toBe(getLanguageGrammar('typescript'));
+  });
+  it('should return JSX grammar for "jsx"', () => {
+    const grammar = getLanguageGrammar('jsx');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('tag');
+    expect(grammar).toHaveProperty('keyword');
+  });
+  it('should return TSX grammar for "tsx"', () => {
+    const grammar = getLanguageGrammar('tsx');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('tag');
+    expect(grammar).toHaveProperty('builtin');
+  });
+  it('should return undefined for unregistered languages', () => {
+    expect(getLanguageGrammar('python')).toBeUndefined();
+    expect(getLanguageGrammar('ruby')).toBeUndefined();
+    expect(getLanguageGrammar('unknown')).toBeUndefined();
+  });
+  it('should return undefined for empty string', () => {
+    expect(getLanguageGrammar('')).toBeUndefined();
+  });
+  it('should return a grammar for "c"', () => {
+    const grammar = getLanguageGrammar('c');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('keyword');
+  });
+  it('should return a grammar for "clike"', () => {
+    const grammar = getLanguageGrammar('clike');
+    expect(grammar).toBeDefined();
+    expect(grammar).toHaveProperty('keyword');
+  });
+  it('should return same grammar for "c" and "clike" aliases', () => {
+    expect(getLanguageGrammar('c')).toBe(getLanguageGrammar('clike'));
+  });
+  it('should map "c" and "clike" to JavaScript grammar as fallback', () => {
+    expect(getLanguageGrammar('c')).toBe(getLanguageGrammar('javascript'));
+  });
+});

package/dist/collection/polyfill/prism/test/markup.test.js

@@ -0,0 +1,57 @@
+import { tokenize } from '../tokenizer';
+import { markupGrammar } from '../languages/markup';
+import { findTokensByType } from './test-utils';
+describe('Markup/HTML Language Grammar', () => {
+  it('should tokenize HTML comments', () => {
+    const code = '<!-- This is a comment -->';
+    const tokens = tokenize(code, markupGrammar);
+    const comments = findTokensByType(tokens, 'comment');
+    expect(comments.length).toBe(1);
+    expect(comments[0].content).toBe('<!-- This is a comment -->');
+  });
+  it('should tokenize HTML tags', () => {
+    const code = '<div class="container">Hello</div>';
+    const tokens = tokenize(code, markupGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(2);
+  });
+  it('should tokenize self-closing tags', () => {
+    const code = '<br/>';
+    const tokens = tokenize(code, markupGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(1);
+  });
+  it('should tokenize tags with attributes', () => {
+    const code = '<a href="https://example.com" target="_blank">Link</a>';
+    const tokens = tokenize(code, markupGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(2);
+  });
+  it('should tokenize DOCTYPE', () => {
+    const code = '<!DOCTYPE html>';
+    const tokens = tokenize(code, markupGrammar);
+    const doctypes = findTokensByType(tokens, 'doctype');
+    expect(doctypes.length).toBe(1);
+  });
+  it('should tokenize HTML entities', () => {
+    const code = '&amp; &lt; &gt;';
+    const tokens = tokenize(code, markupGrammar);
+    const entities = findTokensByType(tokens, 'entity');
+    expect(entities.length).toBe(3);
+  });
+  it('should tokenize nested HTML structure', () => {
+    const code = `<div>
+  <p class="text">Hello</p>
+  <span>World</span>
+</div>`;
+    const tokens = tokenize(code, markupGrammar);
+    const tags = findTokensByType(tokens, 'tag');
+    expect(tags.length).toBe(6);
+  });
+  it('should tokenize CDATA sections', () => {
+    const code = '<![CDATA[some content]]>';
+    const tokens = tokenize(code, markupGrammar);
+    const cdata = findTokensByType(tokens, 'cdata');
+    expect(cdata.length).toBe(1);
+  });
+});

package/dist/collection/polyfill/prism/test/test-utils.js

@@ -0,0 +1,22 @@
+/**
+ * Recursively find all tokens of a given type within a token array.
+ * Traverses nested token content arrays to find deeply nested tokens.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The token array to search.
+ * @param {string} type - The token type to filter by.
+ * @returns {SyntaxToken[]} All tokens matching the specified type.
+ */
+export const findTokensByType = (tokens, type) => {
+  const result = [];
+  for (const token of tokens) {
+    if (typeof token !== 'string') {
+      if (token.type === type) {
+        result.push(token);
+      }
+      else if (Array.isArray(token.content)) {
+        result.push(...findTokensByType(token.content, type));
+      }
+    }
+  }
+  return result;
+};