@effected/toml 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+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,140 @@
+# @effected/toml
+
+[![npm](https://img.shields.io/npm/v/@effected%2Ftoml?label=npm&color=cb3837)](https://www.npmjs.com/package/@effected/toml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
+[![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+
+Zero-dependency TOML 1.0.0 parsing, editing and formatting expressed as Effect schemas and pure functions. Parse TOML into plain values or a byte-exact linear CST, compute comment-preserving edits, format, modify by path, walk a document as a `Stream`, and decode straight into a validated domain schema.
+
+> **Pre-release.** This package is part of the `@effected/*` kit, in pre-`1.0.0`
+> development against a single pinned Effect v4 beta. Packages graduate to
+> `1.0.0` once Effect `4.0.0` ships. To hold your own `effect` versions at
+> exactly the ones the kit is built and tested against, install
+> [`@effected/pnpm-plugin-effect`](https://www.npmjs.com/package/@effected/pnpm-plugin-effect).
+>
+> **Stability: unstable.** This package's API surface is not yet considered
+> complete and may change across `0.x` releases. Pin an exact version — even a
+> package marked *stable* before `1.0.0` can introduce a breaking change by
+> accident, and an exact pin turns that into a type-check error rather than a
+> runtime surprise. Full policy: [release strategy](https://github.com/spencerbeggs/effected#release-strategy).
+
+## Why @effected/toml
+
+TOML is the config format behind `Cargo.toml`, `pyproject.toml` and a large share of the Rust and Python toolchains — files that people maintain by hand and comment heavily. Most JavaScript TOML libraries round-trip through a plain-object model, which loses every comment and blank line the moment you write the file back out.
+
+The engine here is written from scratch against the TOML 1.0.0 spec, and it is the only format package in this repo that vendors no upstream code at all. It parses into a lossless linear CST whose expression spans tile the source byte-exact, so `TomlDocument.parse(text).stringify()` reproduces the original text exactly for any valid document. There is no separate re-serialization path that can drift from the source. Edits are byte-minimal splices against that CST, so formatting and path-based modification preserve every comment and every byte you did not touch.
+
+The value model is honest about TOML's types rather than flattening them into JavaScript's. Integers past ±(2^53 − 1) decode to `bigint` instead of silently losing precision, and TOML's four date-time types decode to four calendar-validated value classes instead of a `Date` that cannot represent a local time. TOML has no null, so `Toml.stringify` on a value containing `null` fails with a structured `UnsupportedValue` diagnostic naming the offending path rather than dropping the key. Every fallible entry point carries a typed error built from `TomlDiagnostic`, and nesting-depth guards on both the parse and the stringify side mean hostile input fails through that channel rather than as a stack overflow.
+
+## Install
+
+```bash
+npm install @effected/toml effect
+```
+
+```bash
+pnpm add @effected/toml effect
+```
+
+Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package itself adds no other runtime dependencies.
+
+## Quick start
+
+Compose your schema with `Toml.schema` to decode TOML straight into a validated domain value, or reach for the pre-bound `Toml.TomlFromString` codec when you just want the plain value:
+
+```ts
+import { Toml } from "@effected/toml";
+import { Effect, Schema } from "effect";
+
+const Config = Schema.Struct({ name: Schema.String, port: Schema.Number });
+const ConfigFromToml = Toml.schema(Config);
+
+const program = Effect.gen(function* () {
+  return yield* Schema.decodeUnknownEffect(ConfigFromToml)(`
+    name = "api"
+    port = 3000
+  `);
+});
+
+Effect.runPromise(program).then(console.log);
+// { name: "api", port: 3000 }
+```
+
+`Toml.stringify` goes the other way, emitting canonical TOML:
+
+```ts
+import { Toml } from "@effected/toml";
+import { Effect } from "effect";
+
+Effect.runPromise(Toml.stringify({ title: "app", server: { port: 8080 } })).then(console.log);
+// title = "app"
+//
+// [server]
+// port = 8080
+```
+
+## Editing without losing comments
+
+`TomlFormat.modify` computes a `TomlEdit` array against the parsed CST; `modifyToString` applies it in one step. Comments, blank lines and layout that an edit does not cover come through byte-identical:
+
+```ts
+import { TomlFormat } from "@effected/toml";
+import { Effect } from "effect";
+
+const source = `# server config
+name = "api"
+port = 3000 # dev default
+`;
+
+Effect.runPromise(TomlFormat.modifyToString(source, ["port"], 8080)).then(console.log);
+// # server config
+// name = "api"
+// port = 8080 # dev default
+```
+
+## Value model
+
+TOML's types do not all have a JavaScript equivalent, so the ones that do not get a real one:
+
+| TOML | Decodes to |
+| ---- | ---------- |
+| Integer within ±(2^53 − 1) | `number` |
+| Integer beyond ±(2^53 − 1), inside the 64-bit range | `bigint` — precision is never silently lost |
+| Integer outside the 64-bit range | fails with an `IntegerOutOfRange` diagnostic |
+| Offset date-time (`1979-05-27T07:32:00Z`) | `TomlOffsetDateTime` |
+| Local date-time (`1979-05-27T07:32:00`) | `TomlLocalDateTime` |
+| Local date (`1979-05-27`) | `TomlLocalDate` |
+| Local time (`07:32:00`) | `TomlLocalTime` |
+
+The four date-time classes are `Schema.Class` value objects with real Gregorian-calendar validation and structural equality, not `Date` subclasses: JavaScript's `Date` has no way to represent a date with no time, or a time with no offset.
+
+TOML cannot represent `null` at all. Rather than dropping the key or writing an empty string, `Toml.stringify` fails:
+
+```ts
+import { Toml } from "@effected/toml";
+import { Effect } from "effect";
+
+Effect.runPromise(Effect.result(Toml.stringify({ a: null }))).then(console.log);
+// Failure with TomlStringifyError, whose `diagnostic` carries:
+// { code: "UnsupportedValue", message: "unsupported null value at a", ... }
+```
+
+## Features
+
+- `Toml.parse` / `Toml.stringify` — value-level parse and canonical stringify, both carrying typed `TomlParseError` / `TomlStringifyError` channels, including nesting-depth guards on adversarial input.
+- `Toml.fromString` / `Toml.TomlFromString` / `Toml.schema` — string→domain schema factories that decode TOML directly into a validated Effect `Schema` value.
+- `TomlDocument` — the lossless document: `parse`, `schema`, `toValue` and `stringify`, backed by the linear CST whose expression spans reconstruct the source byte-exact.
+- `TomlEdit` / `TomlRange` (with `applyAll`) — the non-mutating text-edit vocabulary shared by the formatter and the modifier, and identical in shape to `@effected/jsonc`'s and `@effected/yaml`'s.
+- `TomlFormat` — `format` and `formatToString` compute conservative, comment-preserving formatting edits; `modify` and `modifyToString` compute the edits to replace, delete or insert a value at a path.
+- `TomlVisitor` — walk a parsed document as a `Stream` of visitor events.
+- `TomlDiagnostic` — the structured diagnostic (`code`, `message`, `offset`, `length`, `line`, `character`) every typed error carries, across five staged error-code unions.
+- `TomlLocalDate` / `TomlLocalTime` / `TomlLocalDateTime` / `TomlOffsetDateTime` — TOML's date-time types as calendar-validated `Schema.Class` value objects.
+
+## Conformance
+
+The engine runs the [toml-test](https://github.com/toml-lang/toml-test) 1.0.0 compliance corpus — every valid case and every invalid case — to a 100% pass rate with no skip list, and a differential property suite cross-checks it against an independent TOML parser. Both oracles are devDependency-only; neither reaches your runtime.
+
+## License
+
+[MIT](LICENSE)

package/Toml.js

@@ -0,0 +1,165 @@
+import { isRawTomlError } from "./internal/diagnostics.js";
+import { isGuardExceeded } from "./internal/limits.js";
+import { parseExpressions } from "./internal/parser.js";
+import { buildValue } from "./internal/semantic.js";
+import { stringifyValue } from "./internal/stringifyValue.js";
+import { TomlDiagnostic } from "./TomlDiagnostic.js";
+import { Effect, Option, Schema, SchemaIssue, SchemaTransformation } from "effect";
+
+//#region src/Toml.ts
+/**
+* Options controlling stringify behavior. The only knob is `newline` —
+* omitted, it resolves to `"\n"`.
+*
+* @public
+*/
+var TomlStringifyOptions = class extends Schema.Class("TomlStringifyOptions")({ newline: Schema.optionalKey(Schema.Literals(["\n", "\r\n"])) }) {};
+/**
+* Parse failure: the {@link TomlDiagnostic} entries describing why the
+* document was rejected (first violation wins, so there is one today; the
+* array shape matches `@effected/yaml`'s aggregate contract). Raised by
+* {@link Toml.parse} and the decode direction of the schema factories.
+*
+* @public
+*/
+var TomlParseError = class extends Schema.TaggedErrorClass()("TomlParseError", { diagnostics: Schema.Array(TomlDiagnostic) }) {
+	get message() {
+		const count = this.diagnostics.length;
+		const first = this.diagnostics[0];
+		const detail = first === void 0 ? "" : `: ${first.code} at ${first.line}:${first.character} ${first.message}`;
+		return `TOML parse failed with ${count} error${count === 1 ? "" : "s"}${detail}`;
+	}
+};
+/**
+* Stringification failure: an unsupported value, an out-of-range integer, a
+* circular reference or a tripped depth guard, as one structured
+* {@link TomlDiagnostic} (offset `0` — there is no source text). Raised by
+* {@link Toml.stringify} and the encode direction of the schema factories.
+*
+* @public
+*/
+var TomlStringifyError = class extends Schema.TaggedErrorClass()("TomlStringifyError", { diagnostic: TomlDiagnostic }) {
+	get message() {
+		return `TOML stringify failed: ${this.diagnostic.code} ${this.diagnostic.message}`;
+	}
+};
+/**
+* Run the parser and semantic pass, materializing the engine's raw carriers
+* into the typed error: `RawTomlError` becomes a positioned diagnostic and a
+* `GuardExceeded` depth trip becomes a `NestingDepthExceeded` diagnostic
+* (never an unhandled defect). Anything else is a genuine defect and rethrows.
+*/
+const parseOrFail = (text) => Effect.try({
+	try: () => buildValue(parseExpressions(text)),
+	catch: (defect) => {
+		if (isRawTomlError(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, defect.diagnostic)] });
+		if (isGuardExceeded(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, {
+			code: "NestingDepthExceeded",
+			message: defect.message,
+			offset: defect.offset,
+			length: 0
+		})] });
+		throw defect;
+	}
+});
+const stringifyOrFail = (value, options) => Effect.try({
+	try: () => stringifyValue(value, options?.newline ?? "\n"),
+	catch: (defect) => {
+		if (isRawTomlError(defect)) return new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", defect.diagnostic) });
+		if (isGuardExceeded(defect)) return new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", {
+			code: "NestingDepthExceeded",
+			message: defect.message,
+			offset: 0,
+			length: 0
+		}) });
+		throw defect;
+	}
+});
+/**
+* Static entry points for TOML parsing, stringification and the schema
+* factories. Not instantiable.
+*
+* @remarks
+* `parse`, `stringify` and the schema factories carry real typed error
+* channels — including the hardening guards (nesting-depth caps on both
+* sides, circular-reference detection on encode) that keep malformed or
+* adversarial input on the typed channel instead of surfacing as an
+* unhandled defect. `parse` takes no options: TOML 1.0.0 parsing has no
+* knobs.
+*
+* @example
+* ```ts
+* import { Toml } from "@effected/toml";
+* import { Effect } from "effect";
+*
+* const program = Effect.gen(function* () {
+*   const value = yield* Toml.parse('name = "Alice"\nage = 30');
+*   return value; // { name: "Alice", age: 30 }
+* });
+* ```
+*
+* @public
+*/
+var Toml = class Toml {
+	constructor() {}
+	/**
+	* Parse a TOML 1.0.0 document into a plain JavaScript value: tables and
+	* inline tables become plain objects (`__proto__` lands as an own data
+	* property), arrays become plain arrays, integers become `number` (or
+	* `bigint` past 2^53) and date-times become the four `TomlDateTime`
+	* classes. Fails with {@link TomlParseError} at the first violation;
+	* returns `unknown`, never `any`.
+	*
+	* A nesting-depth bomb (arrays or inline tables past the engine cap) also
+	* fails through {@link TomlParseError} with a `NestingDepthExceeded`
+	* diagnostic, never as an unhandled defect.
+	*/
+	static parse = Effect.fn("Toml.parse")(function* (text) {
+		return yield* parseOrFail(text);
+	});
+	/**
+	* Stringify a plain JavaScript value as a canonical TOML document: within
+	* a table, non-table pairs first, then sub-tables as `[dotted.header]`
+	* sections depth-first, then arrays of tables as `[[dotted.header]]`
+	* sections, a blank line before every header except at document start.
+	* Fails with {@link TomlStringifyError} on unsupported values (TOML has no
+	* null), out-of-int64-range `bigint`s, circular references and
+	* depth-guard trips — all on the typed channel.
+	*/
+	static stringify = Effect.fn("Toml.stringify")(function* (value, options) {
+		return yield* stringifyOrFail(value, options);
+	});
+	/**
+	* A `Schema<unknown, string>` decoding a TOML document and encoding values
+	* back to canonical TOML text.
+	*
+	* Schema-producing: each call returns a fresh schema whose derivation
+	* caches are not shared across calls. Bind the result to a `const` on hot
+	* paths; the pre-bound {@link Toml.TomlFromString} covers the common case.
+	*/
+	static fromString() {
+		return Schema.String.pipe(Schema.decodeTo(Schema.Unknown, SchemaTransformation.transformOrFail({
+			decode: (input) => Toml.parse(input).pipe(Effect.mapError((error) => new SchemaIssue.InvalidValue(Option.some(input), { message: error.message }))),
+			encode: (value) => stringifyOrFail(value).pipe(Effect.mapError((error) => new SchemaIssue.InvalidValue(Option.some(value), { message: error.message })))
+		})));
+	}
+	/**
+	* The zero-config `Schema<unknown, string>` — `Toml.fromString()`
+	* pre-bound so the common case needs no memoization discipline.
+	*/
+	static TomlFromString = Toml.fromString();
+	/**
+	* Compose {@link Toml.fromString} with a target schema, yielding a
+	* `Schema<A, string>` that decodes TOML straight into a validated domain
+	* value. The target's decoding/encoding service requirements flow through.
+	*
+	* Schema-producing: bind the result to a `const` on hot paths (see
+	* {@link Toml.fromString}).
+	*/
+	static schema(target) {
+		return Toml.TomlFromString.pipe(Schema.decodeTo(target));
+	}
+};
+
+//#endregion
+export { Toml, TomlParseError, TomlStringifyError, TomlStringifyOptions };

