@heartlandone/vega 2.75.1 → 2.76.0

package/dist/collection/polyfill/prism/tokenizer.js

@@ -0,0 +1,242 @@
+/**
+ * Unique placeholder used to mark greedy-matched regions so they are not
+ * re-tokenized by later grammar rules.  The surrounding curly-brace pairs
+ * make an accidental collision with real source code extremely unlikely.
+ */
+const GREEDY_PLACEHOLDER = '\x00GREEDY_PLACEHOLDER\x00';
+/**
+ * Core tokenizer that converts source code into syntax tokens based on a grammar definition.
+ * This is a local replacement for Prism tokenize.
+ *
+ * The tokenizer works by:
+ * 1. Pre-processing greedy patterns to claim their matched regions first
+ * 2. Iterating through all grammar rules in order
+ * 3. Finding regex matches in the source text
+ * 4. Splitting the text into matched (typed) and unmatched (plain) segments
+ * 5. Recursively tokenizing nested content when an `inside` grammar is specified
+ *
+ * @param {string} code - The source code string to tokenize.
+ * @param {Grammar} grammar - The grammar rules to apply for tokenization.
+ * @returns {(string | SyntaxToken)[]} An array of plain strings and syntax tokens.
+ */
+export function tokenize(code, grammar) {
+  if (!code || !grammar) {
+    return [code];
+  }
+  const tokens = [code];
+  matchGrammar(tokens, grammar);
+  return tokens;
+}
+/**
+ * Apply grammar rules to tokenize string entries in the token list.
+ * Greedy patterns are applied first: their matched regions are replaced with
+ * opaque placeholder tokens so that subsequent (non-greedy) rules cannot
+ * match inside those regions.  After all rules have run the placeholders are
+ * restored to the original matched text.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The current token list to process in-place.
+ * @param {Grammar} grammar - The grammar rules to apply.
+ */
+function matchGrammar(tokens, grammar) {
+  const greedyEntries = [];
+  const nonGreedyEntries = [];
+  for (const tokenType of Object.keys(grammar)) {
+    const grammarEntry = grammar[tokenType];
+    const patterns = Array.isArray(grammarEntry) ? grammarEntry : [grammarEntry];
+    for (const patternDef of patterns) {
+      if (patternDef.greedy) {
+        greedyEntries.push({ tokenType, patternDef });
+      }
+      else {
+        nonGreedyEntries.push({ tokenType, patternDef });
+      }
+    }
+  }
+  // --- Phase 1: Apply greedy patterns first --------------------------------
+  // Greedy patterns claim regions of the source text exclusively.
+  // We replace matched regions with a placeholder string of equal length so
+  // that character offsets remain stable.  Each greedy match is recorded so
+  // we can later restore the original text inside the token.
+  if (greedyEntries.length > 0) {
+    applyGreedyPatterns(tokens, greedyEntries);
+  }
+  // --- Phase 2: Apply remaining non-greedy patterns ------------------------
+  for (const { tokenType, patternDef } of nonGreedyEntries) {
+    applyPattern(tokens, tokenType, patternDef);
+  }
+}
+/**
+ * Process all greedy patterns against the current token list.
+ *
+ * For every plain-string entry in the list the function builds a *mask* string
+ * of the same length.  Greedy matches are recorded and their corresponding
+ * character ranges in the mask are overwritten with a placeholder character so
+ * that later greedy patterns (and all non-greedy patterns) will never match
+ * inside an already-claimed region.
+ *
+ * After all greedy patterns have been collected the affected string entries are
+ * rebuilt by splicing in SyntaxToken objects for each greedy match.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The token list to process in-place.
+ * @param {{ tokenType: string; patternDef: GrammarPattern }[]} greedyEntries - Greedy patterns to apply.
+ */
+function applyGreedyPatterns(tokens, greedyEntries) {
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    /* istanbul ignore next -- defensive: greedy phase only sees strings from initial tokenize() call */
+    if (typeof token !== 'string') {
+      continue;
+    }
+    // Build the full text by concatenating all consecutive string segments
+    // so greedy regex can match across them — but for simplicity we operate
+    // per-segment, which matches prismjs behavior for the patterns we use.
+    const originalText = token;
+    // Mask tracks which characters have been claimed.  A GREEDY_PLACEHOLDER
+    // character at position j means that character is already part of a greedy match.
+    let mask = originalText;
+    const matches = [];
+    for (const { tokenType, patternDef } of greedyEntries) {
+      const { pattern, lookbehind, inside } = patternDef;
+      const regex = new RegExp(pattern.source, pattern.flags.replace(/g/g, '') + 'g');
+      let execResult;
+      while ((execResult = regex.exec(mask)) !== null) {
+        let matchIndex = execResult.index;
+        let match = execResult[0];
+        /* istanbul ignore next -- defensive: prevents infinite loop on zero-length regex matches */
+        if (match.length === 0) {
+          regex.lastIndex++;
+          continue;
+        }
+        // If matched text contains a placeholder char it overlaps a
+        // previously claimed region — skip it.
+        /* istanbul ignore next -- defensive: prevents re-tokenizing already-claimed greedy regions */
+        if (match.indexOf(GREEDY_PLACEHOLDER) !== -1) {
+          continue;
+        }
+        if (lookbehind && execResult[1]) {
+          const lookbehindLength = execResult[1].length;
+          matchIndex += lookbehindLength;
+          match = match.slice(lookbehindLength);
+        }
+        // Record the match and blank out the region in the mask.
+        const matchEnd = matchIndex + match.length;
+        matches.push({
+          tokenType,
+          matchStart: matchIndex,
+          matchEnd,
+          matchText: originalText.slice(matchIndex, matchEnd),
+          inside,
+        });
+        // Replace matched region in the mask with placeholder so later
+        // patterns cannot match inside it.
+        mask =
+          mask.slice(0, matchIndex) +
+            GREEDY_PLACEHOLDER.repeat(match.length).slice(0, match.length) +
+            mask.slice(matchEnd);
+      }
+    }
+    if (matches.length === 0) {
+      continue;
+    }
+    // Sort matches by start position for deterministic splicing.
+    matches.sort((a, b) => a.matchStart - b.matchStart);
+    // Build replacement array.
+    const replacement = [];
+    let lastIndex = 0;
+    for (const m of matches) {
+      if (m.matchStart > lastIndex) {
+        replacement.push(originalText.slice(lastIndex, m.matchStart));
+      }
+      let content = m.matchText;
+      if (m.inside) {
+        const nested = tokenize(m.matchText, m.inside);
+        content = nested.length === 1 ? nested[0] : nested;
+      }
+      replacement.push({ type: m.tokenType, content });
+      lastIndex = m.matchEnd;
+    }
+    if (lastIndex < originalText.length) {
+      replacement.push(originalText.slice(lastIndex));
+    }
+    tokens.splice(i, 1, ...replacement);
+    i += replacement.length - 1;
+  }
+}
+/**
+ * Apply a single pattern definition across all string entries in the token list.
+ * For each string entry, finds ALL matches of the pattern and splits the string
+ * into alternating unmatched/matched segments in one pass.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The token list to process.
+ * @param {string} tokenType - The token type name for matched content.
+ * @param {GrammarPattern} patternDef - The pattern definition to apply.
+ */
+function applyPattern(tokens, tokenType, patternDef) {
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    // Only process string tokens, skip already-tokenized entries
+    if (typeof token !== 'string') {
+      continue;
+    }
+    const replacement = tokenizeStringByPattern(token, tokenType, patternDef);
+    // Only splice if matches were found (replacement differs from original)
+    if (replacement.length === 1 && typeof replacement[0] === 'string') {
+      continue;
+    }
+    tokens.splice(i, 1, ...replacement);
+    // Skip past the entire replacement — all matches in this string are handled
+    i += replacement.length - 1;
+  }
+}
+/**
+ * Find all matches of a pattern within a string and return the split result
+ * as an array of alternating plain strings and syntax tokens.
+ *
+ * @param {string} text - The string to tokenize.
+ * @param {string} tokenType - The token type name for matched content.
+ * @param {GrammarPattern} patternDef - The pattern definition to apply.
+ * @returns {(string | SyntaxToken)[]} The tokenized result.
+ */
+function tokenizeStringByPattern(text, tokenType, patternDef) {
+  const { pattern, lookbehind, inside } = patternDef;
+  const regex = new RegExp(pattern.source, pattern.flags.replace(/g/g, '') + 'g');
+  const result = [];
+  let lastIndex = 0;
+  let execResult;
+  while ((execResult = regex.exec(text)) !== null) {
+    let matchIndex = execResult.index;
+    let match = execResult[0];
+    // Prevent zero-length match infinite loops
+    if (match.length === 0) {
+      regex.lastIndex++;
+      continue;
+    }
+    // Handle lookbehind: adjust match position and content
+    if (lookbehind && execResult[1]) {
+      const lookbehindLength = execResult[1].length;
+      matchIndex += lookbehindLength;
+      match = match.slice(lookbehindLength);
+    }
+    // Add unmatched text before this match
+    if (matchIndex > lastIndex) {
+      result.push(text.slice(lastIndex, matchIndex));
+    }
+    // Process nested grammar if specified
+    let content = match;
+    if (inside) {
+      const nestedTokens = tokenize(match, inside);
+      content = nestedTokens.length === 1 ? nestedTokens[0] : nestedTokens;
+    }
+    result.push({ type: tokenType, content });
+    lastIndex = matchIndex + match.length;
+  }
+  // Add remaining unmatched text
+  if (lastIndex < text.length) {
+    result.push(text.slice(lastIndex));
+  }
+  /* istanbul ignore next -- defensive: tokenizeStringByPattern always has remainder text */
+  if (result.length === 0) {
+    return [text];
+  }
+  return result;
+}

