soml-lang 0.0.3 → 0.0.4

package/distribution/edit.d.ts

@@ -13,19 +13,19 @@ Change one value in a document, and keep everything else as it is written: comme
 The value at `path` is replaced, or added when it does not exist yet, and an `undefined` value removes it. Only the changed part of the text is rewritten, and an edit to a formatted document leaves it formatted.
 
 - A new value is written as `stringify()` writes it, at the indentation of its line. So `0xFF` that is replaced by `255n` becomes `255`, and `8080` becomes `8080.0` unless you pass `8080n` or the `integers: 'number'` option. The members of a new object keep their order, unless you pass the `canonical: true` option. In a container that is on one line, it is written on one line too, so `[1, 2]` with a new item `{a: 3n}` becomes `[1, 2, {a: 3}]`.
-- A new member goes after the last member of its object, or after the last member that shares its dotted prefix, as `postgres.port` after `postgres.host`. Missing objects on the way are created.
+- A new member goes after the last member of its object. Missing objects on the way are created.
 - A new item can be added at the end of an array, with the index that is its length.
 - A new member or item goes on its own line without a comma, after the comments that the one before it owns (see below), and the commas of the other members and items stay as they are. When something follows the member or item before it on the same line, such as the closing bracket of the one-line container `{a: 1}`, it goes on that line after a comma, as in `{a: 1, b: 2}`. In an empty `[]` or `{}`, it goes on a line of its own, unless that container is inside a container on one line, so `a: [1, []]` becomes `a: [1, [2]]`.
 - A removed member or item takes the comments it owns, which are the ones that `format()` keeps with it: the comments after it on its line, also after its comma when nothing else follows there, and the block comments before it on its line, after the comma or bracket before it. So removing `2` from `[1, /* note *\/ 2]` gives `[1]`. A comment on a line of its own belongs to no member or item, so it stays. A removed member or item also removes its lines when nothing else is on them. A line that a block comment after it continues onto counts as one of its lines. Removing every item of a container closes it up to `[]` or `{}`, unless a comment is left inside.
 - A removed member or item takes its comma with it. When the removed items are the last ones and have no comma after them, they take the comma directly before them instead, when only spaces, tabs, and the comments they own are between, so `[1, 2]` becomes `[1]`.
-- Removing the last member under a dotted prefix, such as `a.b` when it is the only member that starts with `a.`, leaves `a: {}`, because the object `a` still exists. Removing the only member of a document without braces leaves `{}`.
+- Removing the only member of a document without braces leaves `{}`.
 
 Comments inside a value that is replaced or removed are removed with it. In a layout that `format()` never writes, an edit can leave odd spacing, such as a new item after a closing block string delimiter on its line that is indented differently from its neighbors. The document is always valid and has the right value. Removing a value that does not exist changes nothing and is not an error: a missing member, a missing object or array on the way, or an index at or past the end of its array. So removing the same path twice is safe, and `edit(text, path, undefined) === text` tells whether something was removed.
 
 The result is parsed before it is returned, so a bug in `edit()` throws an `Error` rather than returning a broken document.
 
 @param text - The document.
-@param path - The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`. A dotted key is followed like the objects it builds, so `['postgres', 'host']` finds `postgres.host: 'db'`.
+@param path - The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`.
 @param value - The new value, of the types that `stringify()` accepts, or `undefined` to remove the value.
 @param options - How an int is represented in `value`, and whether to sort its members, as for `stringify()`.
 @returns The changed document.
@@ -40,8 +40,8 @@ import {edit} from 'soml-lang';
 edit('name: \'api\' # The service\nport: 8080\n', ['port'], 9090n);
 //=> "name: 'api' # The service\nport: 9090\n"
 
-edit('postgres.host: \'db\'\n', ['postgres', 'port'], 5432n);
-//=> "postgres.host: 'db'\npostgres.port: 5432\n"
+edit('postgres: {host: \'db\'}\n', ['postgres', 'port'], 5432n);
+//=> "postgres: {host: 'db', port: 5432}\n"
 
 edit('a: 1\nb: 2\n', ['a'], undefined);
 //=> 'b: 2\n'

package/distribution/edit.js

@@ -8,19 +8,19 @@ Change one value in a document, and keep everything else as it is written: comme
 The value at `path` is replaced, or added when it does not exist yet, and an `undefined` value removes it. Only the changed part of the text is rewritten, and an edit to a formatted document leaves it formatted.
 
 - A new value is written as `stringify()` writes it, at the indentation of its line. So `0xFF` that is replaced by `255n` becomes `255`, and `8080` becomes `8080.0` unless you pass `8080n` or the `integers: 'number'` option. The members of a new object keep their order, unless you pass the `canonical: true` option. In a container that is on one line, it is written on one line too, so `[1, 2]` with a new item `{a: 3n}` becomes `[1, 2, {a: 3}]`.
-- A new member goes after the last member of its object, or after the last member that shares its dotted prefix, as `postgres.port` after `postgres.host`. Missing objects on the way are created.
+- A new member goes after the last member of its object. Missing objects on the way are created.
 - A new item can be added at the end of an array, with the index that is its length.
 - A new member or item goes on its own line without a comma, after the comments that the one before it owns (see below), and the commas of the other members and items stay as they are. When something follows the member or item before it on the same line, such as the closing bracket of the one-line container `{a: 1}`, it goes on that line after a comma, as in `{a: 1, b: 2}`. In an empty `[]` or `{}`, it goes on a line of its own, unless that container is inside a container on one line, so `a: [1, []]` becomes `a: [1, [2]]`.
 - A removed member or item takes the comments it owns, which are the ones that `format()` keeps with it: the comments after it on its line, also after its comma when nothing else follows there, and the block comments before it on its line, after the comma or bracket before it. So removing `2` from `[1, /* note *\/ 2]` gives `[1]`. A comment on a line of its own belongs to no member or item, so it stays. A removed member or item also removes its lines when nothing else is on them. A line that a block comment after it continues onto counts as one of its lines. Removing every item of a container closes it up to `[]` or `{}`, unless a comment is left inside.
 - A removed member or item takes its comma with it. When the removed items are the last ones and have no comma after them, they take the comma directly before them instead, when only spaces, tabs, and the comments they own are between, so `[1, 2]` becomes `[1]`.
-- Removing the last member under a dotted prefix, such as `a.b` when it is the only member that starts with `a.`, leaves `a: {}`, because the object `a` still exists. Removing the only member of a document without braces leaves `{}`.
+- Removing the only member of a document without braces leaves `{}`.
 
 Comments inside a value that is replaced or removed are removed with it. In a layout that `format()` never writes, an edit can leave odd spacing, such as a new item after a closing block string delimiter on its line that is indented differently from its neighbors. The document is always valid and has the right value. Removing a value that does not exist changes nothing and is not an error: a missing member, a missing object or array on the way, or an index at or past the end of its array. So removing the same path twice is safe, and `edit(text, path, undefined) === text` tells whether something was removed.
 
 The result is parsed before it is returned, so a bug in `edit()` throws an `Error` rather than returning a broken document.
 
 @param text - The document.
