@heartlandone/vega 2.75.1 → 2.76.0

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

@@ -0,0 +1,86 @@
+/**
+ * Grammar definition for CSS syntax highlighting.
+ * Handles selectors, properties, values, at-rules, comments, strings, and other CSS constructs.
+ */
+export const cssGrammar = {
+  comment: {
+    pattern: /\/\*[\s\S]*?\*\//,
+    greedy: true,
+  },
+  string: {
+    pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\\n\r])*\1/,
+    greedy: true,
+  },
+  atrule: [
+    {
+      pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+      inside: {
+        'rule': { pattern: /^@[\w-]+/ },
+        'selector-function-argument': {
+          pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+          lookbehind: true,
+        },
+        'keyword': {
+          pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+          lookbehind: true,
+        },
+        'punctuation': { pattern: /[;:(){}]/ },
+      },
+    },
+  ],
+  url: {
+    pattern: /\burl\((?:("|')(?:\\[\s\S]|(?!\1)[^\\\n\r])*\1|(?:[^\\\r\n()"']|\\[\s\S])*)\)/i,
+    greedy: true,
+    inside: {
+      function: { pattern: /^url/i },
+      punctuation: { pattern: /^\(|\)$/ },
+      string: {
+        pattern: /^("|')[\s\S]+(?=\1$)/,
+        lookbehind: true,
+      },
+    },
+  },
+  selector: {
+    pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?![\s{])|\((?:[^()]|\([^()]*\))*\))*(?=\s*\{)/,
+    inside: {
+      'pseudo-element': { pattern: /(?:::)[\w-]+/ },
+      'pseudo-class': { pattern: /(?::)[\w-]+/ },
+      'class': { pattern: /\.[\w-]+/ },
+      'id': { pattern: /#[\w-]+/ },
+      'attribute': {
+        pattern: /\[(?:[^[\]"']|("|')(?:\\[\s\S]|(?!\1)[^\\\n\r])*\1)*\]/,
+        greedy: true,
+        inside: {
+          'punctuation': { pattern: /^\[|\]$/ },
+          'attr-name': { pattern: /^(\s*)(?:(?!\s)[-\w\u00B7\u00C0-\u024F])+/i, lookbehind: true },
+          'attr-value': [{ pattern: /(=\s*)(?:"[^"]*"|'[^']*'|[^\s'"=]+)/, lookbehind: true }],
+          'operator': { pattern: /[|~*^$]?=/ },
+        },
+      },
+    },
+  },
+  property: {
+    pattern: /(?!\s)[-_a-z\u00B7\u00C0-\u024F][-\w\u00B7\u00C0-\u024F]*(?=\s*:)/i,
+  },
+  important: {
+    pattern: /!important\b/i,
+  },
+  function: {
+    pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+    lookbehind: true,
+  },
+  number: {
+    pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?/i,
+    lookbehind: true,
+  },
+  unit: {
+    pattern: /(\b\d+)(?:%|[a-z]+)/,
+    lookbehind: true,
+  },
+  punctuation: {
+    pattern: /[(){};:,]/,
+  },
+  operator: {
+    pattern: /[+\-*/=><~^|]+/,
+  },
+};

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

@@ -0,0 +1,96 @@
+/**
+ * Grammar definition for JavaScript syntax highlighting.
+ * Handles keywords, operators, strings, template literals, numbers,
+ * regex literals, comments, functions, classes, and other JS constructs.
+ */
+export const javascriptGrammar = {
+  'comment': [
+    {
+      pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+      lookbehind: true,
+      greedy: true,
+    },
+    {
+      pattern: /(^|[^\\:])\/\/.*/,
+      lookbehind: true,
+      greedy: true,
+    },
+  ],
+  'string': [
+    {
+      pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\\r\n])*\1/,
+      greedy: true,
+    },
+  ],
+  'template-string': {
+    pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+    greedy: true,
+    inside: {
+      'template-punctuation': {
+        pattern: /^`|`$/,
+      },
+      'interpolation': {
+        pattern: /\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
+        inside: {
+          'interpolation-punctuation': {
+            pattern: /^\$\{|\}$/,
+          },
+        },
+      },
+      'string': {
+        pattern: /[\s\S]+/,
+      },
+    },
+  },
+  'regex': {
+    pattern: 
+    // eslint-disable-next-line no-useless-escape
+    /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[.\r\n,;:})\]]|\/\/))/,
+    lookbehind: true,
+    greedy: true,
+    inside: {
+      'regex-source': {
+        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+        lookbehind: true,
+      },
+      'regex-delimiter': {
+        pattern: /^\/|\/$/,
+      },
+      'regex-flags': {
+        pattern: /^[a-z]+$/,
+      },
+    },
+  },
+  'class-name': [
+    {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/,
+      lookbehind: true,
+      inside: {
+        punctuation: { pattern: /[.\\]/ },
+      },
+    },
+  ],
+  'keyword': [
+    {
+      pattern: /\b(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+    },
+  ],
+  'boolean': {
+    pattern: /\b(?:false|true)\b/,
+  },
+  'number': {
+    pattern: /\b(?:(?:0[xX][\dA-Fa-f](?:_[\dA-Fa-f])*|0[bB][01](?:_[01])*|0[oO][0-7](?:_[0-7])*)n?|(?:\d(?:_\d)*\.?\d*|\.\d+)(?:[Ee][+-]?\d(?:_\d)*)?n?|NaN|Infinity)\b/,
+  },
+  'function': {
+    pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+  },
+  'operator': {
+    pattern: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%|&^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+  },
+  'punctuation': {
+    pattern: /[{}[\];(),.:]/,
+  },
+  'constant': {
+    pattern: /\b[A-Z](?:[A-Z_]|\dx)*\b/,
+  },
+};

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);
+  });
+});