jaml-ui 0.24.20 → 0.25.2

package/dist/lib/hooks/useJamlFilter.js

@@ -1,219 +0,0 @@
-import { useState, useCallback, useMemo } from 'react';
-import { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS } from '../data/constants.js';
-export { DECK_OPTIONS, STAKE_OPTIONS, ANTE_OPTIONS, SLOT_OPTIONS, CLAUSE_TYPES, SOURCE_OPTIONS, EDITION_OPTIONS, SEAL_OPTIONS, ENHANCEMENT_OPTIONS };
-export function useJamlFilter(initialJaml) {
-    const [filter, setFilter] = useState(parseJamlToFilter(initialJaml || ''));
-    const [editingClause, setEditingClause] = useState(null);
-    // useEffect removed to restore previous UX behavior
-    // The JAML from server (Rules format) parses to empty clauses,
-    // causing the UI to lose state after load. we want to keep the initial state.
-    const jamlText = useMemo(() => filterToJaml(filter), [filter]);
-    const updateFilter = useCallback((updates) => {
-        setFilter(prev => ({ ...prev, ...updates }));
-    }, []);
-    const addClause = useCallback((bucket, clause) => {
-        setFilter(prev => ({
-            ...prev,
-            [bucket]: [...prev[bucket], clause]
-        }));
-    }, []);
-    const editClause = useCallback((bucket, index, clause) => {
-        setFilter(prev => ({
-            ...prev,
-            [bucket]: prev[bucket].map((c, i) => i === index ? clause : c)
-        }));
-    }, []);
-    const deleteClause = useCallback((bucket, index) => {
-        setFilter(prev => ({
-            ...prev,
-            [bucket]: prev[bucket].filter((_, i) => i !== index)
-        }));
-    }, []);
-    const setFromJaml = useCallback((text) => {
-        const newFilter = parseJamlToFilter(text);
-        setFilter(newFilter);
-    }, []);
-    return {
-        filter,
-        jamlText,
-        setFromJaml,
-        updateFilter,
-        addClause,
-        editClause,
-        deleteClause,
-        editingClause,
-        setEditingClause
-    };
-}
-function parseJamlToFilter(text) {
-    if (!text.trim())
-        return createBlankFilter();
-    try {
-        const filter = createBlankFilter();
-        // Reset arrays to empty since we are parsing fresh
-        filter.must = [];
-        filter.should = [];
-        filter.mustNot = [];
-        const lines = text.split('\n');
-        let currentSection = null;
-        let currentClause = null;
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            // 1. Detect Section Headers
-            if (trimmed === 'must:') {
-                currentSection = 'must';
-                currentClause = null;
-                continue;
-            }
-            if (trimmed === 'should:') {
-                currentSection = 'should';
-                currentClause = null;
-                continue;
-            }
-            if (trimmed === 'mustNot:') {
-                currentSection = 'mustNot';
-                currentClause = null;
-                continue;
-            }
-            if (trimmed === 'defaults:') {
-                currentSection = 'defaults';
-                continue;
-            }
-            // 2. Detect Root Properties (indent 0)
-            const rootMatch = line.match(/^(\w+):\s*(.+)$/);
-            if (rootMatch && !line.startsWith(' ') && !line.startsWith('-')) {
-                const [, key, val] = rootMatch;
-                if (['name', 'deck', 'stake', 'description', 'author'].includes(key)) {
-                    filter[key] = val.trim();
-                }
-                continue;
-            }
-            // 3. Handle Sections
-            if (currentSection) {
-                if (currentSection === 'defaults') {
-                    const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
-                    if (propMatch) {
-                        const [, key, val] = propMatch;
-                        if (key === 'antes')
-                            filter.defaults.antes = parseNumArray(val);
-                        if (key === 'packSlots')
-                            filter.defaults.packSlots = parseNumArray(val);
-                        if (key === 'shopSlots')
-                            filter.defaults.shopSlots = parseNumArray(val);
-                        if (key === 'score')
-                            filter.defaults.score = parseInt(val) || 0;
-                    }
-                }
-                else {
-                    // Start of new clause
-                    const typeMatch = trimmed.match(/^-\s*type:\s*(.+)$/);
-                    if (typeMatch) {
-                        currentClause = { type: typeMatch[1].trim(), value: '' };
-                        filter[currentSection].push(currentClause);
-                        continue;
-                    }
-                    // Properties of current clause
-                    if (currentClause) {
-                        const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
-                        if (propMatch) {
-                            const [, key, val] = propMatch;
-                            if (key === 'antes')
-                                currentClause.antes = parseNumArray(val);
-                            else if (key === 'sources')
-                                currentClause.sources = parseStringArray(val);
-                            else if (key === 'score')
-                                currentClause.score = parseInt(val) || 0;
-                            else
-                                currentClause[key] = val.trim();
-                        }
-                    }
-                }
-            }
-        }
-        return filter;
-    }
-    catch (e) {
-        console.warn('JAML Parse Error:', e);
-        return createBlankFilter();
-    }
-}
-function parseNumArray(str) {
-    return str.replace(/[[\]]/g, '').split(',').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
-}
-function parseStringArray(str) {
-    return str.replace(/[[\]]/g, '').split(',').map(s => s.trim()).filter(s => !!s);
-}
-function filterToJaml(filter) {
-    const lines = [];
-    lines.push(`name: ${filter.name}`);
-    lines.push(`description: ${filter.description || ''}`);
-    lines.push(`author: ${filter.author || ''}`);
-    lines.push(`deck: ${filter.deck}`);
-    lines.push(`stake: ${filter.stake}`);
-    lines.push('');
-    lines.push('defaults:');
-    lines.push(`  antes: [${filter.defaults.antes.join(', ')}]`);
-    lines.push(`  packSlots: [${filter.defaults.packSlots.join(', ')}]`);
-    lines.push(`  shopSlots: [${filter.defaults.shopSlots.join(', ')}]`);
-    lines.push(`  score: ${filter.defaults.score}`);
-    lines.push('');
-    if (filter.must.length > 0) {
-        lines.push('must:');
-        filter.must.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
-    }
-    if (filter.should.length > 0) {
-        lines.push('should:');
-        filter.should.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
-    }
-    if (filter.mustNot.length > 0) {
-        lines.push('mustNot:');
-        filter.mustNot.forEach(clause => lines.push(...clauseToLines(clause, '  ')));
-    }
-    return lines.join('\n');
-}
-function clauseToLines(clause, indent) {
-    const lines = [];
-    lines.push(`${indent}- type: ${clause.type}`);
-    lines.push(`${indent}  value: ${clause.value}`);
-    if (clause.label)
-        lines.push(`${indent}  label: ${clause.label}`);
-    if (clause.antes && clause.antes.length > 0)
-        lines.push(`${indent}  antes: [${clause.antes.join(', ')}]`);
-    if (clause.score)
-        lines.push(`${indent}  score: ${clause.score}`);
-    if (clause.edition)
-        lines.push(`${indent}  edition: ${clause.edition}`);
-    if (clause.seal)
-        lines.push(`${indent}  seal: ${clause.seal}`);
-    if (clause.enhancement)
-        lines.push(`${indent}  enhancement: ${clause.enhancement}`);
-    if (clause.rank)
-        lines.push(`${indent}  rank: ${clause.rank}`);
-    if (clause.suit)
-        lines.push(`${indent}  suit: ${clause.suit}`);
-    if (clause.sources && clause.sources.length > 0)
-        lines.push(`${indent}  sources: [${clause.sources.join(', ')}]`);
-    return lines;
-}
-function createBlankFilter() {
-    return {
-        name: 'New Filter',
-        description: '',
-        author: '',
-        deck: 'Erratic',
-        stake: 'White',
-        defaults: {
-            antes: [...ANTE_OPTIONS],
-            packSlots: [...SLOT_OPTIONS],
-            shopSlots: [...SLOT_OPTIONS],
-            score: 1
-        },
-        must: [],
-        should: [
-            { type: 'joker', value: 'Joker' }
-        ],
-        mustNot: []
-    };
-}

