@heartlandone/vega 2.78.0 → 2.80.0

package/dist/collection/polyfill/libphonenumber/test/metadata.test.js

@@ -1,196 +0,0 @@
-import { META, getCountryCallingCode, getCountries, getFormats, detectCallingCode, getCountryByNationalNumber, } from '../metadata';
-// ---------------------------------------------------------------------------
-// META singleton
-// ---------------------------------------------------------------------------
-describe('META singleton', () => {
-  it('should have a version number', () => {
-    expect(META.version).toBeDefined();
-    expect(typeof META.version).toBe('number');
-  });
-  it('should contain countryCallingCode mapping', () => {
-    expect(META.countryCallingCode).toBeDefined();
-    expect(META.countryCallingCode['1']).toContain('US');
-  });
-  it('should contain countries mapping', () => {
-    expect(META.countries).toBeDefined();
-    expect(META.countries['US']).toBeDefined();
-  });
-});
-// ---------------------------------------------------------------------------
-// getCountryCallingCode
-// ---------------------------------------------------------------------------
-describe('getCountryCallingCode', () => {
-  it('should return "1" for US', () => {
-    expect(getCountryCallingCode('US')).toBe('1');
-  });
-  it('should return "44" for GB', () => {
-    expect(getCountryCallingCode('GB')).toBe('44');
-  });
-  it('should return "86" for CN', () => {
-    expect(getCountryCallingCode('CN')).toBe('86');
-  });
-  it('should return "49" for DE', () => {
-    expect(getCountryCallingCode('DE')).toBe('49');
-  });
-  it('should return "61" for AU', () => {
-    expect(getCountryCallingCode('AU')).toBe('61');
-  });
-  it('should throw for unknown country', () => {
-    expect(() => getCountryCallingCode('ZZ')).toThrow('Unknown country: ZZ');
-  });
-});
-// ---------------------------------------------------------------------------
-// getCountries
-// ---------------------------------------------------------------------------
-describe('getCountries', () => {
-  it('should return an array of country codes', () => {
-    const countries = getCountries();
-    expect(Array.isArray(countries)).toBe(true);
-    expect(countries.length).toBeGreaterThan(0);
-  });
-  it('should include common countries', () => {
-    const countries = getCountries();
-    expect(countries).toContain('US');
-    expect(countries).toContain('GB');
-    expect(countries).toContain('CN');
-    expect(countries).toContain('DE');
-    expect(countries).toContain('JP');
-  });
-});
-// ---------------------------------------------------------------------------
-// getFormats
-// ---------------------------------------------------------------------------
-describe('getFormats', () => {
-  it('should return format rules for US', () => {
-    const formats = getFormats('US');
-    expect(formats).toBeDefined();
-    expect(Array.isArray(formats)).toBe(true);
-    const definedFormats = formats;
-    expect(definedFormats.length).toBeGreaterThan(0);
-  });
-  it('should return format rules for GB', () => {
-    const formats = getFormats('GB');
-    expect(formats).toBeDefined();
-    const definedFormats = formats;
-    expect(definedFormats.length).toBeGreaterThan(0);
-  });
-  it('should inherit formats from primary country for NANPA siblings', () => {
-    // CA and VI share calling code '1' with US and have no own formats
-    const caFormats = getFormats('CA');
-    const usFormats = getFormats('US');
-    expect(caFormats).toBeDefined();
-    // CA inherits from US, so they should be the same formats
-    expect(caFormats).toEqual(usFormats);
-  });
-  it('should return undefined for unknown country', () => {
-    const formats = getFormats('ZZ');
-    expect(formats).toBeUndefined();
-  });
-  it('should return format tuples with correct structure', () => {
-    const formats = getFormats('US');
-    expect(formats).toBeDefined();
-    const definedFormats = formats;
-    const firstFormat = definedFormats[0];
-    // [0] pattern (string), [1] replacement (string), [2] leadingDigitsPatterns (string[])
-    expect(typeof firstFormat[0]).toBe('string');
-    expect(typeof firstFormat[1]).toBe('string');
-    expect(Array.isArray(firstFormat[2])).toBe(true);
-  });
-});
-// ---------------------------------------------------------------------------
-// detectCallingCode
-// ---------------------------------------------------------------------------
-describe('detectCallingCode', () => {
-  it('should detect US calling code from digits starting with 1', () => {
-    const result = detectCallingCode('13023334444');
-    expect(result.callingCode).toBe('1');
-    expect(result.countries).toContain('US');
-  });
-  it('should detect UK calling code from digits starting with 44', () => {
-    const result = detectCallingCode('447911123456');
-    expect(result.callingCode).toBe('44');
-    expect(result.countries).toContain('GB');
-  });
-  it('should detect CN calling code from digits starting with 86', () => {
-    const result = detectCallingCode('8613812345678');
-    expect(result.callingCode).toBe('86');
-    expect(result.countries).toContain('CN');
-  });
-  it('should detect 3-digit calling codes (e.g., 375 for BY)', () => {
-    const result = detectCallingCode('375291234567');
-    expect(result.callingCode).toBe('375');
-    expect(result.countries).toContain('BY');
-  });
-  it('should return undefined for unrecognized digits', () => {
-    const result = detectCallingCode('');
-    expect(result.callingCode).toBeUndefined();
-    expect(result.countries).toBeUndefined();
-  });
-  it('should return NANPA countries for calling code 1', () => {
-    const result = detectCallingCode('1');
-    expect(result.callingCode).toBe('1');
-    expect(result.countries).toBeDefined();
-    const definedCountries = result.countries;
-    expect(definedCountries.length).toBeGreaterThan(1);
-    expect(result.countries).toContain('US');
-  });
-});
-// ---------------------------------------------------------------------------
-// getCountryByNationalNumber
-// ---------------------------------------------------------------------------
-describe('getCountryByNationalNumber', () => {
-  it('should distinguish VI from US by leading digits 340', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    const nanpaCountries = META.countryCallingCode['1'];
-    // eslint-disable-next-line spellcheck/spell-checker
-    expect(nanpaCountries).toBeDefined();
-    // eslint-disable-next-line spellcheck/spell-checker
-    const country = getCountryByNationalNumber(nanpaCountries, '3405100000');
-    expect(country).toBe('VI');
-  });
-  it('should distinguish PR from US by leading digits 787/939', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    const nanpaCountries = META.countryCallingCode['1'];
-    // eslint-disable-next-line spellcheck/spell-checker
-    const country = getCountryByNationalNumber(nanpaCountries, '7871234567');
-    expect(country).toBe('PR');
-  });
-  it('should fall back to type-based matching when no leading digits', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    const nanpaCountries = META.countryCallingCode['1'];
-    // eslint-disable-next-line spellcheck/spell-checker
-    const country = getCountryByNationalNumber(nanpaCountries, '2025551234');
-    // US numbers with area code 202 should match US
-    expect(country).toBeDefined();
-  });
-  it('should return undefined when no country matches', () => {
-    const country = getCountryByNationalNumber(['US'], '');
-    expect(country).toBeUndefined();
-  });
-  it('should skip non-existent countries in first pass', () => {
-    // 'FAKE' does not exist in META.countries — the loop should skip it via `if (!entry) continue`
-    const country = getCountryByNationalNumber(['FAKE', 'VI'], '3405100000');
-    expect(country).toBe('VI');
-  });
-  it('should skip non-existent countries in second pass', () => {
-    // 'FAKE' is checked in both passes — first pass skips (no entry), second pass also skips
-    // US has no leadingDigits so it falls to second pass for type matching
-    const country = getCountryByNationalNumber(['FAKE', 'US'], '2025551234');
-    expect(country).toBe('US');
-  });
-  it('should return country from first-pass leading digits match', () => {
-    // VI has leadingDigits '340'. When possibleCountries includes VI
-    // and nationalNumber starts with 340, the first pass matches and returns VI.
-    // eslint-disable-next-line spellcheck/spell-checker
-    const country = getCountryByNationalNumber(['VI', 'US'], '3405100000');
-    expect(country).toBe('VI');
-  });
-  it('should not match leading digits when nationalNumber is empty', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    const country = getCountryByNationalNumber(['VI', 'US'], '');
-    // VI has leadingDigits '340' but nationalNumber '' fails the check
-    // Falls through to second pass, US has no leadingDigits → type matching
-    // Empty string won't match US type patterns either
-    expect(country).toBeUndefined();
-  });
-});

