@widgetic/editor 3.11.4 → 4.0.2

package/dist/utils/colorAutocomplete.d.ts

@@ -0,0 +1,10 @@
+export interface AutocompleteResult {
+    suggestion: string;
+    remainingText: string;
+    allMatches: string[];
+    currentIndex: number;
+}
+export declare function getColorSuggestions(input: string, colorNames: {
+    [key: string]: string;
+}): AutocompleteResult | null;
+export declare function getNextSuggestion(current: AutocompleteResult, direction: 'up' | 'down'): AutocompleteResult;

package/dist/utils/colorAutocomplete.js

@@ -0,0 +1,28 @@
+export function getColorSuggestions(input, colorNames) {
+    if (input.length < 2)
+        return null;
+    const inputLower = input.toLowerCase();
+    const matches = Object.keys(colorNames).filter(color => color.toLowerCase().startsWith(inputLower)).sort();
+    if (matches.length === 0)
+        return null;
+    const firstMatch = matches[0];
+    const remainingText = firstMatch.slice(input.length);
+    return {
+        suggestion: firstMatch,
+        remainingText,
+        allMatches: matches,
+        currentIndex: 0
+    };
+}
+export function getNextSuggestion(current, direction) {
+    const newIndex = direction === 'down'
+        ? (current.currentIndex + 1) % current.allMatches.length
+        : (current.currentIndex - 1 + current.allMatches.length) % current.allMatches.length;
+    const newSuggestion = current.allMatches[newIndex];
+    return {
+        ...current,
+        suggestion: newSuggestion,
+        remainingText: newSuggestion.slice(current.suggestion.length - current.remainingText.length),
+        currentIndex: newIndex
+    };
+}

package/dist/utils/colorNames.d.ts

@@ -0,0 +1,3 @@
+export declare const colorNames: {
+    [key: string]: string;
+};

package/dist/utils/colorNames.js