package/dist/lib/hooks/useSeedAnalyzer.js

@@ -1,50 +0,0 @@
-"use client";
-import { useState, useEffect } from "react";
-export function useSeedAnalyzer(motely, seed) {
-    const [data, setData] = useState(null);
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [prevInputs, setPrevInputs] = useState({ seed, motely });
-    if (seed !== prevInputs.seed || motely !== prevInputs.motely) {
-        setPrevInputs({ seed, motely });
-        if (!seed || seed === "LOCKED" || !motely) {
-            setData(null);
-        }
-    }
-    useEffect(() => {
-        if (!seed || seed === "LOCKED" || !motely) {
-            return;
-        }
-        const abortController = new AbortController();
-        const runAnalysis = async () => {
-            setLoading(true);
-            setError(null);
-            try {
-                const jaml = `version: 1\nconfig:\n  deck: Erratic\n  stake: White\n`;
-                const rawResult = motely.MotelyWasm.analyzeJamlSeeds(jaml, [seed]);
-                if (abortController.signal.aborted)
-                    return;
-                if (rawResult && rawResult.seeds.length > 0) {
-                    const result = rawResult.seeds[0];
-                    setData(result.analysis || null);
-                }
-                else {
-                    throw new Error("No analysis result returned");
-                }
-            }
-            catch (err) {
-                if (abortController.signal.aborted)
-                    return;
-                console.error("[useSeedAnalyzer] Analysis error:", err);
-                setError(err instanceof Error ? err.message : String(err));
-            }
-            finally {
-                if (!abortController.signal.aborted)
-                    setLoading(false);
-            }
-        };
-        runAnalysis();
-        return () => abortController.abort();
-    }, [motely, seed]);
-    return { data, loading, error };
-}