package/dist/collection/polyfill/libphonenumber/test/parse-phone-number.test.js

@@ -1,218 +0,0 @@
-import { parseIncompletePhoneNumber, parsePhoneNumber } from '../parse-phone-number';
-// ---------------------------------------------------------------------------
-// parseIncompletePhoneNumber
-// ---------------------------------------------------------------------------
-describe('parseIncompletePhoneNumber', () => {
-  it('should strip non-digit characters', () => {
-    expect(parseIncompletePhoneNumber('(302) 333-4444')).toBe('3023334444');
-  });
-  it('should keep a leading +', () => {
-    expect(parseIncompletePhoneNumber('+1 (302) 333-4444')).toBe('+13023334444');
-  });
-  it('should only keep the first + (at position 0)', () => {
-    expect(parseIncompletePhoneNumber('1+2+3')).toBe('123');
-  });
-  it('should return empty string for empty input', () => {
-    expect(parseIncompletePhoneNumber('')).toBe('');
-  });
-  it('should return "+" for input containing only "+"', () => {
-    expect(parseIncompletePhoneNumber('+')).toBe('+');
-  });
-  it('should strip letters and special characters', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    expect(parseIncompletePhoneNumber('abc 123 def 456')).toBe('123456');
-  });
-  it('should handle input with only non-digit characters', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    expect(parseIncompletePhoneNumber('abc def')).toBe('');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — international format (+)
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (international)', () => {
-  it('should parse a US number with country code', () => {
-    const phoneNumber = parsePhoneNumber('+1 (302) 333-4444');
-    expect(phoneNumber.countryCallingCode).toBe('1');
-    expect(phoneNumber.nationalNumber).toBe('3023334444');
-    expect(phoneNumber.country).toBe('US');
-  });
-  it('should parse a GB number', () => {
-    const phoneNumber = parsePhoneNumber('+44 2012345678');
-    expect(phoneNumber.countryCallingCode).toBe('44');
-    expect(phoneNumber.nationalNumber).toBe('2012345678');
-    // Calling code 44 is shared by GB/GG/JE/IM; country resolved by type matching
-    expect(phoneNumber.country).toBeDefined();
-  });
-  it('should parse a CN number', () => {
-    const phoneNumber = parsePhoneNumber('+86 138 1234 5678');
-    expect(phoneNumber.countryCallingCode).toBe('86');
-    expect(phoneNumber.nationalNumber).toBe('13812345678');
-    expect(phoneNumber.country).toBe('CN');
-  });
-  it('should parse a DE number', () => {
-    const phoneNumber = parsePhoneNumber('+49 30 12345678');
-    expect(phoneNumber.countryCallingCode).toBe('49');
-    expect(phoneNumber.country).toBe('DE');
-  });
-  it('should detect VI by leading digits 340', () => {
-    const phoneNumber = parsePhoneNumber('+1 340 510 0000');
-    expect(phoneNumber.country).toBe('VI');
-    expect(phoneNumber.nationalNumber).toBe('3405100000');
-  });
-  it('should detect PR by leading digits 787', () => {
-    const phoneNumber = parsePhoneNumber('+1 787 123 4567');
-    expect(phoneNumber.country).toBe('PR');
-  });
-  // eslint-disable-next-line spellcheck/spell-checker
-  it('should strip NANPA trunk prefix when parsing +1 with 11 digits starting with 1', () => {
-    const phoneNumber = parsePhoneNumber('+113405100000');
-    expect(phoneNumber.country).toBe('VI');
-    expect(phoneNumber.nationalNumber).toBe('3405100000');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — national format (with defaultCountry)
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (national / defaultCountry)', () => {
-  it('should parse a US national number with default country', () => {
-    const phoneNumber = parsePhoneNumber('(302) 333-4444', 'US');
-    expect(phoneNumber.countryCallingCode).toBe('1');
-    expect(phoneNumber.nationalNumber).toBe('3023334444');
-    expect(phoneNumber.country).toBe('US');
-  });
-  it('should parse a GB national number', () => {
-    const phoneNumber = parsePhoneNumber('07911 123456', {
-      defaultCountry: 'GB',
-    });
-    expect(phoneNumber.countryCallingCode).toBe('44');
-    expect(phoneNumber.country).toBe('GB');
-  });
-  // eslint-disable-next-line spellcheck/spell-checker
-  it('should detect NANPA sibling country in national mode', () => {
-    // 340 area code → VI
-    const phoneNumber = parsePhoneNumber('3405100000', 'US');
-    expect(phoneNumber.country).toBe('VI');
-  });
-  // eslint-disable-next-line spellcheck/spell-checker
-  it('should strip NANPA trunk prefix 1 from 11-digit national number', () => {
-    const phoneNumber = parsePhoneNumber('13405100000', 'US');
-    expect(phoneNumber.nationalNumber).toBe('3405100000');
-    expect(phoneNumber.country).toBe('VI');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — national format with unique calling code
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (unique calling code)', () => {
-  it('should fall back to defaultCountry when calling code has no siblings', () => {
-    // DE has calling code 49, which is unique (not shared with other countries)
-    const phoneNumber = parsePhoneNumber('3012345678', 'DE');
-    expect(phoneNumber.countryCallingCode).toBe('49');
-    expect(phoneNumber.country).toBe('DE');
-  });
-  it('should use defaultCountry for CN national number', () => {
-    // CN has calling code 86, unique
-    const phoneNumber = parsePhoneNumber('13812345678', 'CN');
-    expect(phoneNumber.countryCallingCode).toBe('86');
-    expect(phoneNumber.country).toBe('CN');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — national prefix extraction
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (return with resolved country and number)', () => {
-  it('should return a PhoneNumber for a country without nationalPrefixForParsing', () => {
-    // KR (South Korea) has no nationalPrefixForParsing (entry[7] is falsy),
-    // so the prefix-extraction block is skipped entirely and execution
-    // falls through to the final return statement.
-    const phoneNumber = parsePhoneNumber('+82 10 1234 5678');
-    expect(phoneNumber.countryCallingCode).toBe('82');
-    expect(phoneNumber.country).toBe('KR');
-    expect(phoneNumber.nationalNumber).toBe('1012345678');
-  });
-});
-describe('parsePhoneNumber (national prefix extraction)', () => {
-  it('should strip national prefix when stripped version matches but original does not', () => {
-    // GB has nationalPrefixForParsing = '0' (entry[7]).
-    // If we parse a GB national number starting with '0', the prefix '0' is matched.
-    // '07911123456': original '07911123456' fails validation (starts with 0),
-    // afterPrefix '7911123456' passes validation → nationalNumber = '7911123456'
-    const phoneNumber = parsePhoneNumber('07911123456', 'GB');
-    expect(phoneNumber.countryCallingCode).toBe('44');
-    expect(phoneNumber.country).toBe('GB');
-    expect(phoneNumber.nationalNumber).toBe('7911123456');
-  });
-  it('should NOT strip prefix if original already matches validation', () => {
-    // A CN number that already matches validation shouldn't have prefix stripped
-    const phoneNumber = parsePhoneNumber('+8613812345678');
-    expect(phoneNumber.country).toBe('CN');
-    expect(phoneNumber.nationalNumber).toBe('13812345678');
-  });
-  it('should not strip when afterPrefix is empty', () => {
-    // If the entire national number IS the prefix match, afterPrefix = ''
-    // strippedMatches should be false (afterPrefix.length > 0 fails)
-    // Use IT which has nationalPrefixForParsing. Parse a number where the
-    // entire string matches the prefix pattern but nothing is left after.
-    // Simplest: use a defaultCountry with prefix, where the number = prefix.
-    // GB prefix is '0'. Parsing '0' as national GB: prefix '0' matched,
-    // afterPrefix is '', strippedMatches is false, number stays '0'.
-    const phoneNumber = parsePhoneNumber('0', 'GB');
-    expect(phoneNumber.nationalNumber).toBe('0');
-  });
-  it('should not strip when prefix match length is 0', () => {
-    // Some nationalPrefixForParsing patterns can match zero-length strings.
-    // The code checks match[0].length > 0. If 0, the block is skipped entirely.
-    // JP has nationalPrefixForParsing = '0' which shouldn't match zero-length
-    // but a number not starting with '0' simply won't match → block skipped
-    const phoneNumber = parsePhoneNumber('3012345678', 'JP');
-    expect(phoneNumber.nationalNumber).toBe('3012345678');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — error handling
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (errors)', () => {
-  it('should throw NOT_A_NUMBER for empty input', () => {
-    expect(() => parsePhoneNumber('')).toThrow('NOT_A_NUMBER');
-  });
-  it('should throw NOT_A_NUMBER for just "+"', () => {
-    expect(() => parsePhoneNumber('+')).toThrow('NOT_A_NUMBER');
-  });
-  it('should throw NOT_A_NUMBER for non-numeric text', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    expect(() => parsePhoneNumber('abc')).toThrow('NOT_A_NUMBER');
-  });
-  it('should throw INVALID_COUNTRY when no + and no defaultCountry', () => {
-    expect(() => parsePhoneNumber('3023334444')).toThrow('INVALID_COUNTRY');
-  });
-  it('should throw INVALID_COUNTRY for unrecognized calling code', () => {
-    expect(() => parsePhoneNumber('+99999999999')).toThrow('INVALID_COUNTRY');
-  });
-  it('should throw NOT_A_NUMBER with extract=false when input contains letters', () => {
-    // eslint-disable-next-line spellcheck/spell-checker
-    expect(() => parsePhoneNumber('abc123', { extract: false })).toThrow('NOT_A_NUMBER');
-  });
-});
-// ---------------------------------------------------------------------------
-// parsePhoneNumber — options object
-// ---------------------------------------------------------------------------
-describe('parsePhoneNumber (options)', () => {
-  it('should accept string shorthand for defaultCountry', () => {
-    const phoneNumber = parsePhoneNumber('2025551234', 'US');
-    expect(phoneNumber.country).toBe('US');
-  });
-  it('should accept options object with defaultCountry', () => {
-    const phoneNumber = parsePhoneNumber('2025551234', {
-      defaultCountry: 'US',
-    });
-    expect(phoneNumber.country).toBe('US');
-  });
-  it('should accept options with extract=true (default)', () => {
-    const phoneNumber = parsePhoneNumber('Call me at 2025551234', {
-      defaultCountry: 'US',
-      extract: true,
-    });
-    expect(phoneNumber.nationalNumber).toBe('2025551234');
-  });
-});

package/dist/collection/polyfill/libphonenumber/test/phone-number.test.js

@@ -1,56 +0,0 @@
-import { PhoneNumber } from '../phone-number';
-// ---------------------------------------------------------------------------
-// Constructor & properties
-// ---------------------------------------------------------------------------
-describe('PhoneNumber', () => {
-  describe('constructor and properties', () => {
-    it('should store countryCallingCode, nationalNumber, and country', () => {
-      const phoneNumber = new PhoneNumber('1', '3023334444', 'US');
-      expect(phoneNumber.countryCallingCode).toBe('1');
-      expect(phoneNumber.nationalNumber).toBe('3023334444');
-      expect(phoneNumber.country).toBe('US');
-    });
-    it('should allow undefined country', () => {
-      const phoneNumber = new PhoneNumber('1', '3023334444');
-      expect(phoneNumber.country).toBeUndefined();
-    });
-  });
-  // -----------------------------------------------------------------------
-  // isValid()
-  // -----------------------------------------------------------------------
-  describe('isValid', () => {
-    it('should return true for a valid US number', () => {
-      const phoneNumber = new PhoneNumber('1', '2025551234', 'US');
-      expect(phoneNumber.isValid()).toBe(true);
-    });
-    it('should return false for a too-short US number', () => {
-      const phoneNumber = new PhoneNumber('1', '20255', 'US');
-      expect(phoneNumber.isValid()).toBe(false);
-    });
-    it('should return false for a too-long US number', () => {
-      const phoneNumber = new PhoneNumber('1', '20255512345678', 'US');
-      expect(phoneNumber.isValid()).toBe(false);
-    });
-    it('should return false when country is undefined', () => {
-      const phoneNumber = new PhoneNumber('1', '2025551234');
-      expect(phoneNumber.isValid()).toBe(false);
-    });
-    it('should return true for a valid GB number', () => {
-      const phoneNumber = new PhoneNumber('44', '7911123456', 'GB');
-      expect(phoneNumber.isValid()).toBe(true);
-    });
-    it('should return true for a valid CN mobile number', () => {
-      const phoneNumber = new PhoneNumber('86', '13812345678', 'CN');
-      expect(phoneNumber.isValid()).toBe(true);
-    });
-    it('should return false when national number does not match validation pattern', () => {
-      // US numbers cannot start with 0 or 1 in area code
-      const phoneNumber = new PhoneNumber('1', '0005551234', 'US');
-      expect(phoneNumber.isValid()).toBe(false);
-    });
-    it('should return false when country is not in metadata', () => {
-      const phoneNumber = new PhoneNumber('1', '2025551234', 'ZZ');
-      expect(phoneNumber.isValid()).toBe(false);
-    });
-  });
-});

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

@@ -1,61 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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();
-  });
-});