eyeleng 1.0.6 → 1.0.7

package/README.md

@@ -3,38 +3,146 @@
 [![npm version](https://img.shields.io/npm/v/eyeleng.svg)](https://www.npmjs.com/package/eyeleng)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20342577-blue.svg)](https://doi.org/10.5281/zenodo.20342577)
 
-`eyeleng` stands for **EYE Logic Engine**. Eyeleng is a JavaScript implementation of SHACL 1.2 Rules, including SRL and RDF Rules syntax front-ends.
+`eyeleng` stands for **EYE Logic Engine**. It is a compact JavaScript implementation of SHACL 1.2 Rules with two rule front-ends:
+
+- **SRL** — the Shape Rules Language syntax used by the SHACL 1.2 Rules draft.
+- **RDF Rules** — a Turtle/RDF syntax for rule sets.
+
+Eyeleng is a forward-chaining reasoner over RDF-style triples. It is deliberately small, dependency-free at runtime, readable as ordinary JavaScript, and usable from the CLI, Node.js, and the browser playground.
+
+Eyeleng implements the rules/reasoning surface. It is **not** a SHACL validation engine and does not emit SHACL validation reports.
 
 ## Quick start
 
 ```sh
+npm install
 npm test
 ./eyeleng.js examples/family.srl
-./eyeleng.js examples/spec-2-2-recursion.srl
-./eyeleng.js examples/deep-taxonomy-100.srl
+./eyeleng.js --all examples/family.srl
 ./eyeleng.js examples/basic-ruleset.ttl
-./eyeleng.js --syntax rdf examples/w3c-rule-set-snippet.ttl
 ./eyeleng.js --check --deps examples/stratified-negation.srl
 ```
 
-## Read next
+A minimal SRL program:
+
+```srl
+PREFIX : <http://example/>
+
+DATA {
+  :Socrates a :Man .
+}
+
+RULE { ?x a :Mortal } WHERE { ?x a :Man }
+```
+
+It derives:
+
+```srl
+:Socrates a :Mortal .
+```
+
+Open the [Playground](https://eyereasoner.github.io/eyeleng/playground) for a self-contained browser UI with URL loading, autosave, share links, diagnostics, queries, and SRL/RDF Rules syntax selection.
+
+## How the reasoner works
+
+Eyeleng computes the closure of a rule set:
+
+```text
+parse source
+analyze dependencies and strata
+match rule bodies against known triples
+instantiate rule heads
+add new triples
+repeat until stable
+```
+
+A rule has a body and a head:
+
+```srl
+RULE { ?child :childOf ?parent } WHERE { ?parent :parentOf ?child }
+```
+
+If the graph contains:
+
+```srl
+:alice :parentOf :bob .
+```
+
+then the body matches with `?parent = :alice` and `?child = :bob`, and the head derives:
+
+```srl
+:bob :childOf :alice .
+```
+
+Negation is handled by stratified evaluation: rules are grouped into dependency layers, and recursion through negation is rejected so the result stays deterministic.
+
+## Language surface
+
+SRL supports the practical rule features used by the SHACL 1.2 Rules tests and examples:
+
+```srl
+PREFIX : <http://example/>
+
+DATA {
+  :alice :score 7 .
+  :bob :score 3 .
+}
+
+RULE { ?x :grade ?grade } WHERE {
+  ?x :score ?score .
+  FILTER(?score >= 5) .
+  BIND(concat("pass-", str(?score)) AS ?grade)
+}
+
+RULE { ?x :eligible true } WHERE {
+  ?x :grade ?grade .
+  NOT { ?x :blocked true . }
+}
+```
+
+Implemented syntax includes:
+
+- `PREFIX`, `BASE`, `VERSION`, and `IMPORTS`
+- `DATA`, `RULE`, `WHERE`, `FILTER`, `BIND`, `SET`, and `NOT`
+- variables such as `?x`
+- IRIs, prefixed names, blank nodes, literals, RDF collections, and RDF 1.2 triple terms
+- Turtle-style `;`, `,`, `a`, blank-node property lists, lists, annotations, and reifiers where supported
+- property paths in rule bodies
+- language tags, base-direction literals, and common XML Schema datatypes
+- SRL and RDF Rules syntax front-ends
+
+The RDF parsing path is shared with the W3C RDF syntax harness, so SRL `DATA { ... }` uses the same grammar-hardened RDF parser surface as Turtle/TriG input.
 
-Read [Handbook](https://eyereasoner.github.io/eyeleng/HANDBOOK) for the full explanation of Eyeleng as code and as a reasoning machine.
+## Builtins and expressions
 
-Open [Playground](https://eyereasoner.github.io/eyeleng/playground) for a self-contained browser playground with URL loading, autosave, share links, diagnostics, queries, and SRL/RDF Rules syntax selection.
+`FILTER`, `BIND`, and `SET` use expression evaluation. Supported operations include comparisons, boolean operators, arithmetic, `IN`, `NOT IN`, datatype/language checks, string functions, numeric functions, and selected date/time helpers.
 
-`npm run build` writes the command-line bundle to `eyeleng.js` and the browser API bundle to `dist/browser/eyeleng.browser.js`. In a browser, the bundle exposes the API as `window.eyeleng`.
+Common builtins include:
 
-The examples live in [examples/](./examples/) at one level. Draft SRL examples are named `spec-*.srl`, RDF Rules syntax examples use `.ttl`, and deep taxonomy benchmarks are named `deep-taxonomy-*.srl`.
+```text
+str, concat, lcase, ucase, replace
+abs, round, floor, ceil
+datatype, lang, iri, uri
+now, year, month, day
+```
+
+The goal is useful SHACL Rules/SRL behavior, not complete SPARQL expression coverage.
 
-Status: Eyeleng runs a growing implementation of the SHACL 1.2 Rules draft surface. It does not implement SHACL validation.
+## RDF 1.2 features
 
-The official Eyeleng EARL 1.0 test report for the W3C SHACL 1.2 Rules manifest is in [reports/w3c-shacl12-rules-earl.ttl](./reports/w3c-shacl12-rules-earl.ttl). It records 88/88 passing tests for `https://w3c.github.io/data-shapes/shacl12-test-suite/tests/rules/manifest-rules.ttl`.
+Eyeleng includes grammar-hardened RDF 1.1/1.2 parsing support in `src/rdfSyntax.js` and W3C manifest runners in `src/rdfManifest.js` / `src/rdfEntailment.js`.
 
+Covered surfaces include:
 
-## W3C RDF syntax and semantics manifests
+- N-Triples and N-Quads
+- Turtle and TriG
+- RDF 1.2 triple terms
+- reifiers and annotation blocks
+- language-direction literals
+- graph isomorphism for blank nodes
+- simple, RDF, and RDFS entailment checks for RDF-MT / RDF 1.2 Semantics manifests
 
-Eyeleng now integrates the grammar-hardened RDF syntax work into its normal `src/rdfSyntax.js` / `src/rdfManifest.js` structure, and adds a small RDF/RDFS entailment runner in `src/rdfEntailment.js`. The W3C RDF checks are therefore part of the same parser/reasoner discipline as the RDF Rules front-end.
+W3C checks:
 
 ```sh
 npm run w3c:rules
@@ -44,10 +152,9 @@ npm run w3c:rdf:json
 npm run w3c:rdf:earl
 ```
 
-`npm test` includes both W3C harnesses. When the W3C URLs are reachable, progress is printed test by test. In offline environments, the remote W3C checks are reported as unreachable unless `EYELENG_W3C_REQUIRED=1` is set.
-
-The RDF harness covers N-Triples, N-Quads, Turtle, and TriG RDF 1.1/1.2 parser syntax/eval manifests, plus the RDF-MT and RDF 1.2 Semantics entailment manifests. Entailment tests are evaluated under their declared `mf:entailmentRegime` (`simple`, `RDF`, or `RDFS`) with their declared recognized datatypes.
+`npm test` includes the W3C harnesses. When W3C URLs are reachable, progress is printed test by test. In offline environments, remote W3C checks are reported as unreachable unless `EYELENG_W3C_REQUIRED=1` is set.
 
+The official Eyeleng EARL 1.0 report for the W3C SHACL 1.2 Rules manifest is in [reports/w3c-shacl12-rules-earl.ttl](./reports/w3c-shacl12-rules-earl.ttl).
 
 ## RDF Message Logs
 
@@ -64,7 +171,7 @@ MESSAGE
 _:reading :sensor :s2 .
 ```
 
-Use it directly, import it from SRL, or force message-log parsing from the CLI:
+Use message logs directly, import them from SRL, or force message-log parsing from the CLI:
 
 ```sh
 ./eyeleng.js examples/rdf-messages.srl
@@ -72,4 +179,154 @@ Use it directly, import it from SRL, or force message-log parsing from the CLI:
 ./eyeleng.js --stream-messages --all examples/rdf-messages.trig
 ```
 
-The replay data includes `eymsg:RDFMessageStream`, `eymsg:MessageEnvelope`, offsets, next-envelope links, payload kind, payload graph, and `eymsg:payloadTriple` triple terms. Blank-node labels are scoped per message. For Eyeleng, each payload graph is represented as a closed list of RDF 1.2 triple terms via `log:nameOf`, plus direct `eymsg:payloadTriple` links for convenient SRL rules.
+The replay data includes message streams, envelopes, offsets, next-envelope links, payload kind, payload graph, and `eymsg:payloadTriple` triple terms. Blank-node labels are scoped per message. For Eyeleng, each payload graph is also represented as a closed RDF list of RDF 1.2 triple terms via `log:nameOf`.
+
+## CLI
+
+Common commands:
+
+```sh
+./eyeleng.js examples/family.srl
+./eyeleng.js --all examples/family.srl
+./eyeleng.js --check --deps examples/stratified-negation.srl
+./eyeleng.js --json --trace --stats examples/if-then.srl
+./eyeleng.js --query-file examples/query-body.txt examples/query.srl
+./eyeleng.js --syntax rdf examples/w3c-rule-set-snippet.ttl
+```
+
+Important options:
+
+```text
+--all               print input and inferred triples
+--check             parse and analyze only
+--strict            warnings become fatal
+--deps              print dependency edges and layers
+--trace             show rule firings
+--stats             show iteration and rule counts
+--json              structured output
+--query             run a raw body pattern over the closure
+--query-file FILE   read a query body from a file
+--max-iterations N  recursive-layer fixpoint safety guard
+--no-imports        parse imports but do not load them
+--rdf-messages      parse input as an RDF Message Log
+--stream-messages   replay RDF Message Log envelopes
+```
+
+## Public API
+
+Typical API use:
+
+```js
+const { run, formatTriples } = require('./src/index.js');
+
+const result = run(`
+PREFIX : <http://example/>
+DATA { :Socrates a :Man . }
+RULE { ?x a :Mortal } WHERE { ?x a :Man }
+`);
+
+console.log(formatTriples(result.inferred, result.prefixes));
+```
+
+Query mode:
+
+```js
+const { runQuery, formatBindings } = require('./src/index.js');
+
+const result = runQuery(source, '?x :ancestorOf ?y');
+console.log(formatBindings(result.query.bindings, result.prefixes));
+```
+
+Imports:
+
+```js
+const result = run(source, {
+  baseIRI: 'file:///main.srl',
+  importResolver(target) {
+    return {
+      source: readSomehow(target),
+      options: { baseIRI: target, filename: target }
+    };
+  }
+});
+```
+
+The API returns structured parsed programs, diagnostics, inferred triples, closure triples, traces, stats, and query bindings.
+
+## Project layout
+
+```text
+src/tokenizer.js      source text -> tokens
+src/parser.js         SRL parser -> program object
+src/rdfSyntax.js      RDF 1.1/1.2 N-Triples/N-Quads/Turtle/TriG syntax
+src/rdfManifest.js    W3C RDF manifest runner
+src/rdfEntailment.js  simple/RDF/RDFS entailment checks
+src/rdfMessages.js    RDF Message Log replay support
+src/term.js           terms, keys, equality, formatting
+src/store.js          triple set, predicate index, matching, paths
+src/builtins.js       expression evaluation and built-in functions
+src/analyze.js        diagnostics, dependencies, strata
+src/engine.js         layered forward-chaining evaluator
+src/query.js          external raw-body query operation
+src/format.js         text and JSON output
+src/api.js            public JavaScript API and import merging
+src/cli.js            command-line interface
+tools/bundle.js       self-contained bundle generator
+test/*.test.js        executable regression and conformance tests
+examples/*.srl        runnable SRL examples
+examples/*.ttl        RDF Rules / Turtle examples
+```
+
+A good reading order is `term.js`, `tokenizer.js`, `parser.js`, `rdfSyntax.js`, `store.js`, `builtins.js`, `analyze.js`, `engine.js`, then `api.js` and `cli.js`.
+
+## Tests and build
+
+```sh
+npm test
+npm run build
+```
+
+`npm run build` writes the command-line bundle to `eyeleng.js` and the browser API bundle to `dist/browser/eyeleng.browser.js`. In a browser, the bundle exposes `window.eyeleng`.
+
+The tests are executable documentation. They cover parsing, recursion, filters, negation, assignment, typed/language literals, RDF 1.2 syntax, property paths, stratification, imports, queries, examples, deep taxonomy benchmarks, W3C SHACL Rules, W3C RDF syntax, and RDF/RDFS entailment.
+
+## Examples
+
+Examples live in [examples/](./examples/):
+
+- `family.srl` — small recursive rules
+- `negation.srl` — stratified negation
+- `assignment.srl` — assignment and expressions
+- `property-paths.srl` — path matching in bodies
+- `basic-ruleset.ttl` — RDF Rules syntax
+- `rdf-messages.srl` / `rdf-messages.trig` — RDF Message Log replay
+- `deep-taxonomy-*.srl` — generated benchmark programs
+
+## Known boundaries
+
+Eyeleng intentionally remains a compact reasoner:
+
+- it does not implement SHACL validation or validation reports
+- it does not aim to be a full RDF database
+- RDF Rules syntax support is a front-end for rule execution, not a shapes-validation layer
+- property paths and SPARQL expressions are practical subsets
+- W3C manifests are used as executable alignment tests, but implementation status should be read from the current test reports
+
+## Extending Eyeleng safely
+
+Preserve the pipeline:
+
+```text
+syntax -> AST/program -> analysis -> evaluation -> formatting
+```
+
+Avoid making the evaluator parse strings. Parsing belongs in `parser.js` or `rdfSyntax.js`. Avoid making the parser derive triples. Inference belongs in `engine.js`.
+
+A safe extension usually needs:
+
+1. syntax support
+2. one focused example
+3. parser/API tests
+4. execution tests
+5. README or handbook notes
+6. bundle regeneration

package/dist/browser/eyeleng.browser.js

@@ -166,7 +166,7 @@
       
       class Parser {
         constructor(source, options = {}) {
-          this.tokens = Array.isArray(source) ? source : tokenize(source, options.filename);
+          this.tokens = Array.isArray(source) ? source : tokenize(source, options);
           this.pos = 0;
           this.options = options;
           this.baseIRI = options.baseIRI || null;
@@ -229,6 +229,7 @@
           let name = nameToken.value;
           if (!name.endsWith(':')) throw this.error('Prefix name must end with :', nameToken);
           name = name.slice(0, -1);
+          if (this.strictGrammar() && !isValidPNPrefix(name)) throw this.error(`Invalid prefix name ${nameToken.value}`, nameToken);
           const iriToken = this.expectType('iri');
           this.prefixes[name] = this.resolveIRI(iriToken.value, iriToken);
           if (wasAtPrefix) this.consumeOptionalDot();
@@ -236,6 +237,10 @@
       
         parseVersion() {
           const token = this.expectType('string');
+          if (this.strictGrammar()) {
+            if (token.long) throw this.error('VERSION must use a short string literal', token);
+            if (token.value !== '1.2') throw this.error('VERSION must be the SHACL Rules version label \"1.2\"', token);
+          }
           this.version = token.value;
         }
       
@@ -631,6 +636,7 @@
             } else if (this.matchWord('SET')) {
               clauses.push(this.parseSetClause());
             } else if (this.matchWord('BIND')) {
+              if (this.strictGrammar()) throw this.error('BIND is not part of the SHACL 1.2 Rules grammar; use SET');
               clauses.push(this.parseBindClause());
             } else if (this.matchWord('NOT')) {
               this.expectValue('{');
@@ -738,8 +744,9 @@
           if (colon < 0) throw this.error(`Expected IRI, prefixed name, literal, blank node, or variable; got ${value}`, token);
           const prefix = value.slice(0, colon);
           const local = value.slice(colon + 1);
+          if (this.strictGrammar()) validatePrefixedName(prefix, local, value, token, (message, errToken) => this.error(message, errToken));
           if (!(prefix in this.prefixes)) throw this.error(`Unknown prefix ${prefix}:`, token);
-          return this.prefixes[prefix] + local;
+          return this.prefixes[prefix] + decodePNLocalEscapes(local);
         }
       
         resolveIRI(value, token = null) {
@@ -898,9 +905,76 @@
         peek() { return this.tokens[this.pos]; }
         peekN(n) { return this.tokens[this.pos + n] || this.tokens[this.tokens.length - 1]; }
         previous() { return this.tokens[this.pos - 1]; }
+        strictGrammar() { return !!this.options.strictGrammar; }
         error(message, token = this.peek()) { return new SyntaxErrorWithLocation(message, token); }
       }
       
+      
+      function isPnCharsBase(ch) {
+        if (!ch) return false;
+        return /[A-Za-z]/.test(ch) || ch.codePointAt(0) >= 0x00C0;
+      }
+      
+      function isPnCharsU(ch) {
+        return isPnCharsBase(ch) || ch === '_';
+      }
+      
+      function isPnChars(ch) {
+        return isPnCharsU(ch) || /[0-9-]/.test(ch) || ch === '\u00B7' || /[\u0300-\u036F\u203F-\u2040]/u.test(ch);
+      }
+      
+      function isValidPNPrefix(prefix) {
+        if (prefix === '') return true;
+        const chars = Array.from(prefix);
+        if (!isPnCharsBase(chars[0])) return false;
+        if (chars.length > 1 && chars.at(-1) === '.') return false;
+        return chars.slice(1).every((ch) => isPnChars(ch) || ch === '.');
+      }
+      
+      function plxLength(text, index) {
+        const ch = text[index];
+        if (ch === '%' && /[0-9A-Fa-f]/.test(text[index + 1] || '') && /[0-9A-Fa-f]/.test(text[index + 2] || '')) return 3;
+        if (ch === '\\' && /[_~.!$&'()*+,;=/?#@%-]/.test(text[index + 1] || '')) return 2;
+        return 0;
+      }
+      
+      function isPNLocalStartAt(text, index) {
+        const ch = text[index];
+        return isPnCharsU(ch) || /[0-9:]/.test(ch || '') || plxLength(text, index) > 0;
+      }
+      
+      function isPNLocalBodyAt(text, index) {
+        const ch = text[index];
+        return isPnChars(ch) || ch === '.' || ch === ':' || plxLength(text, index) > 0;
+      }
+      
+      function isPNLocalEndAt(text, index) {
+        const ch = text[index];
+        return isPnChars(ch) || ch === ':' || plxLength(text, index) > 0;
+      }
+      
+      function validatePNLocal(local) {
+        if (local === '') return true;
+        if (!isPNLocalStartAt(local, 0)) return false;
+        let lastStart = 0;
+        for (let i = 0; i < local.length;) {
+          const len = plxLength(local, i) || 1;
+          if (i > 0 && !isPNLocalBodyAt(local, i)) return false;
+          lastStart = i;
+          i += len;
+        }
+        return isPNLocalEndAt(local, lastStart);
+      }
+      
+      function validatePrefixedName(prefix, local, value, token, makeError) {
+        if (!isValidPNPrefix(prefix)) throw makeError(`Invalid prefixed name ${value}: invalid prefix`, token);
+        if (!validatePNLocal(local)) throw makeError(`Invalid prefixed name ${value}: invalid local name`, token);
+      }
+      
+      function decodePNLocalEscapes(local) {
+        return String(local).replace(/\\([_~.!$&'()*+,;=/?#@%-])/g, '$1');
+      }
+      
       function numericLiteral(value) {
         if (Number.isInteger(value)) return literal(value, XSD_INTEGER);
         return literal(value, XSD_DECIMAL);
@@ -970,7 +1044,10 @@
         }
       }
       
-      function tokenize(source, filename = '<input>') {
+      function tokenize(source, filenameOrOptions = '<input>') {
+        const options = typeof filenameOrOptions === 'object' && filenameOrOptions !== null ? filenameOrOptions : { filename: filenameOrOptions };
+        const filename = options.filename || '<input>';
+        const strictGrammar = !!options.strictGrammar;
         const tokens = [];
         let i = 0;
         let line = 1;
@@ -985,8 +1062,8 @@
           else column += 1;
           return ch;
         }
-        function token(type, value, startLine, startColumn) {
-          tokens.push({ type, value, line: startLine, column: startColumn, filename });
+        function token(type, value, startLine, startColumn, extra = {}) {
+          tokens.push({ type, value, line: startLine, column: startColumn, filename, ...extra });
         }
         function syntax(message, startLine, startColumn) {
           throw new SyntaxErrorWithLocation(message, { line: startLine, column: startColumn, filename });
@@ -1024,14 +1101,37 @@
             const length = esc === 'u' ? 4 : 8;
             let hex = '';
             for (let j = 0; j < length; j += 1) {
-              if (!/[0-9A-Fa-f]/.test(current() || '')) syntax(`Invalid \${esc} escape`, startLine, startColumn);
+              if (!/[0-9A-Fa-f]/.test(current() || '')) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
               hex += advance();
             }
-            return String.fromCodePoint(Number.parseInt(hex, 16));
+            const codePoint = Number.parseInt(hex, 16);
+            try { return String.fromCodePoint(codePoint); }
+            catch { syntax(`Invalid \\${esc} escape`, startLine, startColumn); }
           }
+          if (strictGrammar && !Object.hasOwn(escapeMap, esc)) syntax(`Invalid escape \\${esc}`, startLine, startColumn);
           return escapeValue(esc);
         }
       
+        function readIriChar(startLine, startColumn) {
+          if (current() === '\\') {
+            advance();
+            const esc = advance();
+            if (esc !== 'u' && esc !== 'U') syntax(`Invalid IRI escape \\${esc}`, startLine, startColumn);
+            const length = esc === 'u' ? 4 : 8;
+            let hex = '';
+            for (let j = 0; j < length; j += 1) {
+              if (!/[0-9A-Fa-f]/.test(current() || '')) syntax(`Invalid \\${esc} escape`, startLine, startColumn);
+              hex += advance();
+            }
+            const codePoint = Number.parseInt(hex, 16);
+            try { return String.fromCodePoint(codePoint); }
+            catch { syntax(`Invalid \\${esc} escape`, startLine, startColumn); }
+          }
+          const c = current();
+          if (strictGrammar && (/[\u0000-\u0020]/.test(c) || /[<>"{}|^`]/.test(c))) syntax(`Invalid character in IRI reference ${JSON.stringify(c)}`, startLine, startColumn);
+          return advance();
+        }
+      
         while (i < source.length) {
           const ch = current();
           if (/\s/.test(ch)) { advance(); continue; }
@@ -1077,7 +1177,7 @@
           if (ch === '<' && looksLikeIRI(source, i)) {
             let value = '';
             advance();
-            while (i < source.length && current() !== '>') value += advance();
+            while (i < source.length && current() !== '>') value += readIriChar(startLine, startColumn);
             if (current() !== '>') syntax('Unterminated IRI', startLine, startColumn);
             advance();
             token('iri', value, startLine, startColumn);
@@ -1097,7 +1197,7 @@
             }
             if (!startsWith(quote.repeat(3))) syntax('Unterminated long string literal', startLine, startColumn);
             advance(); advance(); advance();
-            token('string', value, startLine, startColumn);
+            token('string', value, startLine, startColumn, { long: true, quote });
             continue;
           }
       
@@ -1115,7 +1215,7 @@
             }
             if (current() !== quote) syntax('Unterminated string literal', startLine, startColumn);
             advance();
-            token('string', value, startLine, startColumn);
+            token('string', value, startLine, startColumn, { long: false, quote });
             continue;
           }
       
@@ -1161,7 +1261,16 @@
           let value = '';
           while (i < source.length) {
             const c = current();
-            if (/\s/.test(c) || '{}()[].,;|'.includes(c) || '=<>+-*/!^~'.includes(c)) break;
+            if (c === '\\' && peek() !== undefined) {
+              value += advance();
+              value += advance();
+              continue;
+            }
+            if (/\s/.test(c) || '{}()[],;|'.includes(c) || '=<>+-*/!^~'.includes(c)) break;
+            if (c === '.') {
+              const n = peek();
+              if (n === undefined || /\s/.test(n) || '{}()[],;|'.includes(n) || '=<>+-*/!^~'.includes(n)) break;
+            }
             if (c === '#') break;
             value += advance();
           }
@@ -1194,9 +1303,10 @@
         return false;
       }
       
+      const escapeMap = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', '"': '"', "'": "'", '\\': '\\' };
+      
       function escapeValue(esc) {
-        const map = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', '"': '"', "'": "'", '\\': '\\' };
-        return map[esc] ?? esc;
+        return escapeMap[esc] ?? esc;
       }
       
       module.exports = { tokenize, SyntaxErrorWithLocation };