package/dist/lib/jaml/jamlCompletion.js

@@ -1,13 +0,0 @@
-import { JAML_KEYWORDS } from './jamlData';
-export class JamlCompletionService {
-    static getCompletions(currentValue) {
-        const lower = currentValue.toLowerCase();
-        return JAML_KEYWORDS
-            .filter(k => k.toLowerCase().includes(lower))
-            .map(k => ({
-            text: k,
-            displayText: k,
-            type: 'keyword'
-        }));
-    }
-}

package/dist/lib/jaml/jamlData.js

@@ -1,6 +0,0 @@
-import { CLAUSE_TYPE_KEYS } from './jamlSchema.js';
-export const CLAUSE_TYPES = [...CLAUSE_TYPE_KEYS];
-export const ARRAY_KEYS = ['antes', 'tags', 'labels'];
-export const JAML_KEYWORDS = [
-    'must', 'should', 'mustNot', 'any', 'Any', ...CLAUSE_TYPES, ...ARRAY_KEYS
-];

package/dist/lib/jaml/jamlObjectives.js

@@ -1,97 +0,0 @@
-/**
- * JAML Objectives Parser
- *
- * Extracts display-ready objective names from a JAML config string
- * using the existing useJamlFilter parser — no hand-rolled regex.
- *
- * This is the ONLY place JAML → objective extraction should happen.
- */
-/**
- * Parse a JAML config string and extract objectives (must-clause values).
- * Returns an array of human-readable objective names.
- */
-export function parseJamlToObjectives(jamlConfig) {
-    if (!jamlConfig.trim())
-        return [];
-    const objectives = [];
-    const lines = jamlConfig.split('\n');
-    let inMustBlock = false;
-    let currentClause = null;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        // Section headers
-        if (trimmed === 'must:') {
-            inMustBlock = true;
-            currentClause = null;
-            continue;
-        }
-        if (trimmed === 'should:' || trimmed === 'mustNot:' || trimmed === 'defaults:') {
-            // Flush current clause before leaving must block
-            if (inMustBlock && currentClause) {
-                const name = currentClause.label || currentClause.value;
-                if (name)
-                    objectives.push(name);
-            }
-            inMustBlock = false;
-            currentClause = null;
-            continue;
-        }
-        if (!inMustBlock)
-            continue;
-        // New clause (starts with -)
-        if (trimmed.startsWith('-')) {
-            // Flush previous clause
-            if (currentClause) {
-                const name = currentClause.label || currentClause.value;
-                if (name)
-                    objectives.push(name);
-            }
-            currentClause = {};
-            // Parse inline key:value on same line as dash
-            const inlineMatch = trimmed.match(/^-\s*(\w+):\s*(.+)$/);
-            if (inlineMatch) {
-                const [, key, val] = inlineMatch;
-                if (key === 'type')
-                    currentClause.type = val.trim();
-                else if (key === 'value')
-                    currentClause.value = val.trim();
-                else if (key === 'label')
-                    currentClause.label = val.trim();
-                else {
-                    // Shorthand: `- joker: Blueprint` means type=joker, value=Blueprint
-                    currentClause.type = key;
-                    currentClause.value = val.trim();
-                }
-            }
-            continue;
-        }
-        // Properties of current clause (indented, no dash)
-        if (currentClause) {
-            const propMatch = trimmed.match(/^(\w+):\s*(.+)$/);
-            if (propMatch) {
-                const [, key, val] = propMatch;
-                if (key === 'value')
-                    currentClause.value = val.trim();
-                else if (key === 'label')
-                    currentClause.label = val.trim();
-                else if (key === 'type')
-                    currentClause.type = val.trim();
-                else if (!currentClause.value && key !== 'antes' && key !== 'score' && key !== 'sources' && key !== 'edition' && key !== 'seal' && key !== 'enhancement') {
-                    // Shorthand values like `joker: Blueprint` inside a clause
-                    // Only use as value if we don't already have one
-                    currentClause.type = currentClause.type || key;
-                    currentClause.value = val.trim();
-                }
-            }
-        }
-    }
-    // Flush final clause
-    if (inMustBlock && currentClause) {
-        const name = currentClause.label || currentClause.value;
-        if (name)
-            objectives.push(name);
-    }
-    return objectives;
-}

