@cspell/eslint-plugin 7.3.6 → 7.3.7

package/README.md

@@ -84,16 +84,46 @@ interface Options {
    */
   checkComments?: boolean;
   /**
-   * CSpell settings
-   *
-   * @words - list of words to be always considered correct
-   *
-   * @ignoreWords - a list of words to be ignored (even if they are in the flagWords)
-   *
-   * @flagWords - a list of words to be always considered incorrect, unless ignored.
-   *
+   * Some CSpell Settings
    */
-  cSpell?: { words?: string[]; ignoreWords?: string[]; flagWords?: string[] };
+  cspell?: {
+    /** List of words to be considered correct. */
+    words?: string[];
+    /**
+     * List of words to be ignored.
+     * An ignored word will not show up as an error, even if it is also
+     * in the `flagWords`.
+     */
+    ignoreWords?: string[];
+    /**
+     * List of words to always be considered incorrect.
+     * Words found in `flagWords` override `words`.
+     * Format of `flagWords`
+     * - single word entry - `word`
+     * - with suggestions - `word:suggestion` or `word->suggestion, suggestions`
+     */
+    flagWords?: string[];
+    /**
+     * List of regular expression patterns or pattern names to exclude
+     * from spell checking.
+     */
+    ignoreRegExpList?: string[];
+    /**
+     * List of regular expression patterns or defined pattern names to
+     * match for spell checking.
+     * If this property is defined, only text matching the included
+     * patterns will be checked.
+     */
+    includeRegExpList?: string[];
+    /** Allows words to be glued together. */
+    allowCompoundWords?: boolean;
+    /** Import cspell config file. */
+    import?: string[];
+    /** List of dictionaries to enable */
+    dictionaries?: string[];
+    /** Define dictionaries. */
+    dictionaryDefinitions?: DictionaryDefinition[];
+  };
   /**
    * Specify a path to a custom word list file.
    *

package/assets/options.schema.json

@@ -50,60 +50,62 @@
           },
           "type": "array"
         },
-        "dictionaryDefinition": {
-          "additionalProperties": false,
-          "properties": {
-            "description": {
-              "description": "Optional description.",
-              "type": "string"
-            },
-            "name": {
-              "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`.",
-              "pattern": "^(?=[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$",
-              "type": "string"
-            },
-            "noSuggest": {
-              "description": "Indicate that suggestions should not come from this dictionary. Words in this dictionary are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in this dictionary, it will be removed from the set of possible suggestions.",
-              "type": "boolean"
-            },
-            "path": {
-              "description": "Path to the file.",
-              "pattern": "^.*\\.(?:txt|trie)(?:\\.gz)?$",
-              "type": "string"
-            },
-            "repMap": {
-              "description": "Replacement pairs.",
-              "items": {
+        "dictionaryDefinitions": {
+          "items": {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "description": "Optional description.",
+                "type": "string"
+              },
+              "name": {
+                "description": "This is the name of a dictionary.\n\nName Format:\n- Must contain at least 1 number or letter.\n- Spaces are allowed.\n- Leading and trailing space will be removed.\n- Names ARE case-sensitive.\n- Must not contain `*`, `!`, `;`, `,`, `{`, `}`, `[`, `]`, `~`.",
+                "pattern": "^(?=[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$",
+                "type": "string"
+              },
+              "noSuggest": {
+                "description": "Indicate that suggestions should not come from this dictionary. Words in this dictionary are considered correct, but will not be used when making spell correction suggestions.\n\nNote: if a word is suggested by another dictionary, but found in this dictionary, it will be removed from the set of possible suggestions.",
+                "type": "boolean"
+              },
+              "path": {
+                "description": "Path to the file.",
+                "type": "string"
+              },
+              "repMap": {
+                "description": "Replacement pairs.",
                 "items": {
-                  "type": "string"
+                  "items": {
+                    "type": "string"
+                  },
+                  "maxItems": 2,
+                  "minItems": 2,
+                  "type": "array"
                 },
-                "maxItems": 2,
-                "minItems": 2,
                 "type": "array"
               },
-              "type": "array"
-            },
-            "type": {
-              "default": "S",
-              "description": "Type of file:\n- S - single word per line,\n- W - each line can contain one or more words separated by space,\n- C - each line is treated like code (Camel Case is allowed).\n\nDefault is S.\n\nC is the slowest to load due to the need to split each line based upon code splitting rules.",
-              "enum": [
-                "S",
-                "W",
-                "C",
-                "T"
-              ],
-              "type": "string"
+              "type": {
+                "default": "S",
+                "description": "Type of file:\n- S - single word per line,\n- W - each line can contain one or more words separated by space,\n- C - each line is treated like code (Camel Case is allowed).\n\nDefault is S.\n\nC is the slowest to load due to the need to split each line based upon code splitting rules.",
+                "enum": [
+                  "S",
+                  "W",
+                  "C",
+                  "T"
+                ],
+                "type": "string"
+              },
+              "useCompounds": {
+                "description": "Use Compounds.",
+                "type": "boolean"
+              }
             },
-            "useCompounds": {
-              "description": "Use Compounds.",
-              "type": "boolean"
-            }
+            "required": [
+              "name",
+              "path"
+            ],
+            "type": "object"
           },
-          "required": [
-            "name",
-            "path"
-          ],
-          "type": "object"
+          "type": "array"
         },
         "enabled": {
           "default": true,
@@ -189,8 +191,7 @@
       "description": "Specify a path to a custom word list file.\n\nexample: ```js customWordListFile: \"./myWords.txt\" ```"
     },
     "debugMode": {
-      "default": false,
-      "description": "Output debug logs",
+      "description": "Output debug logs to `.cspell-eslint-plugin.log` default false",
       "type": "boolean"
     },
     "generateSuggestions": {

package/dist/common/logger.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultLogger = exports.Logger = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const debugMode = false;
+class Logger {
+    constructor(options) {
+        this.options = options;
+        this.logToFile = true;
+        this.enabled = true;
+        this.useAsync = false;
+        this.log = this._log.bind(this);
+        this.cwd = path_1.default.resolve(options.cwd || '.');
+        const logFileBasename = options.logFile || '.cspell-eslint-plugin.log';
+        this.logFile = path_1.default.resolve(this.cwd, logFileBasename);
+        this.logToFile = options.logToFile ?? true;
+        this.enabled = options.enabled ?? debugMode;
+        this.useAsync = options.useAsync ?? false;
+    }
+    _log(...p) {
+        if (!this.enabled)
+            return;
+        if (!this.logToFile)
+            return console.log(...p);
+        const message = new Date().toISOString() + ' ' + prefixLines((0, util_1.format)(...p), '  ') + '\n';
+        this.useAsync
+            ? fs_1.default.appendFile(this.logFile, message, (err) => err && console.error(err))
+            : fs_1.default.appendFileSync(this.logFile, message);
+        return;
+    }
+}
+exports.Logger = Logger;
+let logger;
+function getDefaultLogger() {
+    if (logger)
+        return logger;
+    logger = new Logger({});
+    return logger;
+}
+exports.getDefaultLogger = getDefaultLogger;
+function prefixLines(text, prefix, startIndex = 1) {
+    return text
+        .split('\n')
+        .map((line, index) => (index >= startIndex ? prefix + line : line))
+        .map((line) => (line.trim() == '' ? '' : line))
+        .join('\n');
+}
+//# sourceMappingURL=logger.cjs.map

package/dist/common/logger.d.cts

@@ -0,0 +1,22 @@
+export interface LoggerOptions {
+    logFile?: string;
+    cwd?: string;
+    /** true - write to file, false - output to console. */
+    logToFile?: boolean;
+    /** enable logging by default? */
+    enabled?: boolean;
+    useAsync?: boolean;
+}
+export declare class Logger {
+    readonly options: LoggerOptions;
+    readonly logFile: string;
+    readonly cwd: string;
+    logToFile: boolean;
+    enabled: boolean;
+    useAsync: boolean;
+    constructor(options: LoggerOptions);
+    private _log;
+    log: (message?: any, ...optionalParams: any[]) => void;
+}
+export declare function getDefaultLogger(): Logger;
+//# sourceMappingURL=logger.d.cts.map