@@ -0,0 +1,152 @@
+// Source: https://www.w3.org/TR/css-color-3/#svg-color
+export const colorNames = {
+    // Basic color keywords (4.1)
+    'black': '#000000',
+    'silver': '#c0c0c0',
+    'gray': '#808080',
+    'white': '#ffffff',
+    'maroon': '#800000',
+    'red': '#ff0000',
+    'purple': '#800080',
+    'fuchsia': '#ff00ff',
+    'green': '#008000',
+    'lime': '#00ff00',
+    'olive': '#808000',
+    'yellow': '#ffff00',
+    'navy': '#000080',
+    'blue': '#0000ff',
+    'teal': '#008080',
+    'aqua': '#00ffff',
+    // Extended color keywords (4.3)
+    'aliceblue': '#f0f8ff',
+    'antiquewhite': '#faebd7',
+    'aquamarine': '#7fffd4',
+    'azure': '#f0ffff',
+    'beige': '#f5f5dc',
+    'bisque': '#ffe4c4',
+    'blanchedalmond': '#ffebcd',
+    'blueviolet': '#8a2be2',
+    'brown': '#a52a2a',
+    'burlywood': '#deb887',
+    'cadetblue': '#5f9ea0',
+    'chartreuse': '#7fff00',
+    'chocolate': '#d2691e',
+    'coral': '#ff7f50',
+    'cornflowerblue': '#6495ed',
+    'cornsilk': '#fff8dc',
+    'crimson': '#dc143c',
+    'cyan': '#00ffff',
+    'darkblue': '#00008b',
+    'darkcyan': '#008b8b',
+    'darkgoldenrod': '#b8860b',
+    'darkgray': '#a9a9a9',
+    'darkgreen': '#006400',
+    'darkgrey': '#a9a9a9',
+    'darkkhaki': '#bdb76b',
+    'darkmagenta': '#8b008b',
+    'darkolivegreen': '#556b2f',
+    'darkorange': '#ff8c00',
+    'darkorchid': '#9932cc',
+    'darkred': '#8b0000',
+    'darksalmon': '#e9967a',
+    'darkseagreen': '#8fbc8f',
+    'darkslateblue': '#483d8b',
+    'darkslategray': '#2f4f4f',
+    'darkslategrey': '#2f4f4f',
+    'darkturquoise': '#00ced1',
+    'darkviolet': '#9400d3',
+    'deeppink': '#ff1493',
+    'deepskyblue': '#00bfff',
+    'dimgray': '#696969',
+    'dimgrey': '#696969',
+    'dodgerblue': '#1e90ff',
+    'firebrick': '#b22222',
+    'floralwhite': '#fffaf0',
+    'forestgreen': '#228b22',
+    'gainsboro': '#dcdcdc',
+    'ghostwhite': '#f8f8ff',
+    'gold': '#ffd700',
+    'goldenrod': '#daa520',
+    'greenyellow': '#adff2f',
+    'grey': '#808080',
+    'honeydew': '#f0fff0',
+    'hotpink': '#ff69b4',
+    'indianred': '#cd5c5c',
+    'indigo': '#4b0082',
+    'ivory': '#fffff0',
+    'khaki': '#f0e68c',
+    'lavender': '#e6e6fa',
+    'lavenderblush': '#fff0f5',
+    'lawngreen': '#7cfc00',
+    'lemonchiffon': '#fffacd',
+    'lightblue': '#add8e6',
+    'lightcoral': '#f08080',
+    'lightcyan': '#e0ffff',
+    'lightgoldenrodyellow': '#fafad2',
+    'lightgray': '#d3d3d3',
+    'lightgreen': '#90ee90',
+    'lightgrey': '#d3d3d3',
+    'lightpink': '#ffb6c1',
+    'lightsalmon': '#ffa07a',
+    'lightseagreen': '#20b2aa',
+    'lightskyblue': '#87cefa',
+    'lightslategray': '#778899',
+    'lightslategrey': '#778899',
+    'lightsteelblue': '#b0c4de',
+    'lightyellow': '#ffffe0',
+    'limegreen': '#32cd32',
+    'linen': '#faf0e6',
+    'magenta': '#ff00ff',
+    'mediumaquamarine': '#66cdaa',
+    'mediumblue': '#0000cd',
+    'mediumorchid': '#ba55d3',
+    'mediumpurple': '#9370db',
+    'mediumseagreen': '#3cb371',
+    'mediumslateblue': '#7b68ee',
+    'mediumspringgreen': '#00fa9a',
+    'mediumturquoise': '#48d1cc',
+    'mediumvioletred': '#c71585',
+    'midnightblue': '#191970',
+    'mintcream': '#f5fffa',
+    'mistyrose': '#ffe4e1',
+    'moccasin': '#ffe4b5',
+    'navajowhite': '#ffdead',
+    'oldlace': '#fdf5e6',
+    'olivedrab': '#6b8e23',
+    'orange': '#ffa500',
+    'orangered': '#ff4500',
+    'orchid': '#da70d6',
+    'palegoldenrod': '#eee8aa',
+    'palegreen': '#98fb98',
+    'paleturquoise': '#afeeee',
+    'palevioletred': '#db7093',
+    'papayawhip': '#ffefd5',
+    'peachpuff': '#ffdab9',
+    'peru': '#cd853f',
+    'pink': '#ffc0cb',
+    'plum': '#dda0dd',
+    'powderblue': '#b0e0e6',
+    'rosybrown': '#bc8f8f',
+    'royalblue': '#4169e1',
+    'saddlebrown': '#8b4513',
+    'salmon': '#fa8072',
+    'sandybrown': '#f4a460',
+    'seagreen': '#2e8b57',
+    'seashell': '#fff5ee',
+    'sienna': '#a0522d',
+    'skyblue': '#87ceeb',
+    'slateblue': '#6a5acd',
+    'slategray': '#708090',
+    'slategrey': '#708090',
+    'snow': '#fffafa',
+    'springgreen': '#00ff7f',
+    'steelblue': '#4682b4',
+    'tan': '#d2b48c',
+    'thistle': '#d8bfd8',
+    'tomato': '#ff6347',
+    'turquoise': '#40e0d0',
+    'violet': '#ee82ee',
+    'wheat': '#f5deb3',
+    'whitesmoke': '#f5f5f5',
+    'yellowgreen': '#9acd32'
+};