-@param path - The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`. A dotted key is followed like the objects it builds, so `['postgres', 'host']` finds `postgres.host: 'db'`.
+@param path - The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`.
 @param value - The new value, of the types that `stringify()` accepts, or `undefined` to remove the value.
 @param options - How an int is represented in `value`, and whether to sort its members, as for `stringify()`.
 @returns The changed document.
@@ -35,8 +35,8 @@ import {edit} from 'soml-lang';
 edit('name: \'api\' # The service\nport: 8080\n', ['port'], 9090n);
 //=> "name: 'api' # The service\nport: 9090\n"
 
-edit('postgres.host: \'db\'\n', ['postgres', 'port'], 5432n);
-//=> "postgres.host: 'db'\npostgres.port: 5432\n"
+edit('postgres: {host: \'db\'}\n', ['postgres', 'port'], 5432n);
+//=> "postgres: {host: 'db', port: 5432}\n"
 
 edit('a: 1\nb: 2\n', ['a'], undefined);
 //=> 'b: 2\n'
@@ -143,7 +143,7 @@ class Editor {
             this.#descend(element, index + 1, depth + 1);
         }
         else if (value === undefined) {
-            this.#removeNodes(array, [element]);
+            this.#removeNode(array, element);
         }
         else {
             this.#replace(element, depth + 1, array);
@@ -151,66 +151,30 @@ class Editor {
     }
     #editInObject(object, index, depth) {
         const path = this.#path;
-        if (typeof path[index] !== 'string') {
+        const key = path[index];
+        if (typeof key !== 'string') {
             throw new TypeError(`Cannot edit ${describePath(path)}, because ${describeParent(path, index)} is an object, so it needs a key, not an index`);
         }
         const value = this.#value;
-        const rest = path.slice(index);
-        // The members inside the object that `rest` names, when dotted keys built it, as `a.b` and `a.c` build `a`.
-        const dottedMembers = [];
-        // The last member whose key shares the most leading segments with `rest`, which is where a new member goes.
-        let sibling;
-        let siblingLength = 0;
-        for (const member of object.members) {
-            const { segments } = member.key;
-            let length = 0;
-            while (length < segments.length && length < rest.length && rest[length] === segments[length].value) {
-                length++;
+        const member = object.members.find(member => member.key.value === key);
+        if (member !== undefined) {
+            if (index < path.length - 1) {
+                this.#isInsideOneLine = this.#isOneLine(object);
+                this.#descend(member.value, index + 1, depth + 1);
             }
-            if (length === segments.length) {
-                if (length < rest.length) {
-                    this.#isInsideOneLine = this.#isOneLine(object);
-                    this.#descend(member.value, index + length, depth + length);
-                }
-                else if (value === undefined) {
-                    this.#removeMembers(object, [member], length);
-                }
-                else {
-                    this.#replaceMemberValue(member, depth + length, object);
-                }
-                return;
-            }
-            if (length === rest.length) {
-                dottedMembers.push(member);
-            }
-            else if (length > 0 && length >= siblingLength) {
-                sibling = member;
-                siblingLength = length;
-            }
-        }
-        // An index where dotted keys built an object, as `['a', 0]` for `a.b: 1`, matches no key segment.
-        if (sibling !== undefined && typeof rest[siblingLength] !== 'string') {
-            throw new TypeError(`Cannot edit ${describePath(path)}, because ${describeParent(path, index + siblingLength)} is an object, so it needs a key, not an index`);
-        }
-        if (dottedMembers.length > 0) {
-            if (value === undefined) {
-                this.#removeMembers(object, dottedMembers, rest.length);
+            else if (value === undefined) {
+                this.#removeMember(object, member);
             }
             else {
-                // The object that the dotted keys build becomes one member, where the first of them was.
-                const [first, ...others] = dottedMembers;
-                this.#replaceMembers(object, first, others, `${this.#keyPrefix(first, rest.length)}: ${this.#valueText(value, depth + rest.length, this.#indentation(first.range[0]), object)}`);
+                this.#replaceMemberValue(member, depth + 1, object);
             }
             return;
         }
         if (value === undefined) {
             return;
         }
-        // A new member continues the dotted prefix it shares with a sibling, and the rest of the path becomes nested objects.
-        const keyLength = siblingLength + 1;
-        const key = `${sibling === undefined ? '' : `${this.#keyPrefix(sibling, siblingLength)}.`}${formatKey(rest[siblingLength])}`;
-        const newValue = nest(path, index + keyLength, value);
-        this.#insert(object, sibling ?? object.members.at(-1), indentation => `${key}: ${this.#valueText(newValue, depth + keyLength, indentation, object)}`);
+        const newValue = nest(path, index + 1, value);
+        this.#insert(object, object.members.at(-1), indentation => `${formatKey(key)}: ${this.#valueText(newValue, depth + 1, indentation, object)}`);
     }
     /*
     Edits the path from `index` on, inside `node`, whose own depth is `depth`.
@@ -252,93 +216,49 @@ class Editor {
         return offset;
     }
     /*
-    Removes `members`, which share the first `length` segments of their keys. When no other member shares the segments before the last one, the object they are in would disappear with them, so it is written as `{}` instead: `a: {}` for an object that dotted keys built, and `{}` for a document without braces. A braced object keeps its braces anyway.
+    Removes `member`. Removing the only member of a document without braces leaves `{}` in its place, because a document is never empty, and the comments that the member owned stay.
     */
-    #removeMembers(object, members, length) {
-        const [first, ...others] = members;
-        const parentLength = length - 1;
-        const removed = new Set(members);
-        const isParentEmptied = object.members.every(member => removed.has(member) || !this.#sharesPrefix(member, first, parentLength));
-        if (!isParentEmptied || (parentLength === 0 && object.braced)) {
-            this.#removeNodes(object, members);
+    #removeMember(object, member) {
+        if (object.braced || object.members.length > 1) {
+            this.#removeNode(object, member);
             return;
         }
-        this.#replaceMembers(object, first, others, parentLength > 0 ? `${this.#keyPrefix(first, parentLength)}: {}` : '{}');
+        this.#replacements.push({ start: member.range[0], end: member.range[1], text: '{}' });
     }
     /*
-    Writes `text` in place of `first`, and removes `others`.
-    */
-    #replaceMembers(object, first, others, text) {
-        this.#replacements.push({ start: first.range[0], end: first.range[1], text });
-        this.#removeNodes(object, others);
-    }
-    /*
-    Removes `nodes` from `container`.
+    Removes `node` from `container`.
 
-    Removed lines that only blank lines separate are one removal, so that the blank lines between them go too, and each removal also takes a blank line that would be left next to another one or directly inside a bracket. When every item of a braced container goes and no comment is left inside, its brackets close up, as `[]`.
+    The removal also takes a blank line that would be left next to another one or directly inside a bracket. When the only item of a braced container goes and no comment is left inside, its brackets close up, as `[]`.
     */
-    #removeNodes(container, nodes) {
+    #removeNode(container, node) {
         const items = container.type === 'Array' ? container.elements : container.members;
-        const removed = new Set(nodes);
-        let trailingStart = items.length;
-        while (trailingStart > 0 && removed.has(items[trailingStart - 1])) {
-            trailingStart--;
-        }
-        // When the removed items reach the end and the last one has no comma after it, the first of them takes the comma before it, so that no trailing comma is left, as `[1, 2]` becomes `[1]`.
-        const lastItem = items.at(-1);
-        const firstToTakeCommaBefore = lastItem !== undefined && this.#text.charCodeAt(this.#skipTrivia(lastItem.range[1])) !== COMMA ? items[trailingStart] : undefined;
-        const removals = [];
-        for (const removal of nodes.flatMap(node => this.#removals(node, node === firstToTakeCommaBefore))) {
-            const previous = removals.at(-1);
-            if (previous !== undefined && removal.start < previous.end) {
-                // A removal that took the comma before it overlaps the one before.
-                previous.end = Math.max(previous.end, removal.end);
-                previous.isWholeLines = false;
-            }
-            else if (removal.isWholeLines && previous?.isWholeLines && this.#skipBlankLines(previous.end) === removal.start) {
-                previous.end = removal.end;
-            }
-            else {
-                removals.push(removal);
-            }
+        // When the removed item is the last one and has no comma after it, it takes the comma before it, so that no trailing comma is left, as `[1, 2]` becomes `[1]`.
+        const shouldTakeCommaBefore = node === items.at(-1) && this.#text.charCodeAt(this.#skipTrivia(node.range[1])) !== COMMA;
+        const removal = this.#nodeRemoval(node, shouldTakeCommaBefore);
+        if (removal.isWholeLines) {
+            this.#takeBlankLine(removal, container, this.#contentStart(container));
         }
-        // Each one takes at most the blank line next to it, so two never take the same one: only blank lines would be between them, and then they are one removal already.
-        const contentStart = this.#contentStart(container);
-        for (const removal of removals) {
-            if (removal.isWholeLines) {
-                this.#takeBlankLine(removal, container, contentStart);
-            }
-        }
-        if (nodes.length === items.length && isBraced(container) && !this.#isCommentLeft(container, removals)) {
+        if (items.length === 1 && isBraced(container) && !this.#isCommentLeft(container, removal)) {
             const [start, end] = container.range;
             this.#replacements.push({ start: start + 1, end: end - 1, text: '' });
             return;
         }
-        for (const { start, end } of removals) {
-            this.#replacements.push({ start, end, text: '' });
-        }
+        this.#replacements.push({ start: removal.start, end: removal.end, text: '' });
     }
     /*
-    Whether a comment inside `container` is outside every one of `removals`. The removals and the comments are both in source order, so one pass finds it.
+    Whether a comment inside `container` is outside `removal`.
     */
-    #isCommentLeft(container, removals) {
+    #isCommentLeft(container, removal) {
         const [start, end] = container.range;
-        let removalIndex = 0;
         return this.#comments.some(comment => {
             const [commentStart] = comment.range;
-            if (commentStart <= start || commentStart >= end) {
-                return false;
-            }
-            while (removalIndex < removals.length && removals[removalIndex].end <= commentStart) {
-                removalIndex++;
-            }
-            return removalIndex === removals.length || commentStart < removals[removalIndex].start;
+            return commentStart > start && commentStart < end && (commentStart < removal.start || commentStart >= removal.end);
         });
     }
     /*
     What removing a member or an item, with the comments it owns and its comma, takes out of the text. With `shouldTakeCommaBefore`, a comma directly before it goes too.
     */
-    #removals(node, shouldTakeCommaBefore) {
+    #nodeRemoval(node, shouldTakeCommaBefore) {
         const text = this.#text;
         const start = this.#ownedStart(node.range[0]);
         const end = this.#ownedEnd(node.range[1]);
@@ -355,7 +275,7 @@ class Editor {
         if (removalStart !== start && !removal.isWholeLines && this.#commentEnds.has(removal.end)) {
             removal.end = skipSpacesBack(text, removal.end);
         }
-        return [removal];
+        return removal;
     }
     /*
     The start of the block comments that a member or an item at `offset` owns before it: those on its line after the comma or the opening bracket before it, as `/* note *\/` in `[1, /* note *\/ 2]`. The formatter keeps them in front of it. It is `offset` when there are none.
@@ -431,7 +351,7 @@ class Editor {
         return offset === this.#text.length || (isBraced(container) && skipSpaces(this.#text, offset) === container.range[1] - 1);
     }
     /*
-    The start of the first line that is not blank after the line that opens `container`, or after the start of the text. The line that opens a container ends after the comments that follow its bracket, and when an item follows on it, this is `undefined`. Found once per removal of nodes rather than once per removed line, which would be quadratic in the number of blank lines or comments there.
+    The start of the first line that is not blank after the line that opens `container`, or after the start of the text. The line that opens a container ends after the comments that follow its bracket, and when an item follows on it, this is `undefined`.
     */
     #contentStart(container) {
         if (!isBraced(container)) {
@@ -511,25 +431,6 @@ class Editor {
         });
     }
     /*
-    The first `length` segments of a member's key, as they are written.
-    */
-    #keyPrefix(member, length) {
-        const { segments } = member.key;
-        return this.#text.slice(segments[0].range[0], segments[length - 1].range[1]);
-    }
-    /*
-    Whether the first `length` segments of the two keys are the same. A key with fewer segments always differs in one of its own, because a key that is a prefix of another one collides with it.
-    */
-    #sharesPrefix(member, other, length) {
-        const { segments } = member.key;
-        for (let index = 0; index < length; index++) {
-            if (segments[index].value !== other.key.segments[index].value) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /*
     The spaces and tabs at the start of the line that holds `offset`.
     */
     #indentation(offset) {

package/distribution/format.d.ts

@@ -1,7 +1,7 @@
 /**
 Format a document. Returns the document with its layout normalized, ending with one line feed.
 
-The layout follows the formatter in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, dotted keys, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
+The layout follows the formatter in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
 
 In detail, as the specification states:
 

package/distribution/format.js

@@ -4,7 +4,7 @@ const INDENT = '\t';
 /**
 Format a document. Returns the document with its layout normalized, ending with one line feed.
 
-The layout follows the formatter in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, dotted keys, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
+The layout follows the formatter in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
 
 In detail, as the specification states:
 

package/distribution/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference lib="esnext.temporal" preserve="true" />
 export { parse, type Value, type ObjectValue, type Document, type ParseOptions, } from './parse.ts';
-export { parseTree, visitorKeys, type Position, type SourceLocation, type Token, type Comment, type DocumentNode, type ObjectNode, type MemberNode, type ArrayNode, type KeyNode, type KeySegmentNode, type StringNode, type IntegerNode, type FloatNode, type BooleanNode, type NullNode, type InstantNode, type DurationNode, type DurationPart, type ValueNode, type Node, } from './tree.ts';
+export { parseTree, visitorKeys, type Position, type SourceLocation, type Token, type Comment, type DocumentNode, type ObjectNode, type MemberNode, type ArrayNode, type KeyNode, type StringNode, type IntegerNode, type FloatNode, type BooleanNode, type NullNode, type InstantNode, type DurationNode, type DurationPart, type ValueNode, type Node, } from './tree.ts';
 export { format, formatEdits, type FormatEdit } from './format.ts';
 export { edit, type EditOptions, type PathSegment } from './edit.ts';
 export { stringify, stringifyValue, compareKeys, type StringifyOptions, } from './stringify.ts';

package/distribution/parse.d.ts

@@ -58,7 +58,7 @@ parse(`
 name: 'api-gateway'
 replicas: 3
 timeout: 30.0
-postgres.host: 'db.internal'
+postgres: {host: 'db.internal'}
 `);
 //=> {name: 'api-gateway', replicas: 3n, timeout: 30, postgres: {host: 'db.internal'}}
 
@@ -85,7 +85,7 @@ parse(`
 name: 'api-gateway'
 replicas: 3
 timeout: 30.0
-postgres.host: 'db.internal'
+postgres: {host: 'db.internal'}
 `);
 //=> {name: 'api-gateway', replicas: 3n, timeout: 30, postgres: {host: 'db.internal'}}
 
@@ -112,7 +112,7 @@ parse(`
 name: 'api-gateway'
 replicas: 3
 timeout: 30.0
-postgres.host: 'db.internal'
+postgres: {host: 'db.internal'}
 `);
 //=> {name: 'api-gateway', replicas: 3n, timeout: 30, postgres: {host: 'db.internal'}}
 

package/distribution/parse.js

@@ -76,7 +76,7 @@ export function parse(text, options) {
     return new Parser(source, integers).parseDocument();
 }
 /*
-An instant, as nanoseconds since the Unix epoch, or a duration, as its length in nanoseconds. A class, so that a dotted key sees it as a value and not as an object.
+An instant, as nanoseconds since the Unix epoch, or a duration, as its length in nanoseconds.
 */
 export class Time {
     type;
@@ -198,26 +198,12 @@ function defineMember(object, key, value) {
         object[key] = value;
     }
 }
-function describeValue(value) {
-    if (Array.isArray(value)) {
-        return 'an array';
-    }
-    // Every parsed object is created with `{}`, unlike an instant or a duration.
-    return value !== null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype ? 'an object' : 'a value';
-}
-function formatPath(path) {
-    return path.map(segment => describeKey(segment)).join('.');
-}
 class Parser {
     #source;
     #index = 0;
     #integers;
     #createTime;
     /*
-    Objects created by dotted keys. They may be extended by further dotted keys, while an object written with braces is closed.
-    */
-    #dottedObjects = new WeakSet();
-    /*
     Where the document's collection starts, after the comments and whitespace before it.
     */
     #documentStart = 0;
@@ -336,11 +322,11 @@ class Parser {
     */
     #parseEntry(object, depth) {
         const keyStart = this.#index;
-        const path = this.#parseKey();
-        if (depth + path.length - 1 > MAX_DEPTH) {
-            this.#failTooDeep(keyStart);
-        }
+        const key = this.#parseKey();
         const code = this.#code();
+        if (code === DOT) {
+            this.#failDotInKey(keyStart);
+        }
         if (code !== COLON) {
             this.#failMissingColon(keyStart);
         }
@@ -349,20 +335,23 @@ class Parser {
         this.#skipTrivia();
         let value;
         try {
-            value = this.#parseValue(depth + path.length);
+            value = this.#parseValue(depth + 1);
         }
         catch (error) {
             if (error instanceof ParseError) {
-                this.#diagnoseBadValue(error, path, keyStart, colon);
+                this.#diagnoseBadValue(error, key, keyStart, colon);
             }
             throw error;
         }
-        this.#assign(object, path, value, keyStart);
+        if (Object.hasOwn(object, key)) {
+            this.#fail(`Duplicate key ${describeKey(key)}`, keyStart);
+        }
+        defineMember(object, key, value);
     }
     /*
     Reports a value that failed to parse as what the entry was meant to be, when that is clear.
     */
-    #diagnoseBadValue(error, path, keyStart, colon) {
+    #diagnoseBadValue(error, key, keyStart, colon) {
         // A key that contains a `:`, as in `12:30: 'lunch'`, ends at the first `:`, and the rest is read as the value.
         if (isBareKeyCharacter(this.#code(colon + 1))) {
             this.#diagnoseKeyWithColon(keyStart);
@@ -372,7 +361,7 @@ class Parser {
         const valueStart = this.#index;
         const commentHint = this.#describeCommentAsValue(colon);
         if (isValueOnNextLine) {
-            this.#diagnoseMissingValue(valueStart, path, keyStart, commentHint);
+            this.#diagnoseMissingValue(valueStart, key, keyStart, commentHint);
         }
         // A value that was left out at the end of the document or of an object.
         const code = this.#code(valueStart);
@@ -414,7 +403,7 @@ class Parser {
     /*
     An entry whose value was left out, as in `a:` followed by `'b': 1` on the next line, reads the next key as the value. That failure is reported as what it is.
     */
-    #diagnoseMissingValue(start, path, keyStart, commentHint) {
+    #diagnoseMissingValue(start, parent, keyStart, commentHint) {
         // A YAML block sequence.
         if (this.#code(start) === DASH && isSpace(this.#code(start + 1))) {
             this.#fail('Expected a value, but found a “-” list. An array is written in brackets, as in [80, 443]', start);
@@ -436,22 +425,18 @@ class Parser {
         if (firstCode !== SINGLE_QUOTE && firstCode !== DOUBLE_QUOTE && next !== LF && !isSpace(next) && !Number.isNaN(next)) {
             return;
         }
-        const hint = commentHint === '' ? this.#describeIndentedKey(path, key, keyStart, start) : commentHint;
-        this.#fail(`Expected a value, but found the key ${abbreviate(formatPath(key), 200)}${hint}`, start);
+        const hint = commentHint === '' ? this.#describeIndentedKey(parent, key, keyStart, start) : commentHint;
+        this.#fail(`Expected a value, but found the key ${describeKey(key)}${hint}`, start);
     }
     /*
     The hint for a key at `start` that is indented under the entry whose value is missing, as YAML nests an object.
     */
-    #describeIndentedKey(path, key, keyStart, start) {
+    #describeIndentedKey(parent, key, keyStart, start) {
         const keyIndentation = getIndentation(this.#source, keyStart);
         const indentation = getIndentation(this.#source, start);
-        if (keyIndentation === undefined || indentation === undefined || indentation <= keyIndentation) {
-            return '';
-        }
         // The keys are written as in a document, so that the suggestion is valid, rather than as JSON strings like the rest of the message, whose escapes, such as `\b`, are not all valid.
-        const parent = abbreviate(path.map(segment => formatKey(segment)).join('.'), 200);
-        const child = abbreviate(key.map(segment => formatKey(segment)).join('.'), 200);
-        return `. Indentation does not nest objects, so write ${parent}: {${child}: …} or ${parent}.${child}: …`;
+        const hint = `. Indentation does not nest objects, so write ${abbreviate(formatKey(parent), 200)}: {${abbreviate(formatKey(key), 200)}: …}`;
+        return keyIndentation === undefined || indentation === undefined || indentation <= keyIndentation ? '' : hint;
     }
     #failMissingColon(keyStart) {
         const source = this.#source;
@@ -468,7 +453,7 @@ class Parser {
             }
         }
         const colon = source.indexOf(':', next);
-        // A key with a space in it, such as `the name: 1`. The hint is only given for plain words, because quoting a dotted or quoted key would change what it means, and for a `:` that whitespace or the end follows, because quoting the words before the `:` in `server localhost:8080` would give a valid document with another meaning. So `the name:1` gets no hint.
+        // A key with a space in it, such as `the name: 1`. The hint is only given for plain words, because quoting a quoted key would change what it means, and for a `:` that whitespace or the end follows, because quoting the words before the `:` in `server localhost:8080` would give a valid document with another meaning. So `the name:1` gets no hint.
         if (colon !== -1 && next > this.#index && isBareKeyCharacter(nextCode) && colon < findLineEnd(source, next) && isSpaceOrLineEnd(source.charCodeAt(colon + 1))) {
             // Only spaces and tabs are trimmed, because `trimEnd()` would also remove characters that are not whitespace in SOML, such as U+00A0.
             const key = source.slice(keyStart, skipSpacesBack(source, colon));
@@ -486,14 +471,6 @@ class Parser {
         this.#fail(`Expected “:” after the key, but found ${this.#describeHere()}${hint}`);
     }
     #parseKey() {
-        const path = [this.#parseKeySegment()];
-        while (this.#code() === DOT) {
-            this.#index++;
-            path.push(this.#parseKeySegment(true));
-        }
-        return path;
-    }
-    #parseKeySegment(isAfterDot = false) {
         const source = this.#source;
         const start = this.#index;
         const code = source.charCodeAt(start);
@@ -512,8 +489,7 @@ class Parser {
             if (code === OPEN_BRACKET) {
                 this.#diagnoseTableHeader();
             }
-            const expected = isAfterDot ? 'Expected a key segment after “.”' : 'Expected a key';
-            this.#fail(this.#isAtEnd() ? expected : `${expected}, but found ${this.#describeHere()}${this.#keyQuotingHint()}${this.#slashCommentHint()}`);
+            this.#fail(this.#isAtEnd() ? 'Expected a key' : `Expected a key, but found ${this.#describeHere()}${this.#keyQuotingHint()}${this.#slashCommentHint()}`);
         }
         this.#index = end;
         return source.slice(start, end);
@@ -529,39 +505,23 @@ class Parser {
         const key = QUOTABLE_KEY.exec(this.#source.slice(this.#index, this.#index + MAX_DIAGNOSED_LENGTH))?.[0];
         return key === undefined ? KEY_QUOTING_HINT : `${KEY_QUOTING_HINT}, as in '${abbreviate(key)}'`;
     }
-    #assign(object, path, value, keyStart) {
-        let target = object;
-        const lastIndex = path.length - 1;
-        for (let index = 0; index < lastIndex; index++) {
-            const key = path[index];
-            if (!Object.hasOwn(target, key)) {
-                const child = {};
-                this.#dottedObjects.add(child);
-                defineMember(target, key, child);
-                target = child;
-                continue;
-            }
-            // Only an object built by dotted keys is in the set, which is checked next.
-            const existing = target[key];
-            if (!this.#dottedObjects.has(existing)) {
-                const prefix = formatPath(path.slice(0, index + 1));
-                const what = describeValue(existing);
-                const reason = what === 'an object' ? 'an object written with braces, which is closed' : what;
-                this.#fail(`Cannot set ${formatPath(path)}, because ${prefix} is already ${reason} and a dotted key cannot extend it`, keyStart);
-            }
-            target = existing;
+    /*
+    A `.` after a key, as in `example.com: 1`. A key is never a path, so the `.` is meant either as part of the key or as nesting.
+    */
+    #failDotInKey(keyStart) {
+        const source = this.#source;
+        let end = this.#index;
+        while (end < keyStart + MAX_DIAGNOSED_LENGTH && (isBareKeyCharacter(source.charCodeAt(end)) || source.charCodeAt(end) === DOT)) {
+            end++;
         }
-        const key = path[lastIndex];
-        if (Object.hasOwn(target, key)) {
-            if (this.#dottedObjects.has(target[key])) {
-                this.#fail(`Cannot set ${formatPath(path)}: it is already an object built by dotted keys`, keyStart);
-            }
-            this.#fail(`Duplicate key ${formatPath(path)}`, keyStart);
+        const key = source.slice(keyStart, end);
+        const words = key.split('.');
+        // The suggestions are only given for a bare key whose dots each have a word on both sides, so that both are valid.
+        if (source.charCodeAt(end) !== COLON || !isBareKeyCharacter(source.charCodeAt(keyStart)) || words.includes('')) {
+            this.#fail('A key cannot contain “.” unless it is quoted. Quote the whole key, or use braces to nest, as in a: {b: …}');
         }
-        defineMember(target, key, value);
-    }
-    #failTooDeep(offset = this.#index) {
-        this.#fail(`The document is nested more than ${MAX_DEPTH} levels deep`, offset);
+        const nested = `${words.join(': {')}: …${'}'.repeat(words.length - 1)}`;
+        this.#fail(`A bare key cannot contain “.”. Quote it, as in '${abbreviate(key)}', or use braces to nest, as in ${abbreviate(nested)}`);
     }
     #parseObject(depth) {
         const object = {};
@@ -582,7 +542,7 @@ class Parser {
     */
     #parseItems(depth, closing, parseItem) {
         if (depth > MAX_DEPTH) {
-            this.#failTooDeep();
+            this.#fail(`The document is nested more than ${MAX_DEPTH} levels deep`);
         }
         const start = this.#index;
         this.#index++;
@@ -758,13 +718,13 @@ class Parser {
             return;
         }
         const line = source.slice(lineStart, Math.min(findLineEnd(source, this.#index), lineStart + MAX_DIAGNOSED_LENGTH));
-        // The name is a valid key, so that the suggestions are valid: a dot has a segment on each side.
-        const match = /^[\t ]*\[\[?(?<name>[A-Z_a-z][\w\-]*(?:\.[\w\-]+)*)\]\]?[\t ]*$/v.exec(line);
+        // The name is a valid key, so that the suggestion is valid.
+        const match = /^[\t ]*\[\[?(?<name>[A-Z_a-z][\w\-]*)\]\]?[\t ]*$/v.exec(line);
         if (match === null) {
             return;
         }
         const { name } = match.groups;
-        this.#fail(`There are no table headers. Write the table as an object, as in ${abbreviate(name)}: {…}, or with dotted keys, as in ${abbreviate(name)}.key: …`);
+        this.#fail(`There are no table headers. Write the table as an object, as in ${abbreviate(name)}: {…}`);
     }
     /*
     A YAML literal block scalar indicator, as in `key: |` or `key: |-`, at the end of its line.

package/distribution/stringify.d.ts

@@ -32,7 +32,7 @@ export type StringifyOptions = {
     readonly canonical?: boolean;
 };
 /**
-Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments, dotted keys, and block strings are never written.
+Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments and block strings are never written.
 
 Members keep the order of `value`, which reads better in a file for people, and every other rule of canonical form is followed. With the `canonical: true` option, members are sorted by key, and the output is canonical form: two equal values produce the same bytes, so it can be hashed, signed, or compared.
 

package/distribution/stringify.js

@@ -27,7 +27,7 @@ const ESCAPES = new Map([
     ['\t', String.raw `\t`],
 ]);
 /**
-Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments, dotted keys, and block strings are never written.
+Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments and block strings are never written.
 
 Members keep the order of `value`, which reads better in a file for people, and every other rule of canonical form is followed. With the `canonical: true` option, members are sorted by key, and the output is canonical form: two equal values produce the same bytes, so it can be hashed, signed, or compared.
 

package/distribution/tree.d.ts

@@ -38,7 +38,7 @@ type Located<Type extends string> = {
 /**
 A token. `value` is its source text.
 
-A `Punctuator` is one of `{`, `}`, `[`, `]`, `:`, `,`, and `.`. A `Keyword` is `true`, `false`, or `null`. `infinity` and `-infinity` are `Float` tokens, and a quoted key segment is a `String` token.
+A `Punctuator` is one of `{`, `}`, `[`, `]`, `:`, and `,`. A `Keyword` is `true`, `false`, or `null`. `infinity` and `-infinity` are `Float` tokens, and a quoted key is a `String` token.
 */
 export type Token = Located<'Punctuator' | 'BareKey' | 'String' | 'Integer' | 'Float' | 'Keyword' | 'Instant' | 'Duration'> & {
     readonly value: string;
@@ -84,7 +84,7 @@ A `key: value` member of an object.
 */
 export type MemberNode = Located<'Member'> & {
     /**
-    The key, which can be dotted.
+    The key.
     */
     readonly key: KeyNode;
     /**
@@ -102,24 +102,15 @@ export type ArrayNode = Located<'Array'> & {
     readonly elements: readonly ValueNode[];
 };
 /**
-A key, with more than one segment when it is dotted.
+A key.
 */
 export type KeyNode = Located<'Key'> & {
-    /**
-    The segments between the dots, in source order.
-    */
-    readonly segments: readonly KeySegmentNode[];
-};
-/**
-One segment of a key, which is the whole key unless it is dotted.
-*/
-export type KeySegmentNode = Located<'KeySegment'> & {
     /**
     The decoded key.
     */
     readonly value: string;
     /**
-    How the segment is written: bare, as `'...'`, or as `"..."`.
+    How the key is written: bare, as `'...'`, or as `"..."`.
     */
     readonly style: 'bare' | 'literal' | 'escaped';
 };
@@ -221,7 +212,7 @@ export type ValueNode = ObjectNode | ArrayNode | StringNode | IntegerNode | Floa
 /**
 Any node in a tree.
 */
-export type Node = DocumentNode | MemberNode | KeyNode | KeySegmentNode | ValueNode;
+export type Node = DocumentNode | MemberNode | KeyNode | ValueNode;
 /**
 The properties of each node type that hold its child nodes, in source order, for tools that walk the tree, such as an ESLint language plugin.
 
@@ -240,7 +231,7 @@ export declare const visitorKeys: Readonly<Record<Node['type'], readonly string[
 /**
 Parse a document into a syntax tree, for tools such as linters and formatters. Returns a `Document` node, which also holds every token and comment.
 
-Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in ESTree. A `ParseError` counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key segment shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
+Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in ESTree. A `ParseError` counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
 
 @param text - The document.
 @returns The root node, which also holds every token and comment.

package/distribution/tree.js

@@ -1,5 +1,5 @@
 import { parseWithTimes, } from "./parse.js";
-import { isBareKeyCharacter, isSpace, findNumberEnd, findLineEnd, findBlockStringEnd, LF, DOUBLE_QUOTE, HASH, SINGLE_QUOTE, ASTERISK, COMMA, DOT, SLASH, BACKSLASH, OPEN_BRACKET, CLOSE_BRACKET, OPEN_BRACE, CLOSE_BRACE, } from "./shared.js";
+import { isBareKeyCharacter, isSpace, findNumberEnd, findLineEnd, findBlockStringEnd, LF, DOUBLE_QUOTE, HASH, SINGLE_QUOTE, ASTERISK, COMMA, SLASH, BACKSLASH, OPEN_BRACKET, CLOSE_BRACKET, OPEN_BRACE, CLOSE_BRACE, } from "./shared.js";
 /**
 The properties of each node type that hold its child nodes, in source order, for tools that walk the tree, such as an ESLint language plugin.
 
@@ -20,8 +20,7 @@ export const visitorKeys = Object.freeze({
     Object: Object.freeze(['members']),
     Member: Object.freeze(['key', 'value']),
     Array: Object.freeze(['elements']),
-    Key: Object.freeze(['segments']),
-    KeySegment: Object.freeze([]),
+    Key: Object.freeze([]),
     String: Object.freeze([]),
     Integer: Object.freeze([]),
     Float: Object.freeze([]),
@@ -40,7 +39,7 @@ const RADIX = new Map([['x', 16], ['o', 8], ['b', 2]]);
 /**
 Parse a document into a syntax tree, for tools such as linters and formatters. Returns a `Document` node, which also holds every token and comment.
 
-Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in ESTree. A `ParseError` counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key segment shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
+Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in ESTree. A `ParseError` counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
 
 @param text - The document.
 @returns The root node, which also holds every token and comment.
@@ -75,7 +74,7 @@ function readScalar(raw) {
     return parseWithTimes(`[${raw}]`)[0];
 }
 /*
-Every node is an object literal with the same property order, `type`, its own fields, `range`, and `loc`, rather than one generic function that spreads the fields, which is several times slower. A node that is one token, such as a scalar or a key segment, shares the token's `range` and `loc`.
+Every node is an object literal with the same property order, `type`, its own fields, `range`, and `loc`, rather than one generic function that spreads the fields, which is several times slower. A node that is one token, such as a scalar or a key, shares the token's `range` and `loc`.
 */
 class TreeBuilder {
     #source;
@@ -236,27 +235,12 @@ class TreeBuilder {
         };
     }
     #key() {
-        const segments = [this.#keySegment()];
-        while (this.#code() === DOT) {
-            this.#punctuator();
-            segments.push(this.#keySegment());
-        }
-        const first = segments[0];
-        const last = segments.at(-1);
-        return {
-            type: 'Key',
-            segments,
-            range: [first.range[0], last.range[1]],
-            loc: spanLocation(first, last),
-        };
-    }
-    #keySegment() {
         const start = this.#index;
         const code = this.#code();
         if (code === SINGLE_QUOTE || code === DOUBLE_QUOTE) {
             const { value, style, token: { range, loc } } = this.#singleLineString();
             return {
-                type: 'KeySegment',
+                type: 'Key',
                 value,
                 style,
                 range,
@@ -268,7 +252,7 @@ class TreeBuilder {
         }
         const { value, range, loc } = this.#token('BareKey', start, this.#index);
         return {
-            type: 'KeySegment',
+            type: 'Key',
             value,
             style: 'bare',
             range,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "soml-lang",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"description": "Reference parser, serializer, and formatter for SOML, a config format for humans",
 	"license": "MIT",
 	"repository": "som-lang/soml-javascript",

package/readme.md

@@ -1,6 +1,6 @@
 # soml
 
-> The reference parser, serializer with canonical form, and formatter for [SOML](https://soml.sh), a config format for humans
+> The reference parser, serializer, and formatter for [SOML](https://soml.sh), a config format for humans
 
 > [!NOTE]
 > The format is a draft. See the [specification](https://github.com/soml-lang/soml/blob/main/spec.md).
@@ -40,7 +40,7 @@ replicas: 3
 timeout: 30.0
 grace: 1m30s
 deployed-at: 2026-09-19T14:00:00Z
-postgres.host: 'db.internal'
+postgres: {host: 'db.internal'}
 `);
 //=> {
 // 	name: 'api-gateway',
@@ -102,7 +102,7 @@ parse(`
 name: 'api-gateway'
 replicas: 3
 timeout: 30.0
-postgres.host: 'db.internal'
+postgres: {host: 'db.internal'}
 `);
 //=> {name: 'api-gateway', replicas: 3n, timeout: 30, postgres: {host: 'db.internal'}}
 ```
@@ -150,7 +150,7 @@ tree.comments[0];
 //=> {type: 'Line', value: ' The default', range: [11, 24], loc: {…}}
 ```
 
-Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in [ESTree](https://github.com/estree/estree). A [`ParseError`](#parseerror) counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key segment shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
+Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16 offsets into `text`, and a `loc`, which is `{start: {line, column}, end: {line, column}}`, with a 1-based line and a 0-based column in UTF-16 code units, as in [ESTree](https://github.com/estree/estree). A [`ParseError`](#parseerror) counts its column differently, for people to read, so use its `offset` to find the position in the tree. A scalar node or a key shares its `range` and `loc` with its token, and other nodes, except `Document`, share the positions in `loc` with their first and last token, so treat them as read-only.
 
 | Node | Fields |
 |---|---|
@@ -158,8 +158,7 @@ Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16
 | `Object` | `members`; `braced`, which is `false` only for a top-level object without braces |
 | `Member` | `key`; `value` |
 | `Array` | `elements` |
-| `Key` | `segments`, more than one for a dotted key |
-| `KeySegment` | `value`, decoded; `style`: `'bare'`, `'literal'`, or `'escaped'` |
+| `Key` | `value`, decoded; `style`: `'bare'`, `'literal'`, or `'escaped'` |
 | `String` | `value`, decoded; `style`: `'literal'` or `'escaped'`; `block` |
 | `Integer` | `value`, a `bigint`; `radix`: `2`, `8`, `10`, or `16` |
 | `Float` | `value`, including `Infinity` and `-Infinity` |
@@ -168,7 +167,7 @@ Every node, token, and comment has a `range`, which is `[start, end]` as UTF-16
 | `Instant` | `value`, a `Temporal.Instant`, made when it is first read, also by spreading or serializing the node |
 | `Duration` | `value`, a `Temporal.Duration`, made when it is first read, also by spreading or serializing the node; `negative`, whether it is written with a `-`; `parts`, each `{number, unit}` as written, so `-1h1.5m` has the parts `{number: '1', unit: 'h'}` and `{number: '1.5', unit: 'm'}` |
 
-A token is `{type, value, range, loc}`, where `type` is `'Punctuator'` (for `{`, `}`, `[`, `]`, `:`, `,`, and `.`), `'BareKey'`, `'String'`, `'Integer'`, `'Float'`, `'Keyword'` (for `true`, `false`, and `null`), `'Instant'`, or `'Duration'`, and `value` is its source text. `infinity` and `-infinity` are `'Float'` tokens, and a quoted key segment is a `'String'` token. A comment is `{type, value, range, loc}`, where `type` is `'Line'` or `'Block'`, and `value` is the text without `#`, or without `/*` and `*/`.
+A token is `{type, value, range, loc}`, where `type` is `'Punctuator'` (for `{`, `}`, `[`, `]`, `:`, and `,`), `'BareKey'`, `'String'`, `'Integer'`, `'Float'`, `'Keyword'` (for `true`, `false`, and `null`), `'Instant'`, or `'Duration'`, and `value` is its source text. `infinity` and `-infinity` are `'Float'` tokens, and a quoted key is a `'String'` token. A comment is `{type, value, range, loc}`, where `type` is `'Line'` or `'Block'`, and `value` is the text without `#`, or without `/*` and `*/`.
 
 ### visitorKeys
 
@@ -188,7 +187,7 @@ visitorKeys.Integer;
 
 Format a document. Returns the document with its layout normalized, ending with one line feed.
 
-The layout follows the [formatter](https://github.com/soml-lang/soml/blob/main/spec.md#formatting) in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, dotted keys, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
+The layout follows the [formatter](https://github.com/soml-lang/soml/blob/main/spec.md#formatting) in the specification: one tab per level, every member and item on its own line with no commas, and no trailing whitespace or runs of blank lines. An object or an array whose brackets are on one line stays on one line, as in `ports: [80, 443]`, with a comma and a space between its members or items. To give a one-line container one member or item per line, put a line break anywhere inside it. Comments, member order, block strings, and the spelling of every value stay as they are, so the value never changes. The one change inside a block comment is the same layout rule: trailing whitespace is removed, and runs of blank lines collapse to one.
 
 Throws the same [`ParseError`](#parseerror) as `parse()`, and a `TypeError` when `text` is not a string.
 
@@ -237,20 +236,20 @@ import {edit} from 'soml-lang';
 edit('name: \'api\' # The service\nport: 8080\n', ['port'], 9090n);
 //=> "name: 'api' # The service\nport: 9090\n"
 
-edit('postgres.host: \'db\'\n', ['postgres', 'port'], 5432n);
-//=> "postgres.host: 'db'\npostgres.port: 5432\n"
+edit('postgres: {host: \'db\'}\n', ['postgres', 'port'], 5432n);
+//=> "postgres: {host: 'db', port: 5432}\n"
 
 edit('a: 1\nb: 2\n', ['a'], undefined);
 //=> 'b: 2\n'
 ```
 
 - A new value is written as `stringify()` writes it, at the indentation of its line. So `0xFF` that is replaced by `255n` becomes `255`, and `8080` becomes `8080.0` unless you pass `8080n` or the `integers: 'number'` option. The members of a new object keep their order, unless you pass the `canonical: true` option. In a container that is on one line, it is written on one line too, so `[1, 2]` with a new item `{a: 3n}` becomes `[1, 2, {a: 3}]`.
-- A new member goes after the last member of its object, or after the last member that shares its dotted prefix, as `postgres.port` after `postgres.host`. Missing objects on the way are created.
+- A new member goes after the last member of its object. Missing objects on the way are created.
 - A new item can be added at the end of an array, with the index that is its length.
 - A new member or item goes on its own line without a comma, after the comments that the one before it owns (see below), and the commas of the other members and items stay as they are. When something follows the member or item before it on the same line, such as the closing bracket of the one-line container `{a: 1}`, it goes on that line after a comma, as in `{a: 1, b: 2}`. In an empty `[]` or `{}`, it goes on a line of its own, unless that container is inside a container on one line, so `a: [1, []]` becomes `a: [1, [2]]`.
 - A removed member or item takes the comments it owns, which are the ones that `format()` keeps with it: the comments after it on its line, also after its comma when nothing else follows there, and the block comments before it on its line, after the comma or bracket before it. So removing `2` from `[1, /* note */ 2]` gives `[1]`. A comment on a line of its own belongs to no member or item, so it stays. A removed member or item also removes its lines when nothing else is on them. A line that a block comment after it continues onto counts as one of its lines. Removing every item of a container closes it up to `[]` or `{}`, unless a comment is left inside.
 - A removed member or item takes its comma with it. When the removed items are the last ones and have no comma after them, they take the comma directly before them instead, when only spaces, tabs, and the comments they own are between, so `[1, 2]` becomes `[1]`.
-- Removing the last member under a dotted prefix, such as `a.b` when it is the only member that starts with `a.`, leaves `a: {}`, because the object `a` still exists. Removing the only member of a document without braces leaves `{}`.
+- Removing the only member of a document without braces leaves `{}`.
 
 Comments inside a value that is replaced or removed are removed with it. In a layout that `format()` never writes, an edit can leave odd spacing, such as a new item after a closing block string delimiter on its line that is indented differently from its neighbors. The document is always valid and has the right value. Removing a value that does not exist changes nothing and is not an error: a missing member, a missing object or array on the way, or an index at or past the end of its array. So removing the same path twice is safe, and `edit(text, path, undefined) === text` tells whether something was removed.
 
@@ -268,7 +267,7 @@ The document.
 
 Type: `Array<string | number>`
 
-The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`. A dotted key is followed like the objects it builds, so `['postgres', 'host']` finds `postgres.host: 'db'`.
+The keys and array indexes that lead to the value, such as `['servers', 0, 'port']`.
 
 #### value
 
@@ -306,7 +305,7 @@ edit('a: 1\n', ['b'], {y: 1n, x: 2n}, {canonical: true});
 
 ### stringify(value, options?)
 
-Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments, dotted keys, and block strings are never written.
+Serialize an object or an array to SOML. Nesting is written with braces and tabs, and the output ends with one line feed. Comments and block strings are never written.
 
 Members keep the order of `value`, which reads better in a file for people, and every other rule of canonical form is followed. With the [`canonical: true`](#canonical-1) option, members are sorted by key, and the output is canonical form: two equal values produce the same bytes, so it can be hashed, signed, or compared.
 
@@ -477,7 +476,7 @@ Up to three lines ending at the error, with a caret under the position. A long l
 
 ## Limits
 
-- **Nesting is limited to 100 levels**, as the spec requires: every document up to 100 levels is accepted, by `parse()`, `parseTree()`, `format()`, and `edit()`, and every deeper one is rejected. `stringify()` refuses a deeper value, and `edit()` refuses a change that would make one. The document's own collection is level 1, and a dotted key counts the objects it builds, so `a.b.c: 1` has a depth of 3, the same as `a: {b: {c: 1}}`.
+- **Nesting is limited to 100 levels**, as the spec requires: every document up to 100 levels is accepted, by `parse()`, `parseTree()`, `format()`, and `edit()`, and every deeper one is rejected. `stringify()` refuses a deeper value, and `edit()` refuses a change that would make one. The document's own collection is level 1, so `a: {b: {c: 1}}` has a depth of 3.
 
 ## Conformance suite
 
@@ -504,7 +503,7 @@ The same 2.5 MB of config-shaped data on an Apple M-series machine with Node.js
 | smol-toml | 100 MB/s | 135 MB/s |
 | json5 | 22 MB/s | 85 MB/s |
 
-A hand-written style document (comments, dotted keys, block strings, hex ints, instants) parses at about 110 MB/s, and minified one-line input at about 120 MB/s. The `stringify` figure is with `canonical: true`, which sorts every object's keys, a step smol-toml does not need. The default keeps member order and skips that step, so it is faster.
+A hand-written style document (comments, block strings, hex ints, instants) parses at about 110 MB/s, and minified one-line input at about 120 MB/s. The `stringify` figure is with `canonical: true`, which sorts every object's keys, a step smol-toml does not need. The default keeps member order and skips that step, so it is faster.
 
 `parseTree()` runs at about 35 MB/s, and `format()` at about 20 to 25 MB/s, also on an already formatted document. Both are slower than `parse()`, because the tree has a node and a location for every token.