package/dist/common/options.d.cts

@@ -17,16 +17,16 @@ export interface Options extends Check {
      */
     autoFix: boolean;
     /**
-     * Output debug logs
-     * @default false
+     * Output debug logs to `.cspell-eslint-plugin.log`
+     * default false
      */
     debugMode?: boolean;
 }
 type DictionaryDefinition = DictionaryDefinitionPreferred;
 export type CSpellOptions = Pick<CSpellSettings, 'allowCompoundWords' | 'dictionaries' | 'enabled' | 'flagWords' | 'ignoreWords' | 'ignoreRegExpList' | 'includeRegExpList' | 'import' | 'words'> & {
-    dictionaryDefinition?: DictionaryDefinition;
+    dictionaryDefinitions?: DictionaryDefinition[];
 };
-export type RequiredOptions = Required<Options>;
+export type RequiredOptions = Required<Pick<Options, Exclude<keyof Options, 'debugMode'>>> & Pick<Options, 'debugMode'>;
 export interface Check {
     /**
      * Ignore import and require names

package/dist/plugin/cspell-eslint-plugin.cjs

@@ -4,6 +4,7 @@ exports.configs = exports.rules = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const synckit_1 = require("synckit");
+const logger_cjs_1 = require("../common/logger.cjs");
 const defaultCheckOptions_cjs_1 = require("./defaultCheckOptions.cjs");
 const optionsSchema = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../../assets/options.schema.json'), 'utf8'));
 const schema = optionsSchema;
@@ -25,26 +26,24 @@ const meta = {
     schema: [schema],
 };
 let isDebugMode = false;
-function log(...args) {
-    if (!isDebugMode)
-        return;
-    console.log(...args);
-}
 function nullFix() {
     return null;
 }
 function create(context) {
-    const options = (0, defaultCheckOptions_cjs_1.normalizeOptions)(context.options[0], context.getCwd());
+    const logger = (0, logger_cjs_1.getDefaultLogger)();
+    const log = logger.log;
+    const options = (0, defaultCheckOptions_cjs_1.normalizeOptions)(context.options[0], context.cwd);
     const autoFix = options.autoFix;
-    isDebugMode = options.debugMode || false;
-    isDebugMode && logContext(context);
+    isDebugMode = options.debugMode ?? isDebugMode;
+    logger.enabled = options.debugMode ?? (logger.enabled || isDebugMode);
+    logContext(log, context);
     function reportIssue(issue) {
         const messageId = issue.severity === 'Forbidden' ? 'wordForbidden' : 'wordUnknown';
         const { word, start, end } = issue;
         const data = {
             word,
         };
-        const code = context.getSourceCode();
+        const code = context.sourceCode;
         const startPos = code.getLocFromIndex(start);
         const endPos = code.getLocFromIndex(end);
         const loc = { start: startPos, end: endPos };
@@ -62,7 +61,7 @@ function create(context) {
                 fix: fixFactory(word),
             };
         }
-        log('Suggestions: %o', issue.suggestions);
+        // log('Suggestions: %o', issue.suggestions);
         const issueSuggestions = issue.suggestions;
         const fixable = issueSuggestions?.filter((sug) => !!sug.isPreferred);
         const canFix = fixable?.length === 1;
@@ -82,8 +81,12 @@ function create(context) {
         context.report(des);
     }
     function checkProgram() {
-        const sc = context.getSourceCode();
-        const issues = spellCheck(context.getFilename(), sc.text, sc.ast, options);
+        const sc = context.sourceCode;
+        const { issues, errors } = spellCheck(context.filename, sc.text, sc.ast, options);
+        if (errors && errors.length) {
+            log('errors: %o', errors.map((e) => e.message));
+            errors.forEach((error) => console.error('%s', error.message));
+        }
         issues.forEach((issue) => reportIssue(issue));
     }
     return { Program: checkProgram };
@@ -94,17 +97,15 @@ exports.rules = {
         create,
     },
 };
-function logContext(context) {
-    log('\n\n************************');
-    // log(context.getSourceCode().text);
-    log(`
-
-id: ${context.id}
-cwd: ${context.getCwd()}
-filename: ${context.getFilename()}
-physicalFilename: ${context.getPhysicalFilename()}
-scope: ${context.getScope().type}
-`);
+function logContext(log, context) {
+    log('context: %o', {
+        id: context.id,
+        cwd: context.cwd,
+        filename: context.filename,
+        physicalFilename: context.physicalFilename,
+        scope: context.getScope().type,
+        options: context.options.length === 1 ? context.options[0] : context.options,
+    });
 }
 exports.configs = {
     recommended: {

package/dist/plugin/defaultCheckOptions.cjs

@@ -20,7 +20,6 @@ exports.defaultOptions = {
     ...exports.defaultCheckOptions,
     numSuggestions: 8,
     generateSuggestions: true,
-    debugMode: false,
     autoFix: false,
 };
 function normalizeOptions(opts, cwd) {

package/dist/worker/spellCheck.d.mts

@@ -1,5 +1,5 @@
 import type { Node } from 'estree';
 import type { WorkerOptions } from '../common/options.cjs';
-import type { Issue } from './types.cjs';
-export declare function spellCheck(filename: string, text: string, root: Node, options: WorkerOptions): Promise<Issue[]>;
+import type { SpellCheckResults } from './types.cjs';
+export declare function spellCheck(filename: string, text: string, root: Node, options: WorkerOptions): Promise<SpellCheckResults>;
 //# sourceMappingURL=spellCheck.d.mts.map

package/dist/worker/spellCheck.mjs

@@ -1,7 +1,8 @@
 import assert from 'assert';
-import { createTextDocument, DocumentValidator, refreshDictionaryCache } from 'cspell-lib';
+import { createTextDocument, DocumentValidator, extractImportErrors, getDictionary, refreshDictionaryCache, } from 'cspell-lib';
 import * as path from 'path';
 import { format } from 'util';
+import { getDefaultLogger } from '../common/logger.cjs';
 import { walkTree } from './walkTree.mjs';
 const defaultSettings = {
     patterns: [
@@ -13,19 +14,28 @@ const defaultSettings = {
     // },
     ],
 };
-let isDebugMode = false;
-function log(...args) {
-    if (!isDebugMode)
-        return;
-    console.log(...args);
-}
+const isDebugModeExtended = false;
+const knownConfigErrors = new Set();
 export async function spellCheck(filename, text, root, options) {
+    const logger = getDefaultLogger();
+    const debugMode = options.debugMode || false;
+    logger.enabled = options.debugMode ?? (logger.enabled || isDebugModeExtended);
+    const log = logger.log;
+    log('options: %o', options);
     const toIgnore = new Set();
     const importedIdentifiers = new Set();
-    isDebugMode = options.debugMode || false;
     const validator = getDocValidator(filename, text, options);
     await validator.prepare();
+    log('Settings: %o', validator.settings);
+    const errors = [...validator.errors];
     const issues = [];
+    errors.push(...(await checkSettings()));
+    async function checkSettings() {
+        const finalSettings = validator.getFinalizedDocSettings();
+        const found = await reportConfigurationErrors(finalSettings, knownConfigErrors);
+        found.forEach((err) => (debugMode ? log(err) : log('Error: %s', err.message)));
+        return found;
+    }
     function checkLiteral(node) {
         if (node.type !== 'Literal')
             return;
@@ -257,13 +267,13 @@ export async function spellCheck(filename, text, root, options) {
         return isRequireCall(node.parent) || (node.parent?.type === 'ImportDeclaration' && node.parent.source === node);
     }
     function debugNode(node, value) {
-        if (!isDebugMode)
+        if (!isDebugModeExtended)
             return;
         const val = format('%o', value);
         log(`${inheritanceSummary(node)}: ${val}`);
     }
     walkTree(root, checkNode);
-    return issues;
+    return { issues, errors };
 }
 function tagLiteral(node) {
     assert(node.type === 'Literal');
@@ -288,7 +298,6 @@ function getDocValidator(filename, text, options) {
         cachedValidator.updateDocumentText(text);
         return cachedValidator;
     }
-    isDebugMode = options.debugMode || false;
     const validator = new DocumentValidator(doc, options, settings);
     docValCache.set(doc, validator);
     return validator;
@@ -297,22 +306,35 @@ function calcInitialSettings(options) {
     const { customWordListFile, cspell, cwd } = options;
     const settings = {
         ...defaultSettings,
+        ...cspell,
         words: cspell?.words || [],
         ignoreWords: cspell?.ignoreWords || [],
         flagWords: cspell?.flagWords || [],
     };
     if (customWordListFile) {
         const filePath = isCustomWordListFile(customWordListFile) ? customWordListFile.path : customWordListFile;
-        const dictFile = path.resolve(cwd, filePath);
-        const customWordListSettings = {
-            ...settings,
-            dictionaryDefinitions: [{ name: 'eslint-plugin-custom-words', path: dictFile }],
-            dictionaries: ['eslint-plugin-custom-words'],
-        };
-        return customWordListSettings;
+        const { dictionaries = [], dictionaryDefinitions = [] } = settings;
+        dictionaries.push('eslint-plugin-custom-words');
+        dictionaryDefinitions.push({ name: 'eslint-plugin-custom-words', path: filePath });
+        settings.dictionaries = dictionaries;
+        settings.dictionaryDefinitions = dictionaryDefinitions;
     }
+    resolveDictionaryPaths(settings.dictionaryDefinitions, cwd);
     return settings;
 }
+const regexIsUrl = /^(https?|file|ftp):/i;
+/** Patches the path of dictionary definitions. */
+function resolveDictionaryPaths(defs, cwd) {
+    if (!defs)
+        return;
+    for (const def of defs) {
+        if (!def.path)
+            continue;
+        if (regexIsUrl.test(def.path))
+            continue;
+        def.path = path.resolve(cwd, def.path);
+    }
+}
 function getTextDocument(filename, content) {
     if (cache.lastDoc?.filename === filename) {
         return cache.lastDoc.doc;
@@ -358,4 +380,29 @@ function deepEqual(a, b) {
         return false;
     }
 }
+async function reportConfigurationErrors(config, knownConfigErrors) {
+    const errors = [];
+    const importErrors = extractImportErrors(config);
+    importErrors.forEach((ref) => {
+        const key = ref.error.toString();
+        if (knownConfigErrors.has(key))
+            return;
+        knownConfigErrors.add(key);
+        errors.push(Error('Configuration Error: \n  ' + ref.error.message));
+    });
+    const dictCollection = await getDictionary(config);
+    dictCollection.dictionaries.forEach((dict) => {
+        const dictErrors = dict.getErrors?.() || [];
+        const msg = `Dictionary Error with (${dict.name})`;
+        dictErrors.forEach((error) => {
+            const key = msg + error.toString();
+            if (knownConfigErrors.has(key))
+                return;
+            knownConfigErrors.add(key);
+            const errMsg = `${msg}: ${error.message}\n  Source: ${dict.source}`;
+            errors.push(Error(errMsg));
+        });
+    });
+    return errors;
+}
 //# sourceMappingURL=spellCheck.mjs.map

package/dist/worker/types.d.cts

@@ -24,7 +24,11 @@ export interface Issue {
     suggestions: Suggestions;
     nodeType: NodeType;
 }
-type SpellCheckFn = (filename: string, text: string, root: Node, options: WorkerOptions) => Promise<Issue[]>;
+export interface SpellCheckResults {
+    issues: Issue[];
+    errors?: Error[];
+}
+type SpellCheckFn = (filename: string, text: string, root: Node, options: WorkerOptions) => Promise<SpellCheckResults>;
 export type SpellCheckSyncFn = (...p: Parameters<SpellCheckFn>) => Awaited<ReturnType<SpellCheckFn>>;
 export {};
 //# sourceMappingURL=types.d.cts.map

package/dist/worker/worker.d.mts

@@ -1,4 +1,5 @@
 export type Node = import('estree').Node;
 export type Issue = import('./types.cjs').Issue;
+export type SpellCheckResults = import('./types.cjs').SpellCheckResults;
 export type WorkerOptions = import('../common/options.cjs').WorkerOptions;
 //# sourceMappingURL=worker.d.mts.map

package/dist/worker/worker.mjs

@@ -4,6 +4,7 @@
 /**
  * @typedef {import('estree').Node} Node
  * @typedef {import('./types.cjs').Issue} Issue
+ * @typedef {import('./types.cjs').SpellCheckResults} SpellCheckResults
  * @typedef {import('../common/options.cjs').WorkerOptions} WorkerOptions
  */
 import { runAsWorker } from 'synckit';
@@ -17,7 +18,7 @@ runAsWorker(
  * @param {string} text
  * @param {Node} root
  * @param {WorkerOptions} options
- * @returns {Promise<Issue[]>} The issues found.
+ * @returns {Promise<SpellCheckResults>} The issues found.
  */
 async (filename, text, root, options) => {
     if (!spellChecker) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "7.3.6",
+  "version": "7.3.7",
   "description": "CSpell ESLint plugin",
   "keywords": [
     "cspell",
@@ -17,10 +17,13 @@
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-eslint-plugin#readme",
   "license": "MIT",
   "exports": {
-    "types": "./dist/plugin/index.d.cts",
-    "require": "./dist/plugin/index.cjs",
-    "import": "./dist/plugin/index.cjs",
-    "default": "./dist/plugin/index.cjs"
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/plugin/index.d.cts",
+      "require": "./dist/plugin/index.cjs",
+      "import": "./dist/plugin/index.cjs",
+      "default": "./dist/plugin/index.cjs"
+    }
   },
   "type": "module",
   "main": "dist/plugin/index.cjs",
@@ -38,7 +41,7 @@
     "build": "pnpm build:schema && pnpm build:src",
     "build:src": "tsc -b ./tsconfig.json",
     "build:schema": "ts-json-schema-generator --no-top-ref --expose none --path src/common/options.cts --type Options  -o  ./assets/options.schema.json",
-    "watch": "tsc -p . --watch",
+    "watch": "tsc -b ./tsconfig.json --watch",
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "echo coverage",
@@ -56,23 +59,23 @@
     "node": ">=16"
   },
   "devDependencies": {
-    "@types/eslint": "^8.44.2",
-    "@types/estree": "^1.0.1",
-    "@types/mocha": "^10.0.1",
+    "@types/eslint": "^8.44.3",
+    "@types/estree": "^1.0.2",
+    "@types/mocha": "^10.0.2",
     "@typescript-eslint/parser": "^5.62.0",
-    "@typescript-eslint/types": "^6.7.0",
-    "@typescript-eslint/typescript-estree": "^5.62.0",
-    "eslint": "^8.49.0",
+    "@typescript-eslint/types": "^6.7.3",
+    "@typescript-eslint/typescript-estree": "^6.7.3",
+    "eslint": "^8.50.0",
     "eslint-plugin-react": "^7.33.2",
     "mocha": "^10.2.0",
     "ts-json-schema-generator": "^1.3.0",
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@cspell/cspell-types": "7.3.6",
-    "cspell-lib": "7.3.6",
+    "@cspell/cspell-types": "7.3.7",
+    "cspell-lib": "7.3.7",
     "estree-walker": "^3.0.3",
     "synckit": "^0.8.5"
   },
-  "gitHead": "64ab7715f3f6566c1917084557f2ee415798c6f0"
+  "gitHead": "22246a7924b9ae27ae39f0d0217890a1c2736f68"
 }