package/dist/lib/jaml/jamlParser.js

@@ -1,47 +0,0 @@
-/**
- * Simple regex-based JAML parser for extracting highlighting rules.
- * Handles basic YAML structure:
- * Must:
- *   - joker: WeeJoker
- * Should:
- *   - joker: HangingChad
- */
-export function parseJamlHighlights(jamlContent) {
-    const rules = {
-        highPriority: new Set(),
-        mediumPriority: new Set()
-    };
-    if (!jamlContent)
-        return rules;
-    const lines = jamlContent.split('\n');
-    let currentSection = null;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('Must:')) {
-            currentSection = 'Must';
-            continue;
-        }
-        if (trimmed.startsWith('Should:')) {
-            currentSection = 'Should';
-            continue;
-        }
-        // Look for "- joker: Name" or "- souljoker: Name"
-        const jokerMatch = trimmed.match(/- (?:joker|souljoker): (.+)/);
-        if (jokerMatch) {
-            const name = jokerMatch[1].trim();
-            // Normalize: "WeeJoker" -> "Wee Joker" if needed? 
-            // Blueprint output usually has spaces "Wee Joker". 
-            // JAML uses "WeeJoker".
-            // We'll normalize by removing spaces for comparison.
-            const normalized = name.replace(/\s+/g, '').toLowerCase();
-            if (currentSection === 'Must')
-                rules.highPriority.add(normalized);
-            if (currentSection === 'Should')
-                rules.mediumPriority.add(normalized);
-        }
-    }
-    return rules;
-}
-export function normalizeName(name) {
-    return name.replace(/\s+/g, '').toLowerCase();
-}

package/dist/lib/jaml/jamlPresets.js

@@ -1,61 +0,0 @@
-export const JAML_PRESETS = [
-    {
-        id: 'soul-hunter',
-        label: 'Soul Hunter',
-        description: 'Find a Spectral Soul card in early Antes.',
-        jaml: `# The Soul Hunter
-name: Soul Hunter
-deck: Red
-stake: White
-
-must:
-  - spectralCard: The Soul
-    antes: [1, 2, 3]
-`
-    },
-    {
-        id: 'negative-blueprint',
-        label: 'Negative Blueprint',
-        description: 'Find a Negative Blueprint early.',
-        jaml: `# Negative Blueprint
-name: Negative Blueprint
-deck: Red
-stake: White
-
-must:
-  - joker: Blueprint
-    edition: Negative
-    antes: [1, 2, 3, 4]
-`
-    },
-    {
-        id: 'mega-tags',
-        label: 'Mega Tags',
-        description: 'Find a lot of Investment and Double Tags.',
-        jaml: `# Mega Tags
-name: Mega Tags
-deck: Red
-stake: White
-
-must:
-  - tag: Double Tag
-    antes: [1, 2]
-  - tag: Investment Tag
-    antes: [1, 2]
-`
-    },
-    {
-        id: 'black-hole',
-        label: 'Black Hole',
-        description: 'Find the elusive Black Hole spectral card.',
-        jaml: `# Black Hole
-name: Black Hole
-deck: Red
-stake: White
-
-must:
-  - spectralCard: Black Hole
-    antes: [1, 2, 3, 4]
-`
-    }
-];