package/dist/utils/colorTransparency.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Utility functions for handling color transparency while preserving color positions
+ */
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare class ColorTransparencyHandler {
+    private persistentOpacity;
+    private isInternalUpdate;
+    private isColorSelectUpdate;
+    constructor(initialOpacity?: number);
+    /**
+     * Converts hex color to RGBA while preserving opacity
+     */
+    hexToRgba(hex: string): RGB;
+    /**
+     * Converts RGBA values to hex color
+     */
+    rgbaToHex(r: number, g: number, b: number, a: number): string;
+    /**
+     * Updates opacity from slider position
+     */
+    updateOpacityFromPosition(event: MouseEvent, sliderElement: HTMLDivElement, onUpdate: (hexValue: string, rgb: RGB) => void, currentRgb: RGB): void;
+    /**
+     * Updates opacity from input value
+     */
+    updateOpacityFromInput(inputValue: number, onUpdate: (hexValue: string, rgb: RGB) => void, currentRgb: RGB): void;
+    /**
+     * Gets the current opacity percentage
+     */
+    getOpacityPercentage(): number;
+    /**
+     * Gets the current persistent opacity value
+     */
+    getCurrentOpacity(): number;
+    /**
+     * Checks if an update is internal
+     */
+    isUpdatingInternally(): boolean;
+    /**
+     * Checks if an update is from color select
+     */
+    isUpdatingFromColorSelect(): boolean;
+    /**
+     * Sets the color select update flag
+     */
+    setColorSelectUpdate(value: boolean): void;
+}
+export declare function getRGBABorder(color: string, opacity: number): string;

package/dist/utils/colorTransparency.js