package/dist/collection/polyfill/tinycolor/tinycolor-polyfill.js

@@ -0,0 +1,320 @@
+/**
+ * TinyColor Polyfill - A lightweight color manipulation utility.
+ *
+ * This is a drop-in replacement for tinycolor2, implementing only the methods
+ * used in the Vega theme overriding system.
+ *
+ * @see VD-5026 - [Zero Dependencies] remove tinycolor2 dependency
+ */
+/**
+ * TinyColor polyfill class for color manipulation.
+ * Implements the same interface as tinycolor2.Instance for the methods used in Vega.
+ */
+export class TinyColorPolyfill {
+  /**
+   * Create a new TinyColorPolyfill instance.
+   *
+   * @param {string | RgbaValue} color - The color to parse.
+   */
+  constructor(color) {
+    const rgba = TinyColorPolyfill.parseColor(color);
+    this._r = rgba.r;
+    this._g = rgba.g;
+    this._b = rgba.b;
+    this._a = rgba.a;
+  }
+  // ==================== Private Static Helper Methods ====================
+  /**
+   * Clamp a value between a minimum and maximum.
+   *
+   * @param {number} value - The value to clamp.
+   * @param {number} min - The minimum allowed value.
+   * @param {number} max - The maximum allowed value.
+   * @returns {number} The clamped value.
+   */
+  static clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  }
+  /**
+   * Parse a color string or RGBA object into an RgbaValue.
+   *
+   * Supported formats:
+   * - Hex: #RGB, #RRGGBB, #RRGGBBAA
+   * - RGB: rgb(r, g, b)
+   * - RGBA: rgba(r, g, b, a)
+   * - Object: { r, g, b, a? }
+   *
+   * @param {string | RgbaValue} color - The color to parse.
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  static parseColor(color) {
+    if (typeof color === 'object' && 'r' in color && 'g' in color && 'b' in color) {
+      return {
+        r: Math.round(TinyColorPolyfill.clamp(color.r, 0, 255)),
+        g: Math.round(TinyColorPolyfill.clamp(color.g, 0, 255)),
+        b: Math.round(TinyColorPolyfill.clamp(color.b, 0, 255)),
+        a: color.a !== undefined ? TinyColorPolyfill.clamp(color.a, 0, 1) : 1,
+      };
+    }
+    if (typeof color !== 'string') {
+      return { r: 0, g: 0, b: 0, a: 1 };
+    }
+    const trimmed = color.trim().toLowerCase();
+    // Hex format
+    if (trimmed.startsWith('#')) {
+      return TinyColorPolyfill.parseHex(trimmed);
+    }
+    // RGB/RGBA format
+    if (trimmed.startsWith('rgb')) {
+      return TinyColorPolyfill.parseRgbString(trimmed);
+    }
+    // Fallback to black for unsupported formats
+    return { r: 0, g: 0, b: 0, a: 1 };
+  }
+  /* eslint-disable spellcheck/spell-checker */
+  /**
+   * Parse a hex color string into RGBA values.
+   *
+   * @param {string} hex - The hex color string (e.g., "#fff", "#ffffff", "#ffffffff").
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  static parseHex(hex) {
+    /* eslint-enable spellcheck/spell-checker */
+    // Remove the # prefix
+    let hexValue = hex.slice(1);
+    // Expand shorthand format (#RGB -> #RRGGBB)
+    if (hexValue.length === 3) {
+      hexValue = hexValue
+        .split('')
+        .map((c) => c + c)
+        .join('');
+    }
+    // Handle #RGBA shorthand
+    if (hexValue.length === 4) {
+      hexValue = hexValue
+        .split('')
+        .map((c) => c + c)
+        .join('');
+    }
+    const r = parseInt(hexValue.slice(0, 2), 16);
+    const g = parseInt(hexValue.slice(2, 4), 16);
+    const b = parseInt(hexValue.slice(4, 6), 16);
+    let a = 1;
+    // Handle #RRGGBBAA format
+    if (hexValue.length === 8) {
+      a = parseInt(hexValue.slice(6, 8), 16) / 255;
+    }
+    return {
+      r: Number.isNaN(r) ? 0 : r,
+      g: Number.isNaN(g) ? 0 : g,
+      b: Number.isNaN(b) ? 0 : b,
+      a: Number.isNaN(a) ? 1 : a,
+    };
+  }
+  /**
+   * Parse an RGB or RGBA string into RGBA values.
+   *
+   * @param {string} rgbString - The RGB/RGBA string (e.g., "rgb(255, 128, 0)" or "rgba(255, 128, 0, 0.5)").
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  static parseRgbString(rgbString) {
+    // Match rgb(r, g, b) or rgba(r, g, b, a) with comma-separated integer values.
+    // Note: Does NOT support percentage values (e.g., rgb(100%, 50%, 0%)) or
+    // modern CSS space-separated syntax (e.g., rgb(255 128 0 / 0.5)).
+    const match = rgbString.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d+\.?\d*))?\s*\)/);
+    if (!match) {
+      return { r: 0, g: 0, b: 0, a: 1 };
+    }
+    return {
+      r: TinyColorPolyfill.clamp(parseInt(match[1], 10), 0, 255),
+      g: TinyColorPolyfill.clamp(parseInt(match[2], 10), 0, 255),
+      b: TinyColorPolyfill.clamp(parseInt(match[3], 10), 0, 255),
+      a: match[4] !== undefined ? TinyColorPolyfill.clamp(parseFloat(match[4]), 0, 1) : 1,
+    };
+  }
+  /**
+   * Convert RGB to HSL.
+   *
+   * @param {number} r - Red (0-255).
+   * @param {number} g - Green (0-255).
+   * @param {number} b - Blue (0-255).
+   * @returns {HslValue} The HSL values (h: 0-360, s: 0-1, l: 0-1).
+   */
+  static rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    let h = 0;
+    let s = 0;
+    if (max !== min) {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      switch (max) {
+        case r:
+          h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+          break;
+        case g:
+          h = ((b - r) / d + 2) / 6;
+          break;
+        case b:
+          h = ((r - g) / d + 4) / 6;
+          break;
+      }
+    }
+    return { h: h * 360, s, l };
+  }
+  /**
+   * Convert HSL to RGB.
+   *
+   * @param {number} h - Hue (0-360).
+   * @param {number} s - Saturation (0-1).
+   * @param {number} l - Lightness (0-1).
+   * @returns {RgbValue} The RGB values (0-255).
+   */
+  static hslToRgb(h, s, l) {
+    h /= 360;
+    let r;
+    let g;
+    let b;
+    if (s === 0) {
+      r = g = b = l;
+    }
+    else {
+      /**
+       * Helper function to convert hue to RGB component.
+       *
+       * @param {number} p - First intermediate value.
+       * @param {number} q - Second intermediate value.
+       * @param {number} t - Hue offset value.
+       * @returns {number} RGB component value (0-1).
+       */
+      const hue2rgb = (p, q, t) => {
+        if (t < 0)
+          t += 1;
+        if (t > 1)
+          t -= 1;
+        if (t < 1 / 6)
+          return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+          return q;
+        if (t < 2 / 3)
+          return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+      };
+      const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      const p = 2 * l - q;
+      r = hue2rgb(p, q, h + 1 / 3);
+      g = hue2rgb(p, q, h);
+      b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return {
+      r: Math.round(r * 255),
+      g: Math.round(g * 255),
+      b: Math.round(b * 255),
+    };
+  }
+  /**
+   * Calculate the perceived brightness of a color using the YIQ formula.
+   * This matches tinycolor2's brightness calculation.
+   *
+   * @param {number} r - Red (0-255).
+   * @param {number} g - Green (0-255).
+   * @param {number} b - Blue (0-255).
+   * @returns {number} Brightness value (0-255).
+   */
+  static getBrightness(r, g, b) {
+    return (r * 299 + g * 587 + b * 114) / 1000;
+  }
+  // ==================== Public Instance Methods ====================
+  /**
+   * Check if the color is dark (brightness < 128).
+   *
+   * @returns {boolean} True if the color is considered dark.
+   */
+  isDark() {
+    return TinyColorPolyfill.getBrightness(this._r, this._g, this._b) < 128;
+  }
+  /**
+   * Check if the color is light (brightness >= 128).
+   *
+   * @returns {boolean} True if the color is considered light.
+   */
+  isLight() {
+    return !this.isDark();
+  }
+  /**
+   * Create a copy of this color.
+   *
+   * @returns {TinyColorPolyfill} A new TinyColorPolyfill instance with the same values.
+   */
+  clone() {
+    const cloned = new TinyColorPolyfill({
+      r: this._r,
+      g: this._g,
+      b: this._b,
+      a: this._a,
+    });
+    return cloned;
+  }
+  /**
+   * Lighten the color by a given amount.
+   * Note: tinycolor2 accepts negative values to darken.
+   *
+   * @param {number} amount - The amount to lighten (0-100). Negative values darken.
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  lighten(amount = 10) {
+    const hsl = TinyColorPolyfill.rgbToHsl(this._r, this._g, this._b);
+    hsl.l = TinyColorPolyfill.clamp(hsl.l + amount / 100, 0, 1);
+    const rgb = TinyColorPolyfill.hslToRgb(hsl.h, hsl.s, hsl.l);
+    this._r = rgb.r;
+    this._g = rgb.g;
+    this._b = rgb.b;
+    return this;
+  }
+  /**
+   * Darken the color by a given amount.
+   *
+   * @param {number} amount - The amount to darken (0-100).
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  darken(amount = 10) {
+    return this.lighten(-amount);
+  }
+  /**
+   * Set the alpha (opacity) of the color.
+   *
+   * @param {number} alpha - The alpha value (0-1).
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  setAlpha(alpha) {
+    this._a = TinyColorPolyfill.clamp(alpha, 0, 1);
+    return this;
+  }
+  /**
+   * Get the RGBA representation of the color.
+   *
+   * @returns {RgbaValue} The RGBA values.
+   */
+  toRgb() {
+    return {
+      r: this._r,
+      g: this._g,
+      b: this._b,
+      a: this._a,
+    };
+  }
+}
+/**
+ * Factory function to create a TinyColorPolyfill instance.
+ * This provides API compatibility with tinycolor2's default export.
+ *
+ * @param {string | RgbaValue} color - The color to parse.
+ * @returns {TinyColorPolyfill} A new TinyColorPolyfill instance.
+ */
+export function tinycolor(color) {
+  return new TinyColorPolyfill(color);
+}