package/dist/lib/jaml/jamlSchema.js

@@ -1,91 +0,0 @@
-/**
- * JAML Schema Bridge
- *
- * Derives all JAML schema constants from motely-wasm/jaml.schema.json.
- * All JAML-aware files import from here — single swap point if the API changes.
- */
-import jamlSchemaJson from '../../../jaml.schema.json';
-const schema = jamlSchemaJson;
-const clauseDef = schema.definitions?.clause?.properties ?? {};
-export const JAML_SCHEMA_VERSION = schema.version ?? 'unknown';
-/** The raw JSON schema object. */
-export const jamlSchema = schema;
-// ── Key groups ─────────────────────────────────────────────────────────────
-/** Root-level metadata keys (name, author, deck, etc.) */
-export const METADATA_KEYS = [
-    'id', 'name', 'description', 'author', 'dateCreated',
-    'deck', 'stake', 'seeds', 'hashtags', 'aesthetics', 'defaults',
-];
-/** Section keys that contain clause arrays. */
-export const SECTION_KEYS = ['must', 'should', 'mustNot'];
-/** Clause type keys — the primary discriminators (joker, voucher, tarot, etc.). */
-export const CLAUSE_TYPE_KEYS = (clauseDef.type?.enum ?? []);
-/** Property keys available inside a clause. */
-export const PROPERTY_KEYS = Object.keys(clauseDef);
-/** Source-configuration keys (shopItems, boosterPacks, etc.). */
-export const SOURCE_KEYS = (() => {
-    const srcProps = clauseDef.sources?.properties;
-    return srcProps ? Object.keys(srcProps) : ['shopItems', 'boosterPacks'];
-})();
-// ── Value lookups ──────────────────────────────────────────────────────────
-/**
- * Get the valid enum values for a given JAML key.
- * Checks top-level properties first, then falls back to clause properties.
- */
-export function getValidValuesForKey(key) {
-    // Top-level enum (deck, stake)
-    const topProp = schema.properties?.[key];
-    if (topProp?.enum)
-        return topProp.enum;
-    if (topProp?.items?.enum)
-        return topProp.items.enum;
-    // Clause-level enum
-    const clauseProp = clauseDef[key];
-    if (clauseProp?.enum)
-        return clauseProp.enum;
-    if (clauseProp?.items?.enum)
-        return clauseProp.items.enum;
-    return null;
-}
-/**
- * Get the available properties for a given clause type.
- * Returns all clause property keys (the type system doesn't restrict per-type in JSON schema v7).
- */
-export function getAvailablePropsForType( /* _clauseType */) {
-    return PROPERTY_KEYS;
-}
-/**
- * Check if a property is invalid for a clause type.
- * In the v7 schema, all properties are available on all clause types.
- */
-export function isInvalidPropForType( /* _prop, _clauseType */) {
-    return false;
-}
-/**
- * Check if a value is invalid for a property.
- */
-export function isInvalidValueForProp(value, prop) {
-    const valid = getValidValuesForKey(prop);
-    if (!valid)
-        return false; // No enum constraint — anything goes
-    return !valid.includes(value);
-}
-// ── Convenience lookups ────────────────────────────────────────────────────
-export const DECK_VALUES = (getValidValuesForKey('deck') ?? []);
-export const STAKE_VALUES = (getValidValuesForKey('stake') ?? []);
-export const EDITION_VALUES = (getValidValuesForKey('edition') ?? []);
-export const SEAL_VALUES = (getValidValuesForKey('seal') ?? []);
-export const ENHANCEMENT_VALUES = (getValidValuesForKey('enhancement') ?? []);
-export const RANK_VALUES = (getValidValuesForKey('rank') ?? []);
-export const SUIT_VALUES = (getValidValuesForKey('suit') ?? []);
-export const STICKER_VALUES = (getValidValuesForKey('stickers') ?? []);
-/**
- * All JAML keywords — sections, metadata keys, clause types, and property keys.
- */
-export const ALL_JAML_KEYWORDS = [
-    ...SECTION_KEYS,
-    ...METADATA_KEYS,
-    ...CLAUSE_TYPE_KEYS,
-    ...PROPERTY_KEYS,
-    ...SOURCE_KEYS,
-];

