cspell-grammar 8.7.0 → 8.8.1

package/dist/app.js

@@ -1,5 +1,5 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
 import { parser as parserTypeScript } from './parsers/typescript/index.js';
 const parsers = {
     '.ts': parserTypeScript,
@@ -15,7 +15,7 @@ export async function run(args) {
         console.log('usage...');
         return;
     }
-    const filename = args.slice(2).filter((p) => !p.startsWith('-'))[0];
+    const filename = args.slice(2).find((p) => !p.startsWith('-'));
     if (!filename) {
         console.log('filename missing');
         return;
@@ -27,14 +27,14 @@ export async function run(args) {
         return;
     }
     console.log(`File: ${path.basename(filename)} Parser: ${parser.name}`);
-    const content = await fs.readFile(filename, 'utf-8');
+    const content = await fs.readFile(filename, 'utf8');
     const result = parser.parse(content, filename);
     for (const pt of result.parsedTexts) {
         emit(pt);
     }
 }
 function emit(pt) {
-    const t = pt.text.replace(/\t/g, '↦').replace(/\r?\n/g, '↩︎').replace(/\r/g, '⇠');
+    const t = pt.text.replaceAll('\t', '↦').replaceAll(/\r?\n/g, '↩︎').replaceAll('\r', '⇠');
     console.log(`${pt.range[0]}-${pt.range[1]}\t${t}\t${pt.scope?.toString() || ''}`);
 }
 //# sourceMappingURL=app.js.map

package/dist/mappers/appendMappedText.js

@@ -1,12 +1,12 @@
-import assert from 'assert';
+import assert from 'node:assert';
 export function appendMappedText(a, b) {
     if (!a.map && !b.map) {
         return { text: a.text + b.text };
     }
     const aLen = a.text.length;
     const bLen = b.text.length;
-    const aMap = [0, 0].concat(a.map || [0, 0, aLen, aLen]);
-    const bMap = [0, 0].concat(b.map || [0, 0, bLen, bLen]);
+    const aMap = [0, 0, ...(a.map || [0, 0, aLen, aLen])];
+    const bMap = [0, 0, ...(b.map || [0, 0, bLen, bLen])];
     assert(aMap[aMap.length - 1] === aLen);
     assert(bMap[bMap.length - 1] === bLen);
     assert((aMap.length & 1) === 0);
@@ -19,7 +19,7 @@ export function appendMappedText(a, b) {
 function joinMaps(aMap, bMap) {
     const n = aMap.length - 1;
     const offsets = [aMap[n - 1], aMap[n]];
-    const ab = aMap.concat(bMap.map((v, i) => v + offsets[i & 1]));
+    const ab = [...aMap, ...bMap.map((v, i) => v + offsets[i & 1])];
     // Normalize the map by removing duplicate entries
     const r = [0, 0];
     let last0 = 0, last1 = 0;

package/dist/mappers/typescript.js

@@ -55,14 +55,14 @@ export function mapRawString(text) {
                 continue;
             }
             switch (tc) {
-                case 'u':
+                case 'u': {
                     {
                         let char;
                         let end;
                         if (text[i + 1] !== '{') {
                             const digits = text.slice(i + 1, i + 5);
-                            parsed = isHex.test(digits) ? parseInt(digits, 16) : NaN;
-                            char = isNaN(parsed) ? '' : String.fromCharCode(parsed);
+                            parsed = isHex.test(digits) ? Number.parseInt(digits, 16) : Number.NaN;
+                            char = Number.isNaN(parsed) ? '' : String.fromCodePoint(parsed);
                             end = i + 4;
                         }
                         else {
@@ -74,8 +74,8 @@ export function mapRawString(text) {
                             }
                             else {
                                 const digits = text.slice(i + 2, end);
-                                parsed = isHex.test(digits) ? parseInt(digits, 16) : NaN;
-                                char = isNaN(parsed) ? '' : String.fromCodePoint(parsed);
+                                parsed = isHex.test(digits) ? Number.parseInt(digits, 16) : Number.NaN;
+                                char = Number.isNaN(parsed) ? '' : String.fromCodePoint(parsed);
                             }
                         }
                         if (!char) {
@@ -89,38 +89,45 @@ export function mapRawString(text) {
                         }
                     }
                     break;
-                case 'x':
+                }
+                case 'x': {
                     {
                         const digits = text.slice(i + 1, i + 3);
-                        parsed = isHex.test(digits) ? parseInt(digits, 16) : NaN;
-                        if (isNaN(parsed)) {
+                        parsed = isHex.test(digits) ? Number.parseInt(digits, 16) : Number.NaN;
+                        if (Number.isNaN(parsed)) {
                             // give up, it is not valid
                             t += tc;
                             j += 1;
                         }
                         else {
-                            t += String.fromCharCode(parsed);
+                            t += String.fromCodePoint(parsed);
                             i += 2;
                             ++j;
                         }
                     }
                     break;
-                case '0':
+                }
+                case '0': {
                     // Deprecated in ES5
                     t += '0';
                     j += 1;
                     break;
-                case '\r':
+                }
+                case '\r': {
                     i += text[i + 1] === '\n' ? 1 : 0;
                     break;
-                case '\n':
+                }
+                case '\n': {
                     break;
-                case undefined:
+                }
+                case undefined: {
                     break;
-                default:
+                }
+                default: {
                     t += tc;
                     ++j;
                     break;
+                }
             }
             map.push(i + 1, j);
             continue;

package/dist/parser/matchResult.js

@@ -28,11 +28,7 @@ export function segmentMatch(mr) {
         const s = value && textToSeg.get(value);
         if (!s)
             continue;
-        s.groupName = s.groupName
-            ? Array.isArray(s.groupName)
-                ? s.groupName.concat([name])
-                : [s.groupName, name]
-            : name;
+        s.groupName = s.groupName ? (Array.isArray(s.groupName) ? [...s.groupName, name] : [s.groupName, name]) : name;
     }
     return segments;
 }

package/dist/parser/scope.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 export class Scope {
     value;
     parent;

package/dist/parser/tokenizeLine.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { extractScope } from './grammarNormalizer.js';
 import { applyCaptureToBeginOrMatch, applyCaptureToEnd } from './processors/procMatchingRule.js';
 export function tokenizeLine(line, rule) {

package/dist/parser/validateGrammar.js

@@ -1,5 +1,5 @@
-import { strict as assert } from 'assert';
-import { format } from 'util';
+import { strict as assert } from 'node:assert';
+import { format } from 'node:util';
 import { isPatternBeginEnd, isPatternInclude, isPatternMatch, isPatternPatterns } from './grammarTypesHelpers.js';
 export function validate(grammar) {
     assert(grammar.scopeName);

package/dist/viewer/escapeMarkdown.js

@@ -21,7 +21,7 @@ function _escape(str, r) {
     r.lastIndex = 0;
     while (r.test(str)) {
         const i = r.lastIndex - 1;
-        html += str.substring(lastIndex, i) + cvt[str.charCodeAt(i)];
+        html += str.substring(lastIndex, i) + (cvt[str.codePointAt(i) || 0] || '');
         lastIndex = r.lastIndex;
     }
     return html + str.substring(lastIndex);
@@ -33,7 +33,10 @@ function compileEntities(entityMap) {
         result[i] = `&#${i};`;
     }
     for (const [char, entity] of Object.entries(entityMap)) {
-        result[char.charCodeAt(0)] = entity;
+        const index = char.codePointAt(0);
+        if (!index)
+            continue;
+        result[index] = entity;
     }
     return result;
 }

package/dist/viewer/markdownHelper.js

@@ -1,5 +1,5 @@
 import { escapeMarkdown } from './escapeMarkdown.js';
 export function toInlineCode(text) {
-    return `<code>${escapeMarkdown(text.replace(/\r/g, '↤').replace(/\n/g, '↩'))}</code>`;
+    return `<code>${escapeMarkdown(text.replaceAll('\r', '↤').replaceAll('\n', '↩'))}</code>`;
 }
 //# sourceMappingURL=markdownHelper.js.map

package/dist/viewer/visualizeAsMD.js

@@ -5,8 +5,7 @@ export function _tokenizedLineToMarkdown(line, indentation = '') {
 
   | text      | scope                                                    |
   | --------- | -------------------------------------------------------- |`;
-    markdownLines.push(...header.split('\n'));
-    markdownLines.push(...line.tokens.map((t) => `  | ${toInlineCode(t.text)} | ${t.scope} |`));
+    markdownLines.push(...header.split('\n'), ...line.tokens.map((t) => `  | ${toInlineCode(t.text)} | ${t.scope} |`));
     return markdownLines.map((line) => indentation + line).join('\n') + '\n\n';
 }
 export function tokenizedLineToMarkdown(line, indentation = '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-grammar",
-  "version": "8.7.0",
+  "version": "8.8.1",
   "description": "Grammar parsing support for cspell",
   "keywords": [
     "cspell",
@@ -62,12 +62,12 @@
   ],
   "scripts": {
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
-    "build": "tsc -b .",
+    "build": "tsc -b . -f",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "test": "vitest run",
-    "watch": "tsc -b . -w"
+    "watch": "tsc -b . -w -f"
   },
   "repository": {
     "type": "git",
@@ -84,8 +84,8 @@
     "jest": "^29.7.0"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "8.7.0",
-    "@cspell/cspell-types": "8.7.0"
+    "@cspell/cspell-pipe": "8.8.1",
+    "@cspell/cspell-types": "8.8.1"
   },
-  "gitHead": "5318079ed11fe77e981287ecf1c40d6f28dd91ed"
+  "gitHead": "6381846ffce8b9a349bfda03262297aa8e301ef5"
 }