n3.js-messages 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pieter Colpaert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# n3.js-messages
+
+[RDF Messages](https://w3c-cg.github.io/rsp/spec/messages) for [N3.js](https://github.com/rdfjs/N3.js):
+parse, stream and write message-delimited **Turtle, TriG, N-Triples and N-Quads**, with ordinary RDF/JS `Quad` objects.
+
+## What this package is
+
+An RDF Message Log is an RDF document in which `MESSAGE` delimiters group the triples or quads into *messages*, so that a
+stream of RDF can be written to a file (or a socket) and read again as the same stream of messages.
+This package adds that to N3.js **as an extension**: it depends on the public API of the `n3` package (a peer dependency), and
+does not fork, patch or copy N3.js. The syntax of the statements is still parsed and written by N3.js.
+
+## Status
+
+RDF Messages is a *Living Document* of the [W3C RDF Stream Processing Community Group](https://www.w3.org/community/rsp/);
+it is **not a W3C Recommendation**, and may still change. This package implements the specification of 25 September 2026
+(upstream commit `9c3b947`) and is versioned `0.x` accordingly.
+
+## Installation
+
+```sh
+npm install n3 n3.js-messages
+```
+
+Requires Node.js ≥ 18 and `n3` ≥ 2.0.0 < 3. The package works with `import` and `require`, and ships TypeScript declarations.
+
+## Parsing
+
+```js
+import { parseMessages } from 'n3.js-messages';
+
+const messages = parseMessages(`
+VERSION "1.2-messages"
+PREFIX ex: <http://example.org/>
+
+ex:alice ex:says "Hello" .
+MESSAGE
+ex:bob ex:says "Hi" .
+MESSAGE
+MESSAGE
+ex:carol ex:says "Bye" .
+`, { format: 'Turtle' });
+
+// An array of messages; a message is an array of RDF/JS quads, in document order
+console.log(messages.length);        // 4 (the third message is empty)
+console.log(messages[1][0].object);  // Literal "Hi"
+```
+
+`format` is `'Turtle'`, `'TriG'` (the default), `'N-Triples'` or `'N-Quads'` (or the matching media type).
+Other options: `baseIRI`, `factory` (any RDF/JS `DataFactory`), `blankNodePrefix`, and `version` / `messages: true` to announce
+a message log without a `VERSION` line (for example when the media type says so).
+`MessageParser` offers callbacks instead of an array:
+
+```js
+import { MessageParser } from 'n3.js-messages';
+
+new MessageParser({ format: 'TriG' }).parse(text, {
+  onMessage: (error, message, prefixes, index) => { /* message === null at the end */ },
+  onQuad: (error, quad, messageIndex) => { /* optional */ },
+  onPrefix: (prefix, iri) => {},
+  onVersion: label => {},
+});
+```
+
+Messages are not merged, empty messages are preserved, and quads keep the order of the document.
+A document that does not announce a `-messages` version is one message, and a delimiter in it is an error.
+
+## Streaming
+
+`MessageStreamParser` is a Node.js stream: text (or bytes) in, one array of quads per message out, **as soon as the message is
+complete**, with normal backpressure. It never buffers the input, and keeps nothing of messages that it already emitted.
+
+```js
+import { createReadStream } from 'node:fs';
+import { MessageStreamParser } from 'n3.js-messages';
+
+const messages = createReadStream('log.trig').pipe(new MessageStreamParser({ format: 'TriG' }));
+for await (const message of messages)
+  console.log(`message with ${message.length} quads`);
+// parser.on('prefix', (prefix, iri) => …) and parser.on('version', label => …) are emitted too
+```
+
+Chunk boundaries may be anywhere (inside `MESSAGE`, inside an IRI, between the bytes of a character, after the CR of a CRLF);
+the result is identical to parsing the whole string at once.
+
+## Writing
+
+```js
+import { MessageWriter, MessageStreamWriter, writeMessages } from 'n3.js-messages';
+import { DataFactory } from 'n3';
+const { namedNode, literal, quad } = DataFactory;
+
+const writer = new MessageWriter(process.stdout, { format: 'TriG', prefixes: { ex: 'http://example.org/' } });
+await writer.addMessage([quad(namedNode('http://example.org/alice'), namedNode('http://example.org/says'), literal('Hello'))]);
+await writer.addMessage([]);                       // empty messages are written, too
+await writer.end();
+
+const text = writeMessages(messages, { format: 'N-Quads' });  // synchronous, returns a string
+```
+
+- Writes `VERSION "1.2-messages"` (`@version "1.2-messages" .` in Turtle/TriG) first, and a delimiter after each message:
+  `MESSAGE` in N-Triples and N-Quads, `@message .` in Turtle and TriG. A parser gets a message when it is written, and a trailing empty
+  message survives a round trip.
+- Each message starts from a clean serializer state, so consecutive messages in the same named graph are valid. Prefixes (and `baseIRI` with
+  `writeBase: true`) are declared once; `addPrefix` declares more before the next message.
+- `addMessage` and `end` accept a callback or return a promise. They complete when the output stream has accepted the data, not when it was queued.
+- `MessageStreamWriter` is the `Transform` equivalent: messages in (object mode), text out.
+
+## Blank node semantics
+
+Blank node labels are **scoped to their message**: `_:a` in message 1 and `_:a` in message 2 are different blank nodes, also when the
+whole log is parsed by one parser instance, from one stream, with any data factory. Within one message a label is one node.
+Consequently, a blank node that the same quad objects share between two messages is *written* with the same label twice, and
+comes back as two nodes. Prefixes and the base IRI, on the other hand, stay in effect across messages (and a later `PREFIX` overrides).
+
+## Supported syntaxes
+
+| Syntax | Version announcement | Delimiter | Graphs |
+| --- | --- | --- | --- |
+| Turtle | `VERSION "1.2-messages"` or `@version "1.2-messages" .` | `MESSAGE` or `@message .` | – |
+| TriG | idem | `MESSAGE` or `@message .` | graph blocks |
+| N-Triples | `VERSION "1.2-messages"` | `MESSAGE` (own line) | – |
+| N-Quads | `VERSION "1.2-messages"` | `MESSAGE` (own line) | fourth term |
+
+The labels `1.2-messages`, `1.2-basic-messages` and `1.1-messages` are accepted. Not supported: NDJSON-LD, YAML-LD, RDF/XML message logs,
+Jelly, Notation3. Syntax details and ambiguities of the specification are in [IMPLEMENTATION-NOTES.md](IMPLEMENTATION-NOTES.md).
+
+## Specification compliance
+
+The [RDF Messages test suite](https://w3c-cg.github.io/rsp/spec/messages-tests) is vendored at a pinned upstream revision and run by
+`npm run test:spec` (see [spec/README.md](spec/README.md)). The suite is a prose document, so the cases are extracted from it
+mechanically; each parsing case runs through the synchronous parser and through the stream parser with one character per chunk.
+
+Result of the run for this version (node 25.9.0, n3 2.10.6): **16 passed, 0 failed, 12 skipped** of 28 cases.
+The 12 skipped cases do not apply to RDF syntax parsers and serializers: 7 test protocol adapters (SSE, WebSocket, Kafka, MQTT, other brokers,
+Jelly gRPC), and 5 are about NDJSON-LD, a different serialization. The run prints each skipped case with its reason.
+`npm run test:spec:earl` writes an EARL report.
+
+Beyond the suite there are 334 unit, regression, property and differential tests (100% statement, branch, function and line coverage),
+including every possible two-chunk split of the fixtures, deterministic randomized chunking, per-byte streaming, and the regressions of
+the review of N3.js [pull request 586](https://github.com/rdfjs/N3.js/pull/586), which proposed this feature for N3.js itself.
+
+## Relationship to N3.js
+
+- `n3` is a **peer dependency** (`>=2.0.0 <3`), so that an application has one N3.js installation. It is tested against n3 2.0.0 (minimum) and
+  the latest 2.x, and against N3.js `main` in a scheduled, non-blocking job.
+- This is not a fork. The N3.js maintainers asked for RDF Messages to live in a separate package until the specification matures
+  (they proposed it in the discussion of pull request 586, which first added the feature to N3.js itself); this package is that package.
+  Where N3.js lacks a hook, [IMPLEMENTATION-NOTES.md](IMPLEMENTATION-NOTES.md) says which, and how it is bridged with public API only.
+
+## Performance
+
+`npm run perf` runs the benchmarks (`PERF_QUICK=1` for a smoke run) and writes `.perf-results/latest.json`; `npm run perf:compare` checks
+ratio-based guardrails against each other and compares with `perf/baseline.json`. Method, thresholds and their rationale are in
+[perf/README.md](perf/README.md). Measured on an Intel i7-1265U, node 25.9.0 (median of 5; quads/s):
+
+| | plain N3.js | n3.js-messages |
+| --- | --- | --- |
+| parse 100k quads, one message | 688k | 719k (`parseMessages`), 784k (stream, 64 KiB chunks) |
+| parse 10k messages × 5 quads | – | 588k (`parseMessages`), 813k (stream) |
+| stream, 16-byte chunks (10k quads) | – | 464k |
+| write 100k quads in one message (N-Quads) | – | 1.79M |
+| write 10k messages (N-Quads) | – | 1.18M (235k messages/s) |
+
+Streaming 100k messages (17 MB) through `MessageStreamParser` grows the heap by 0.12 MB (after gc).
+
+### Comparison with rdf-parser-ts and rdf-writer-ts
+
+[rdf-parser-ts](https://github.com/pietercolpaert/rdf-parser-ts) and its sibling [rdf-writer-ts](https://github.com/pietercolpaert/rdf-writer-ts)
+also support RDF Messages, as standalone packages instead of a layer over N3.js. The benchmark suite runs the same generated documents
+through both (`npm run perf`, then `npm run perf:compare`). Throughput in quads per second, median of 5, Intel i7-1265U, Node.js 25.9
+(the higher number is faster; a speed above 1× means n3.js-messages is faster):
+
+| Workload | n3.js-messages | rdf-parser-ts / rdf-writer-ts | Speed of n3.js-messages |
+| --- | --- | --- | --- |
+| Parse a string, one message, 100k quads | 719k | 696k | 1.03× |
+| Parse a string, 10k messages × 5 quads | 588k | 691k | 0.85× |
+| Parse a string, 10 messages × 10k quads | 680k | 745k | 0.91× |
+| Stream, 64 KiB chunks, 100k quads | 784k | 680k | 1.15× |
+| Stream, 64 KiB chunks, 10k messages | 813k | 549k | 1.48× |
+| Stream, 16-byte chunks, 10k quads | 464k | 254k | 1.83× |
+| Stream, 1-character chunks, 1k quads | 117k | 76k | 1.53× |
+| Write one message, 100k quads, N-Quads | 1,793k | 1,678k | 1.07× |
+| Write one message, 100k quads, TriG | 1,667k | 1,636k | 1.02× |
+| Write 10k messages, N-Quads | 1,177k | 1,540k | 0.76× |
+| Write 10k messages, TriG | 1,039k | 1,374k | 0.76× |
+
+- **Streaming is where this package is ahead**: 1.15× to 1.8×, most for tiny chunks. Our scanner and the N3.js lexer work incrementally; by its
+  documentation, rdf-parser-ts runs its parser over every complete statement prefix of the buffered input. I did not profile it to confirm the cause.
+- **Parsing a whole string is faster with rdf-parser-ts** (0.85× to 0.91× for many messages or large ones, parity for one message): `parseMessages` is
+  N3.js plus a scanner, so it is bounded by the speed of N3.js, which rdf-parser-ts also beats on ordinary documents (by 1.2×).
+- **Writing**: on par for one large message; rdf-writer-ts is faster for many small messages (0.76×), since this package creates an N3.js writer per message.
+- **Memory**: both stay flat while streaming 100k messages (17 MB): the heap grows by 0.12 MB here and
+  0.08 MB with rdf-parser-ts.
+
+Beyond speed, the choice is mostly about the ecosystem. Choose n3.js-messages if you already use N3.js (one parser and one set of syntax quirks, `n3` as a
+shared peer dependency, Node.js 18+, messages as plain `Quad[]`, and a writer that starts every message from a clean state). Choose rdf-parser-ts and rdf-writer-ts if you do not need N3.js, or if parsing whole
+documents and writing many tiny messages are your bottleneck (they need Node.js 22+ and use `rdf-data-factory` by default).
+These are one machine's numbers from a single process: run `npm run perf` on yours; method and caveats are in [perf/README.md](perf/README.md).
+
+## Development
+
+```sh
+npm ci
+npm test               # unit, regression, property tests, with coverage (100% required)
+npm run lint
+npm run test:spec      # official RDF Messages test suite
+npm run test:types     # TypeScript declarations
+npm run test:package   # packs the tarball and tests it in a clean consumer project (needs network)
+npm run perf
+npm pack --dry-run
+```
+
+`FUZZ_SEED=… FUZZ_ITERATIONS=…` repeats the property test with another seed; a failure prints its seed and a minimized log.
+
+## License
+
+MIT. The vendored test suite in `spec/fixtures` keeps its upstream license (`spec/fixtures/LICENSE-UPSTREAM.md`).

package/index.d.ts

@@ -0,0 +1,115 @@
+// Type definitions for n3.js-messages
+import * as RDF from '@rdfjs/types';
+import { Transform } from 'stream';
+
+export type MessageFormat =
+  | 'Turtle' | 'TriG' | 'N-Triples' | 'N-Quads'
+  | (string & {});
+
+/** One RDF message: the quads between two message delimiters. */
+export type Message<Q extends RDF.BaseQuad = RDF.Quad> = Q[];
+
+/**
+ * The part of an RDF/JS DataFactory that is used for parsing; any `RDF.DataFactory<Q>` fits.
+ * The quads that the factory creates determine the quads that are parsed.
+ */
+export interface MessageQuadFactory<Q extends RDF.BaseQuad = RDF.Quad>
+  extends Pick<RDF.DataFactory<RDF.Quad, any>, 'namedNode' | 'blankNode' | 'literal' | 'variable' | 'defaultGraph'> {
+  quad(subject: Q['subject'], predicate: Q['predicate'], object: Q['object'], graph?: Q['graph']): Q;
+}
+
+export interface MessageParserOptions<Q extends RDF.BaseQuad = RDF.Quad> {
+  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
+  format?: MessageFormat;
+  baseIRI?: string;
+  /** Data factory used to create terms and quads. */
+  factory?: MessageQuadFactory<Q>;
+  /** Prefix for generated blank node labels, e.g. `b0_`. */
+  blankNodePrefix?: string;
+  /** RDF version label, e.g. `1.2-messages`; a `-messages` suffix forces message mode. */
+  version?: string;
+  /** Force message mode even without a `-messages` version declaration. */
+  messages?: boolean;
+}
+
+export type MessageCallback<Q extends RDF.BaseQuad = RDF.Quad> = (
+  error: Error | null,
+  message: Q[] | null,
+  prefixes?: { [prefix: string]: RDF.NamedNode },
+  index?: number,
+) => void;
+
+export interface MessageParseCallbacks<Q extends RDF.BaseQuad = RDF.Quad> {
+  onMessage?: MessageCallback<Q>;
+  onQuad?: (error: Error | null, quad?: Q, messageIndex?: number) => void;
+  onPrefix?: (prefix: string, term: RDF.NamedNode) => void;
+  onVersion?: (version: string) => void;
+}
+
+export class MessageParser<Q extends RDF.BaseQuad = RDF.Quad> {
+  constructor(options?: MessageParserOptions<Q>);
+  /** Synchronously parses a string; throws on syntax errors. */
+  parse(input: string): Q[][];
+  /** Parses a string or stream, reporting messages through a callback. */
+  parse(input: string | NodeJS.ReadableStream, callback: MessageCallback<Q>): void;
+  /** Parses a string or stream, reporting through object callbacks. */
+  parse(input: string | NodeJS.ReadableStream, callbacks: MessageParseCallbacks<Q>): void;
+  /** Parses a stream without callbacks (reports nothing). */
+  parse(input: NodeJS.ReadableStream): void;
+}
+
+export function parseMessages<Q extends RDF.BaseQuad = RDF.Quad>(
+  input: string,
+  options?: MessageParserOptions<Q>,
+): Q[][];
+
+export class MessageStreamParser<Q extends RDF.BaseQuad = RDF.Quad> extends Transform
+  implements AsyncIterable<Q[]> {
+  constructor(options?: MessageParserOptions<Q>);
+  on(event: 'prefix', listener: (prefix: string, term: RDF.NamedNode) => void): this;
+  on(event: 'version', listener: (version: string) => void): this;
+  on(event: 'data', listener: (message: Q[]) => void): this;
+  on(event: string | symbol, listener: (...args: any[]) => void): this;
+  once(event: 'prefix', listener: (prefix: string, term: RDF.NamedNode) => void): this;
+  once(event: 'version', listener: (version: string) => void): this;
+  once(event: 'data', listener: (message: Q[]) => void): this;
+  once(event: string | symbol, listener: (...args: any[]) => void): this;
+  [Symbol.asyncIterator](): NodeJS.AsyncIterator<Q[]>;
+}
+
+export interface MessageWriterOptions {
+  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
+  format?: MessageFormat;
+  /** Prefixes that are declared up front. */
+  prefixes?: { [prefix: string]: RDF.NamedNode | string };
+  baseIRI?: string;
+  writeBase?: boolean;
+  lists?: { [listHead: string]: RDF.Term[] };
+  /** RDF version label announced in the output. Defaults to `1.2-messages`. */
+  version?: string;
+  /** Whether to end the output stream on `end()`. Defaults to `true`. */
+  end?: boolean;
+}
+
+export interface MessageOutputStream {
+  write(chunk: string, encoding?: string, callback?: (error?: Error | null) => void): unknown;
+  end(callback?: (error?: Error | null) => void): unknown;
+}
+
+export class MessageWriter {
+  constructor(options?: MessageWriterOptions);
+  constructor(outputStream?: MessageOutputStream | NodeJS.WritableStream | null, options?: MessageWriterOptions);
+  addMessage(quads: RDF.BaseQuad[], done: (error: Error | null) => void): void;
+  addMessage(quads: RDF.BaseQuad[]): Promise<void>;
+  addPrefix(prefix: string, iri: RDF.NamedNode | string, done: (error: Error | null) => void): void;
+  addPrefix(prefix: string, iri: RDF.NamedNode | string): Promise<void>;
+  /** Without an output stream, the result is the written string. */
+  end(done: (error: Error | null, result?: string) => void): void;
+  end(): Promise<string>;
+}
+
+export function writeMessages(messages: Iterable<RDF.BaseQuad[]>, options?: MessageWriterOptions): string;
+
+export class MessageStreamWriter extends Transform {
+  constructor(options?: Omit<MessageWriterOptions, 'end'>);
+}

package/lib/MessageParser.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.parseMessages = parseMessages;
+var _string_decoder = require("string_decoder");
+var _MessageParserCore = _interopRequireDefault(require("./MessageParserCore.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// **MessageParser** parses RDF Message Logs (Turtle, TriG, N-Triples and N-Quads).
+
+class MessageParser {
+  constructor(options) {
+    this._options = options || {};
+    // Fail early on unsupported options
+    this._createCore({});
+  }
+  _createCore(sink) {
+    return new _MessageParserCore.default(this._options, sink);
+  }
+
+  // ### `parse` parses a string or a readable stream of RDF Messages.
+  //
+  // Without callbacks, a string is parsed synchronously into an array of
+  // messages (arrays of quads), and parse errors are thrown.
+  // With a callback `(error, message, prefixes)`, or an object with the
+  // callbacks `onMessage(error, message, prefixes)`, `onQuad(error, quad, messageIndex)`,
+  // `onPrefix(prefix, term)` and `onVersion(label)`, messages are reported as soon
+  // as they are complete. The final call has `null` as message.
+  parse(input, callbacks) {
+    if (typeof callbacks === 'function') callbacks = {
+      onMessage: callbacks
+    };
+    const messages = callbacks ? null : [];
+    let error = null;
+    callbacks = callbacks || {};
+    const sink = {
+      message: (quads, index) => callbacks.onMessage ? callbacks.onMessage(null, quads, undefined, index) : messages && messages.push(quads),
+      end: prefixes => callbacks.onMessage && callbacks.onMessage(null, null, prefixes),
+      error: e => {
+        error = e;
+        callbacks.onMessage && callbacks.onMessage(e);
+        callbacks.onQuad && callbacks.onQuad(e);
+      }
+    };
+    if (callbacks.onQuad) sink.quad = (quad, index) => callbacks.onQuad(null, quad, index);
+    if (callbacks.onPrefix) sink.prefix = callbacks.onPrefix;
+    if (callbacks.onVersion) sink.version = callbacks.onVersion;
+    const core = this._createCore(sink);
+
+    // Parse a string at once
+    if (typeof input === 'string') {
+      core.write(input);
+      core.end();
+      if (error && messages) throw error;
+      return messages || undefined;
+    }
+
+    // Parse a stream chunk by chunk
+    const decoder = new _string_decoder.StringDecoder('utf8');
+    input.on('data', chunk => core.write(typeof chunk === 'string' ? chunk : decoder.write(chunk)));
+    input.on('end', () => {
+      core.write(decoder.end());
+      core.end();
+    });
+    input.on('error', e => sink.error(e));
+    return undefined;
+  }
+}
+
+// ### `parseMessages` synchronously parses a string into an array of messages
+exports.default = MessageParser;
+function parseMessages(input, options) {
+  return new MessageParser(options).parse(input);
+}

package/lib/MessageParserCore.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = require("events");
+var _n = require("n3");
+var _MessageScanner = require("./MessageScanner.js");
+var _formats = require("./formats.js");
+// **MessageParserCore** is the push-based engine behind all message parsers.
+// It feeds scanned text to the public N3.js parser and groups the resulting
+// quads into messages.
+
+// Unrecognizable by construction: a document cannot contain it by accident
+function createSentinel() {
+  return `rdf-messages-${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+}
+class MessageParserCore {
+  // `sink` receives `message(quads, index)`, `end(prefixes)`, `error(error)`
+  // and optionally `quad(quad, messageIndex)`, `prefix(prefix, term)`, `version(label)`
+  constructor(options, sink) {
+    options = options || {};
+    const format = (0, _formats.resolveFormat)(options.format);
+    this._sink = sink;
+    this._factory = options.factory || _n.DataFactory;
+    this._blankNodePrefix = typeof options.blankNodePrefix === 'string' ? options.blankNodePrefix.replace(/^_:/, '') : undefined;
+    this._blankNodeCounter = 0;
+    this._supportedVersions = _n.Parser.SUPPORTED_VERSIONS;
+    this._messages = options.messages === true || (0, _formats.isMessagesVersion)(options.version);
+    this._index = 0;
+    this._current = null;
+    this._scope = null;
+    this._seenQuad = false;
+    this._failed = false;
+    this._finished = false;
+    const n3Options = {
+      format: format.name,
+      factory: this._factory,
+      // Version labels are validated here, because N3.js does not know `-messages` labels
+      parseUnsupportedVersions: true
+    };
+    if (options.baseIRI) n3Options.baseIRI = options.baseIRI;
+    if (options.version) {
+      this._checkVersion(options.version, true);
+      n3Options.version = (0, _formats.baseVersion)(options.version);
+    }
+    const sentinel = createSentinel();
+    this._sentinel = sentinel;
+    this._scanner = format.lineMode ? new _MessageScanner.LineScanner(sentinel) : new _MessageScanner.TurtleScanner(sentinel);
+    this._input = new _events.EventEmitter();
+    const callbacks = {
+      onQuad: (error, quad, prefixes) => this._onQuad(error, quad, prefixes),
+      onPrefix: (prefix, term) => this._failed || sink.prefix && sink.prefix(prefix, term),
+      onVersion: label => this._onVersion(label)
+    };
+    if (format.lineMode) callbacks.onComment = comment => this._onComment(comment);
+    new _n.Parser(n3Options).parse(this._input, callbacks);
+  }
+
+  // ### `write` accepts the next chunk of text
+  write(text) {
+    if (!this._failed && !this._finished && text.length > 0) this._feed(this._scanner.push(text));
+  }
+
+  // ### `end` signals the end of the input
+  end() {
+    if (!this._failed && !this._finished) {
+      this._feed(this._scanner.end());
+      this._input.emit('end');
+    }
+  }
+  _feed(text) {
+    if (text.length > 0) this._input.emit('data', text);
+  }
+  _onQuad(error, quad, prefixes) {
+    if (this._failed || this._finished) return;
+    if (error) this._fail(error);else if (quad) this._addQuad(quad);else {
+      this._finished = true;
+      if (this._current !== null) this._emitMessage();
+      this._sink.end(prefixes);
+    }
+  }
+  _addQuad(quad) {
+    this._seenQuad = true;
+    // Blank node labels are scoped to their message
+    if (this._messages) quad = this._scopeQuad(quad);
+    if (this._current === null) this._current = [];
+    this._current.push(quad);
+    if (this._sink.quad) this._sink.quad(quad, this._index);
+  }
+  _onVersion(label) {
+    if (this._failed) return;
+    if (label === this._sentinel) this._delimiter(this._scanner.delimiterLines.shift());else this._announce(label);
+  }
+
+  // Line mode reports delimiters and versions as comments
+  _onComment(comment) {
+    if (this._failed || !comment.startsWith(this._sentinel)) return;
+    const rest = comment.substring(this._sentinel.length);
+    if (rest[0] === 'M') this._delimiter(Number(rest.substring(1)));else this._announce(rest.substring(1));
+  }
+  _announce(label) {
+    const error = this._checkVersion(label);
+    if (error) return this._fail(error);
+    if ((0, _formats.isMessagesVersion)(label) && !this._messages) {
+      if (this._seenQuad) return this._fail(new Error(`Version "${label}" must be announced before the first statement.`));
+      this._messages = true;
+    }
+    if (this._sink.version) this._sink.version(label);
+  }
+
+  // Validates a version label, and returns an error for unsupported ones
+  _checkVersion(label, throwing) {
+    if ((0, _formats.isSupportedVersion)((0, _formats.baseVersion)(label), this._supportedVersions)) return null;
+    const error = new Error(`Detected unsupported version: "${label}"`);
+    if (throwing) throw error;
+    return error;
+  }
+  _delimiter(line) {
+    if (!this._messages) {
+      return this._fail(new Error(`Unexpected "MESSAGE" on line ${line}: the document did not announce ` + 'a version with the "-messages" suffix.'));
+    }
+    this._emitMessage();
+  }
+
+  // Finalizes the current message, which is empty if no quad was seen
+  _emitMessage() {
+    const quads = this._current || [];
+    this._current = null;
+    this._scope = null;
+    this._sink.message(quads, this._index++);
+  }
+  _fail(error) {
+    this._failed = true;
+    this._current = null;
+    this._sink.error(error);
+  }
+
+  // ## Blank node scoping
+
+  _scopeQuad(quad) {
+    const subject = this._scopeTerm(quad.subject);
+    const predicate = this._scopeTerm(quad.predicate);
+    const object = this._scopeTerm(quad.object);
+    const graph = this._scopeTerm(quad.graph);
+    return subject === quad.subject && predicate === quad.predicate && object === quad.object && graph === quad.graph ? quad : this._factory.quad(subject, predicate, object, graph);
+  }
+  _scopeTerm(term) {
+    if (term.termType === 'BlankNode') {
+      const scope = this._scope || (this._scope = new Map());
+      let scoped = scope.get(term.value);
+      if (!scoped) {
+        scoped = this._blankNodePrefix === undefined ? this._factory.blankNode() : this._factory.blankNode(`${this._blankNodePrefix}${this._blankNodeCounter++}`);
+        scope.set(term.value, scoped);
+      }
+      return scoped;
+    }
+    return term.termType === 'Quad' ? this._scopeQuad(term) : term;
+  }
+}
+exports.default = MessageParserCore;