package/dist/lib/parseDailyRitual.js

@@ -1,70 +0,0 @@
-/**
- * Parser for daily_ritual.json abbreviated format
- *
- * Expands abbreviated fields like "wj2", "hc1" into full item objects
- */
-// Mapping of abbreviations to full item data
-const ITEM_MAP = {
-    wj: { id: 'weejoker', name: 'Wee Joker', type: 'joker' },
-    hc: { id: 'hangingchad', name: 'Hanging Chad', type: 'joker' },
-    hk: { id: 'hack', name: 'Hack', type: 'joker' },
-    bp: { id: 'blueprint', name: 'Blueprint', type: 'joker' },
-    bs: { id: 'brainstorm', name: 'Brainstorm', type: 'joker' },
-    sh: { id: 'showman', name: 'Showman', type: 'joker' },
-    cp: { id: 'copy', name: 'Copy', type: 'consumable' }, // Placeholder
-    // Add more as needed
-};
-/**
- * Parse daily_ritual.json seed format
- *
- * Example input:
- * {"id":"J4SPZMWW","t":"Twosday","j":"Joker","s":206,"w":16,"wj2":1,"hc2":1}
- *
- * Output:
- * {
- *   seed: "J4SPZMWW",
- *   title: "Twosday",
- *   score: 206,
- *   twos: 16,
- *   items: [
- *     { id: 'weejoker', name: 'Wee Joker', type: 'joker', ante: 2 },
- *     { id: 'hangingchad', name: 'Hanging Chad', type: 'joker', ante: 2 }
- *   ]
- * }
- */
-export function parseDailyRitualSeed(raw) {
-    const items = [];
-    // Parse each field looking for pattern: letters + number (e.g., "wj2", "hc1")
-    Object.keys(raw).forEach(key => {
-        if (key === 'id' || key === 't' || key === 's' || key === 'w')
-            return;
-        const match = key.match(/^([a-z]+)(\d+)$/);
-        if (match) {
-            const [, code, ante] = match;
-            const itemData = ITEM_MAP[code];
-            if (itemData) {
-                items.push({
-                    ...itemData,
-                    ante: Number(ante)
-                });
-            }
-        }
-    });
-    return {
-        seed: raw.id || '',
-        title: raw.t || '',
-        score: raw.s || 0,
-        twos: raw.w || 0,
-        items
-    };
-}
-/**
- * Group items by type for rendering
- */
-export function groupItemsByType(items) {
-    return {
-        jokers: items.filter(i => i.type === 'joker'),
-        consumables: items.filter(i => i.type === 'consumable'),
-        vouchers: items.filter(i => i.type === 'voucher')
-    };
-}

package/dist/lib/tts/getRevealPos.js

@@ -1,16 +0,0 @@
-/**
- * Advance past trailing punctuation and whitespace so reveal snaps to word boundaries.
- * Used by both JammySpeechBox (home announcement) and ChatInterface (streaming chat).
- */
-export function getRevealPos(text, highlightPos) {
-    if (highlightPos <= 0)
-        return 0;
-    if (highlightPos >= text.length)
-        return text.length;
-    let i = highlightPos;
-    while (i < text.length && /[)\]}'"'\u2018\u2019.,!?;:]/.test(text[i]))
-        i++;
-    while (i < text.length && /\s/.test(text[i]))
-        i++;
-    return i;
-}