@@ -0,0 +1,114 @@
+/**
+ * Utility functions for handling color transparency while preserving color positions
+ */
+export class ColorTransparencyHandler {
+    persistentOpacity = 1;
+    isInternalUpdate = false;
+    isColorSelectUpdate = false;
+    constructor(initialOpacity = 1) {
+        this.persistentOpacity = initialOpacity;
+    }
+    /**
+     * Converts hex color to RGBA while preserving opacity
+     */
+    hexToRgba(hex) {
+        console.log('Converting hex to rgba:', hex, 'Current opacity:', this.persistentOpacity);
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i.exec(hex);
+        if (result) {
+            return {
+                r: parseInt(result[1], 16) / 255,
+                g: parseInt(result[2], 16) / 255,
+                b: parseInt(result[3], 16) / 255,
+                a: this.persistentOpacity
+            };
+        }
+        return {
+            r: 0,
+            g: 0,
+            b: 0,
+            a: this.persistentOpacity
+        };
+    }
+    /**
+     * Converts RGBA values to hex color
+     */
+    rgbaToHex(r, g, b, a) {
+        const toHex = (x) => Math.round(x * 255).toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}${a < 1 ? toHex(a) : ''}`;
+    }
+    /**
+     * Updates opacity from slider position
+     */
+    updateOpacityFromPosition(event, sliderElement, onUpdate, currentRgb) {
+        if (!sliderElement)
+            return;
+        const rect = sliderElement.getBoundingClientRect();
+        const x = event.clientX - rect.left;
+        const width = rect.width;
+        let newOpacity = Math.max(0, Math.min(x, width)) / width;
+        newOpacity = Math.round(newOpacity * 100) / 100;
+        try {
+            this.isInternalUpdate = true;
+            this.persistentOpacity = newOpacity;
+            const updatedRgb = { ...currentRgb, a: newOpacity };
+            const hexValue = this.rgbaToHex(updatedRgb.r, updatedRgb.g, updatedRgb.b, newOpacity);
+            onUpdate(hexValue, updatedRgb);
+        }
+        finally {
+            this.isInternalUpdate = false;
+        }
+        console.log('Updated opacity:', newOpacity);
+    }
+    /**
+     * Updates opacity from input value
+     */
+    updateOpacityFromInput(inputValue, onUpdate, currentRgb) {
+        const value = Math.min(100, Math.max(0, inputValue));
+        const newOpacity = value / 100;
+        try {
+            this.isInternalUpdate = true;
+            this.persistentOpacity = newOpacity;
+            const updatedRgb = { ...currentRgb, a: newOpacity };
+            const hexValue = this.rgbaToHex(updatedRgb.r, updatedRgb.g, updatedRgb.b, newOpacity);
+            onUpdate(hexValue, updatedRgb);
+        }
+        finally {
+            this.isInternalUpdate = false;
+        }
+        console.log('Updated opacity from input:', value);
+    }
+    /**
+     * Gets the current opacity percentage
+     */
+    getOpacityPercentage() {
+        return Math.round(this.persistentOpacity * 100);
+    }
+    /**
+     * Gets the current persistent opacity value
+     */
+    getCurrentOpacity() {
+        return this.persistentOpacity;
+    }
+    /**
+     * Checks if an update is internal
+     */
+    isUpdatingInternally() {
+        return this.isInternalUpdate;
+    }
+    /**
+     * Checks if an update is from color select
+     */
+    isUpdatingFromColorSelect() {
+        return this.isColorSelectUpdate;
+    }
+    /**
+     * Sets the color select update flag
+     */
+    setColorSelectUpdate(value) {
+        this.isColorSelectUpdate = value;
+    }
+}
+// Export the helper function
+export function getRGBABorder(color, opacity) {
+    return `1px solid ${color.replace('rgb', 'rgba').replace(')', `, ${opacity})`)}`;
+}

package/dist/utils/fontUtils.d.ts

@@ -0,0 +1,34 @@
+type CategoryMap = {
+    'sans-serif': 'Sans Serif';
+    'serif': 'Serif';
+    'display': 'Script';
+    'handwriting': 'Script';
+    'monospace': 'Other';
+};
+type CategoryTypes = ['All', 'Serif', 'Sans Serif', 'Script', 'Other', 'Mine'];
+type FontCategories = {
+    map: CategoryMap;
+    types: CategoryTypes;
+    normalize: (category: string) => Exclude<CategoryTypes[number], 'All'>;
+};
+export declare const fontCategories: FontCategories;
+export type FontCategory = Exclude<typeof fontCategories.types[number], 'All'>;
+export interface FontItem {
+    family: string;
+    category: FontCategory;
+    isCustom?: boolean;
+}
+export interface RecentFont {
+    family: string;
+    category: string;
+    isCustom?: boolean;
+    lastUsed: number;
+}
+export declare const recentFontsStore: import("svelte/store").Writable<RecentFont[]>;
+export declare const fontUtils: {
+    getRecentFonts(): RecentFont[];
+    addRecentFont(font: FontItem): RecentFont[];
+    removeCustomFont(family: string): RecentFont[];
+    categorizeFont(family: string): FontCategory;
+};
+export {};

package/dist/utils/fontUtils.js

@@ -0,0 +1,132 @@
+import { writable } from 'svelte/store';
+// Define our category types with proper typing
+export const fontCategories = {
+    // Google Fonts categories to our categories mapping
+    map: {
+        'sans-serif': 'Sans Serif',
+        'serif': 'Serif',
+        'display': 'Script',
+        'handwriting': 'Script',
+        'monospace': 'Other'
+    },
+    // Our category types
+    types: ['All', 'Serif', 'Sans Serif', 'Script', 'Other', 'Mine'],
+    // Helper function to map Google Fonts category to our category
+    normalize(category) {
+        // Handle null or undefined category
+        if (!category) {
+            console.log('⚠️ [FontUtils] Null category, returning Other');
+            return 'Other';
+        }
+        // Convert to lowercase and trim for consistent matching
+        const normalizedCategory = category.toLowerCase().trim();
+        // // Debug: log the exact state of the mapping
+        // console.log('🔍 [FontUtils] Category mapping:', {
+        //   input: category,
+        //   normalized: normalizedCategory,
+        //   mapKeys: Object.keys(this.map),
+        //   hasExactMatch: normalizedCategory in this.map,
+        //   availableMappings: this.map
+        // });
+        // Try direct mapping first
+        if (normalizedCategory in this.map) {
+            const mapped = this.map[normalizedCategory];
+            //   console.log('✅ [FontUtils] Direct mapping found:', {
+            //     from: normalizedCategory,
+            //     to: mapped
+            //   });
+            return mapped;
+        }
+        // If no direct mapping, try to infer category
+        // First normalize the input category to match our expected format
+        const categoryToCheck = normalizedCategory === 'script' ? 'display' : normalizedCategory;
+        if (categoryToCheck in this.map) {
+            const mapped = this.map[categoryToCheck];
+            //   console.log('✅ [FontUtils] Normalized mapping found:', {
+            //     from: normalizedCategory,
+            //     via: categoryToCheck,
+            //     to: mapped
+            //   });
+            return mapped;
+        }
+        // If still no match, use inference rules
+        let inferredCategory = 'Other';
+        if (normalizedCategory.includes('serif')) {
+            inferredCategory = normalizedCategory.includes('sans') ? 'Sans Serif' : 'Serif';
+        }
+        else if (normalizedCategory.includes('display') ||
+            normalizedCategory.includes('handwriting') ||
+            normalizedCategory.includes('script')) {
+            inferredCategory = 'Script';
+        }
+        else if (normalizedCategory.includes('mono')) {
+            inferredCategory = 'Other';
+        }
+        // console.log('ℹ️ [FontUtils] Inferred category:', {
+        //   from: normalizedCategory,
+        //   to: inferredCategory
+        // });
+        return inferredCategory;
+    }
+};
+const RECENT_FONTS_KEY = 'recent_fonts';
+const MAX_RECENT_FONTS = 3;
+// Add store for recent fonts
+export const recentFontsStore = writable([]);
+export const fontUtils = {
+    getRecentFonts() {
+        try {
+            const stored = localStorage.getItem(RECENT_FONTS_KEY);
+            return stored ? JSON.parse(stored) : [];
+        }
+        catch (error) {
+            console.error('Error reading recent fonts:', error);
+            return [];
+        }
+    },
+    addRecentFont(font) {
+        try {
+            const recentFonts = this.getRecentFonts();
+            const filteredFonts = recentFonts.filter(f => f.family !== font.family);
+            const newRecentFonts = [
+                {
+                    ...font,
+                    lastUsed: Date.now()
+                },
+                ...filteredFonts
+            ].slice(0, MAX_RECENT_FONTS);
+            localStorage.setItem(RECENT_FONTS_KEY, JSON.stringify(newRecentFonts));
+            recentFontsStore.set(newRecentFonts);
+            return newRecentFonts;
+        }
+        catch (error) {
+            console.error('Error saving recent font:', error);
+            return this.getRecentFonts();
+        }
+    },
+    removeCustomFont(family) {
+        try {
+            const recentFonts = this.getRecentFonts();
+            const filteredFonts = recentFonts.filter(f => f.family !== family);
+            localStorage.setItem(RECENT_FONTS_KEY, JSON.stringify(filteredFonts));
+            return filteredFonts;
+        }
+        catch (error) {
+            console.error('Error removing custom font:', error);
+            return this.getRecentFonts();
+        }
+    },
+    categorizeFont(family) {
+        const lowerFamily = family.toLowerCase();
+        if (lowerFamily.includes('serif') && !lowerFamily.includes('sans')) {
+            return 'Serif';
+        }
+        else if (lowerFamily.includes('sans')) {
+            return 'Sans Serif';
+        }
+        else if (lowerFamily.includes('script') || lowerFamily.includes('cursive')) {
+            return 'Script';
+        }
+        return 'Other';
+    }
+};

package/dist/utils/passiveEvents.js

@@ -0,0 +1,20 @@
+// Add passive event listener support globally
+if (typeof window !== 'undefined') {
+    // Save the original addEventListener
+    const originalAddEventListener = EventTarget.prototype.addEventListener;
+    // Override addEventListener
+    EventTarget.prototype.addEventListener = function (type, listener, options) {
+        // Force passive for touch and wheel events
+        if (type === 'touchstart' || type === 'touchmove' || type === 'wheel') {
+            let newOptions = options;
+            if (typeof options === 'object') {
+                newOptions = { ...options, passive: true };
+            }
+            else {
+                newOptions = { passive: true };
+            }
+            return originalAddEventListener.call(this, type, listener, newOptions);
+        }
+        return originalAddEventListener.call(this, type, listener, options);
+    };
+}

package/dist/utils/recentColors.d.ts

@@ -0,0 +1,10 @@
+type RecentColor = {
+    color: string;
+    alpha: number;
+    timestamp: number;
+};
+export declare const recentColorsUtil: {
+    getRecentColors(): RecentColor[];
+    addRecentColor(color: string, alpha: number): RecentColor[];
+};
+export {};

package/dist/utils/recentColors.js

@@ -0,0 +1,63 @@
+const STORAGE_KEY = 'recentColors';
+const MAX_COLORS = 12;
+export const recentColorsUtil = {
+    getRecentColors() {
+        try {
+            const stored = localStorage.getItem(STORAGE_KEY);
+            return stored ? JSON.parse(stored) : [];
+        }
+        catch (error) {
+            console.error('Error reading recent colors:', error);
+            return [];
+        }
+    },
+    addRecentColor(color, alpha) {
+        try {
+            const normalizedColor = color.toLowerCase();
+            console.log('Adding/updating recent color:', {
+                normalizedColor,
+                alpha,
+                originalColor: color
+            });
+            let colors = this.getRecentColors();
+            // Normalize all colors for comparison
+            const existingIndex = colors.findIndex(c => {
+                const normalizedExisting = c.color.toLowerCase();
+                const alphaMatch = Math.abs(c.alpha - alpha) < 0.001;
+                console.log('Comparing:', {
+                    existing: normalizedExisting,
+                    new: normalizedColor,
+                    existingAlpha: c.alpha,
+                    newAlpha: alpha,
+                    alphaMatch,
+                    colorsMatch: normalizedExisting === normalizedColor
+                });
+                return normalizedExisting === normalizedColor && alphaMatch;
+            });
+            console.log('Found existing color at index:', existingIndex);
+            if (existingIndex !== -1) {
+                // Remove the existing color
+                const removed = colors.splice(existingIndex, 1)[0];
+                console.log('Removed existing color:', removed);
+            }
+            // Add the new/updated color to the front
+            const newColor = {
+                color: color, // Keep original case
+                alpha,
+                timestamp: Date.now()
+            };
+            colors.unshift(newColor);
+            // console.log('Added color to front:', newColor);
+            // Trim to max size
+            colors = colors.slice(0, MAX_COLORS);
+            // Save to localStorage
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(colors));
+            // console.log('Final colors list:', colors);
+            return colors;
+        }
+        catch (error) {
+            console.error('Error saving recent color:', error);
+            return this.getRecentColors(); // Return existing colors on error
+        }
+    }
+};

package/dist/utils/skipFonts.d.ts

@@ -0,0 +1,3 @@
+export declare const skipFamilies: Set<string>;
+export declare const skipFonts: Set<string>;
+export declare function shouldSkipFont(fontFamily: string): boolean;

package/dist/utils/skipFonts.js

@@ -0,0 +1,49 @@
+// Define patterns for Material Icons/Symbols
+const MATERIAL_PATTERNS = [
+    'material icons',
+    'material symbols'
+];
+// Define specific fonts to skip
+export const skipFamilies = new Set([
+    "Libre Barcode 39"
+]);
+// Define monospace and other fonts to skip
+export const skipFonts = new Set([
+    'VT323',
+    'PT Mono',
+    'DM Mono',
+    'Share Tech Mono',
+    'Share-Tech-Mono',
+    'Anonymous Pro',
+    'AnonymousPro',
+    'Anonymous-Pro',
+    'Noto Sans'
+]);
+function normalizeFontName(fontFamily) {
+    return fontFamily
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '');
+}
+export function shouldSkipFont(fontFamily) {
+    if (!fontFamily)
+        return false;
+    // Convert to lowercase for consistent comparison
+    const familyLower = fontFamily.toLowerCase();
+    // First check if it's a Material font using patterns
+    if (MATERIAL_PATTERNS.some(pattern => familyLower.includes(pattern))) {
+        // console.log('🚫 [skipFonts] Skipping Material font:', fontFamily);
+        return true;
+    }
+    // Then check exact matches
+    if (skipFamilies.has(fontFamily) || skipFonts.has(fontFamily)) {
+        // console.log('🚫 [skipFonts] Skipping exact match:', fontFamily);
+        return true;
+    }
+    // Finally check normalized names
+    const normalizedName = normalizeFontName(fontFamily);
+    const shouldSkip = Array.from(skipFamilies).some(family => normalizeFontName(family) === normalizedName) || Array.from(skipFonts).some(font => normalizeFontName(font) === normalizedName);
+    if (shouldSkip) {
+        // console.log('🚫 [skipFonts] Skipping normalized match:', fontFamily);
+    }
+    return shouldSkip;
+}