package/TomlDateTime.js

@@ -0,0 +1,147 @@
+import { Schema } from "effect";
+
+//#region src/TomlDateTime.ts
+/** Zero-pad `value` to `width` digits (never truncates a wider value). */
+function pad(value, width) {
+	return String(value).padStart(width, "0");
+}
+/** Whether `year` is a Gregorian leap year (div-4, except centuries unless div-400). */
+function isLeapYear(year) {
+	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+const MONTH_LENGTHS = [
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+/** The number of days in `month` (1-12) of `year`, accounting for leap years. */
+function daysInMonth(year, month) {
+	if (month === 2 && isLeapYear(year)) return 29;
+	return MONTH_LENGTHS[month - 1] ?? 31;
+}
+/** Class-level filter shared by every class carrying a `{ year, month, day }` triple. */
+const isRealCalendarDate = Schema.makeFilter(({ year, month, day }) => {
+	const max = daysInMonth(year, month);
+	return day <= max || `day ${day} does not exist in ${pad(year, 4)}-${pad(month, 2)} (month has ${max} days)`;
+}, { title: "a real calendar date" });
+const dateFields = {
+	year: Schema.Int.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 9999
+	})),
+	month: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 12
+	})),
+	day: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 31
+	}))
+};
+const timeFields = {
+	hour: Schema.Int.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 23
+	})),
+	minute: Schema.Int.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 59
+	})),
+	second: Schema.Int.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 60
+	})),
+	nanosecond: Schema.Int.check(Schema.isBetween({
+		minimum: 0,
+		maximum: 999999999
+	}))
+};
+/** `YYYY-MM-DD`. */
+function formatDate(date) {
+	return `${pad(date.year, 4)}-${pad(date.month, 2)}-${pad(date.day, 2)}`;
+}
+/**
+* `HH:MM:SS[.fraction]` — the fractional part is present only when
+* `nanosecond > 0`, trimmed to the shortest exact representation.
+*/
+function formatTime(time) {
+	const base = `${pad(time.hour, 2)}:${pad(time.minute, 2)}:${pad(time.second, 2)}`;
+	if (time.nanosecond === 0) return base;
+	return `${base}.${pad(time.nanosecond, 9).replace(/0+$/, "")}`;
+}
+/** `Z` for a zero offset, else `+hh:mm` / `-hh:mm`. */
+function formatOffset(offsetMinutes) {
+	if (offsetMinutes === 0) return "Z";
+	const sign = offsetMinutes < 0 ? "-" : "+";
+	const magnitude = Math.abs(offsetMinutes);
+	const hh = Math.trunc(magnitude / 60);
+	const mm = magnitude % 60;
+	return `${sign}${pad(hh, 2)}:${pad(mm, 2)}`;
+}
+/**
+* A TOML local date: `year`-`month`-`day` with no time-of-day or offset,
+* validated against the real Gregorian calendar.
+*
+* @public
+*/
+var TomlLocalDate = class extends Schema.Class("TomlLocalDate")(Schema.Struct(dateFields).check(isRealCalendarDate)) {
+	toString() {
+		return formatDate(this);
+	}
+};
+/**
+* A TOML local time: `hour`:`minute`:`second`[.`nanosecond`] with no date or
+* offset. `second` tolerates the RFC 3339 leap second (0-60).
+*
+* @public
+*/
+var TomlLocalTime = class extends Schema.Class("TomlLocalTime")(timeFields) {
+	toString() {
+		return formatTime(this);
+	}
+};
+/**
+* A TOML local date-time: a {@link TomlLocalDate} and a {@link TomlLocalTime}
+* combined, with no offset.
+*
+* @public
+*/
+var TomlLocalDateTime = class extends Schema.Class("TomlLocalDateTime")(Schema.Struct({
+	...dateFields,
+	...timeFields
+}).check(isRealCalendarDate)) {
+	toString() {
+		return `${formatDate(this)}T${formatTime(this)}`;
+	}
+};
+/**
+* A TOML offset date-time: a {@link TomlLocalDateTime} plus `offsetMinutes`
+* (-1439-1439). Parsing enforces `hh <= 23` / `mm <= 59` before construction;
+* this class only bounds the combined minute count.
+*
+* @public
+*/
+var TomlOffsetDateTime = class extends Schema.Class("TomlOffsetDateTime")(Schema.Struct({
+	...dateFields,
+	...timeFields,
+	offsetMinutes: Schema.Int.check(Schema.isBetween({
+		minimum: -1439,
+		maximum: 1439
+	}))
+}).check(isRealCalendarDate)) {
+	toString() {
+		return `${formatDate(this)}T${formatTime(this)}${formatOffset(this.offsetMinutes)}`;
+	}
+};
+
+//#endregion
+export { TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlOffsetDateTime };

package/TomlDiagnostic.js

@@ -0,0 +1,106 @@
+import { TOML_LEX_ERROR_CODES, TOML_PARSE_ERROR_CODES, TOML_SEMANTIC_ERROR_CODES, TOML_STRINGIFY_ERROR_CODES } from "./internal/diagnostics.js";
+import { Schema } from "effect";
+
+//#region src/TomlDiagnostic.ts
+/**
+* Error codes emitted by the lexer stage.
+*
+* @public
+*/
+const TomlLexErrorCode = Schema.Literals(TOML_LEX_ERROR_CODES);
+/**
+* Error codes emitted by the parser stage.
+*
+* @public
+*/
+const TomlParseErrorCode = Schema.Literals(TOML_PARSE_ERROR_CODES);
+/**
+* Error codes emitted by the semantic (table/key conflict) stage.
+*
+* @public
+*/
+const TomlSemanticErrorCode = Schema.Literals(TOML_SEMANTIC_ERROR_CODES);
+/**
+* Error codes emitted by the stringifier stage.
+*
+* @public
+*/
+const TomlStringifyErrorCode = Schema.Literals(TOML_STRINGIFY_ERROR_CODES);
+/**
+* Union of all TOML error codes across all pipeline stages. Stage
+* discrimination lives here (in the code), not in separate error classes.
+*
+* @public
+*/
+const TomlErrorCode = Schema.Union([
+	TomlLexErrorCode,
+	TomlParseErrorCode,
+	TomlSemanticErrorCode,
+	TomlStringifyErrorCode
+]);
+/**
+* One structured diagnostic: its {@link (TomlErrorCode:type)}, a
+* human-readable `message`, and its exact position (`offset`/`length`, plus
+* zero-based `line`/`character`).
+*
+* @remarks
+* The five-field positional core (`code`/`offset`/`length`/`line`/`character`)
+* is structurally identical to `@effected/jsonc`'s parse-error detail shape
+* and `@effected/yaml`'s `YamlDiagnostic`; `message` is this package's
+* additive extra.
+*
+* @public
+*/
+var TomlDiagnostic = class TomlDiagnostic extends Schema.Class("TomlDiagnostic")({
+	code: TomlErrorCode,
+	message: Schema.String,
+	offset: Schema.Number,
+	length: Schema.Number,
+	line: Schema.Number,
+	character: Schema.Number
+}) {
+	/**
+	* Materialize an engine record, deriving `line`/`character` (0-based)
+	* from `offset` against the source `text`. Advanced — the parse/stringify
+	* entry points call this for you.
+	*/
+	static fromRaw(source, raw) {
+		const { line, character } = lineChar(source, raw.offset);
+		return TomlDiagnostic.make({
+			code: raw.code,
+			message: raw.message,
+			offset: raw.offset,
+			length: raw.length,
+			line,
+			character
+		});
+	}
+};
+/**
+* Compute the zero-based line/character position of `offset` within `text`.
+* Recognizes `\n`, `\r` and `\r\n` as line breaks (TOML's newline grammar);
+* a CRLF pair counts as a single newline.
+*/
+function lineChar(text, offset) {
+	let line = 0;
+	let lineStart = 0;
+	const limit = Math.min(offset, text.length);
+	for (let i = 0; i < limit; i++) {
+		const ch = text.charCodeAt(i);
+		if (ch === 10) {
+			line++;
+			lineStart = i + 1;
+		} else if (ch === 13) {
+			if (i + 1 < text.length && text.charCodeAt(i + 1) === 10) i++;
+			line++;
+			lineStart = i + 1;
+		}
+	}
+	return {
+		line,
+		character: offset - lineStart
+	};
+}
+
+//#endregion
+export { TomlDiagnostic, TomlErrorCode, TomlLexErrorCode, TomlParseErrorCode, TomlSemanticErrorCode, TomlStringifyErrorCode };