@nette/neon 0.0.0-stage → 1.0.0

package/dist/encoder.d.ts

@@ -0,0 +1,16 @@
+export interface EncodeOptions {
+    /** Writes arrays as blocks, one item per line; a function is asked for every array, with the keys to it. */
+    blockMode?: boolean | BlockFilter;
+    /** Indentation of nested blocks and of the lines of multiline strings. */
+    indentation?: string;
+    /** @internal Writes multiline strings in """, for a document where ''' would close an earlier string. */
+    doubleQuotedMultiline?: boolean;
+}
+/** Decides whether the array is written as a block. */
+export type BlockFilter = (value: unknown, path: readonly string[]) => boolean;
+/** Writes a value as NEON. */
+export declare function encode(value: unknown, options?: EncodeOptions): string;
+/** Whether the string has to be quoted. */
+export declare function needsQuotes(s: string): boolean;
+/** Shortest round-trip digits, positional for exponents -4 to 16; null for INF and NAN. */
+export declare function formatFloat(f: number): string | null;

package/dist/encoder.js

@@ -0,0 +1,292 @@
+import { NeonError } from "./errors.js";
+import { Scanner } from "./scanner.js";
+import { Chain, Entity, evaluateLiteral, isIntegerKey, MaxDepth, NeonDate } from "./values.js";
+/** Writes a value as NEON. */
+export function encode(value, options = {}) {
+    return new Encoder(options).encode(value);
+}
+class Encoder {
+    #stack = [];
+    #arrays = [];
+    #path = [];
+    indentation;
+    doubleQuoted;
+    blockMode;
+    constructor(options) {
+        this.indentation = options.indentation ?? '\t';
+        this.doubleQuoted = options.doubleQuotedMultiline ?? false;
+        this.blockMode = options.blockMode ?? false;
+        if (typeof this.indentation !== 'string' || !/^[\t ]+$/.test(this.indentation)) {
+            throw new TypeError('The indentation is a non-empty run of spaces and tabs.');
+        }
+        else if (typeof this.blockMode !== 'boolean' && typeof this.blockMode !== 'function') {
+            throw new TypeError('The blockMode is a boolean or a function.');
+        }
+    }
+    encode(value) {
+        const entries = this.entries(value);
+        if (!entries || !this.isBlock(value)) {
+            return this.inline(value);
+        }
+        else if (!entries.length) {
+            return isMapLike(value) ? '{}' : '[]';
+        }
+        return this.block(value, entries);
+    }
+    block(container, entries) {
+        let res = '';
+        this.enter(container, true);
+        for (const [key, value, hidden] of withHiddenKeys(entries)) {
+            this.#path.push(key);
+            const prefix = hidden ? '-' : this.key(key) + ':';
+            const nested = this.entries(value);
+            if (nested?.length && this.isBlock(value)) {
+                const text = indent(this.block(value, nested), this.indentation);
+                res += prefix + '\n' + text + (text.endsWith('\n\n') ? '' : '\n');
+            }
+            else {
+                res += prefix + ' ' + this.inline(value) + '\n';
+            }
+            this.#path.pop();
+        }
+        this.leave();
+        return res;
+    }
+    isBlock(value) {
+        return typeof this.blockMode === 'function' ? this.blockMode(value, [...this.#path]) : this.blockMode;
+    }
+    inline(value) {
+        if (value instanceof Entity) {
+            this.enter(value);
+            const res = value.value === Chain ? this.chain(value) : this.entity(value);
+            this.leave();
+            return res;
+        }
+        const entries = this.entries(value);
+        if (entries) {
+            const [open, close] = Array.isArray(value) ? ['[', ']'] : ['{', '}'];
+            return open + this.items(value) + close;
+        }
+        return this.scalar(value);
+    }
+    entity(entity, link = false) {
+        const head = this.inline(entity.value);
+        if (entity.value instanceof Entity) {
+            this.fail('the value of an entity cannot be an entity or a chain');
+        }
+        else if (link && /^['"[{]/.test(head)) {
+            this.fail('a link of a chain after the first needs a head written as a literal');
+        }
+        return head + '(' + this.items(entity.attributes) + ')';
+    }
+    chain(chain) {
+        const links = chain.attributes;
+        if (!Array.isArray(links) || links.length < 2 || !links.every((link) => link instanceof Entity && link.value !== Chain)) {
+            this.fail('a chain must hold a list of two or more entities');
+        }
+        return links.map((link, i) => {
+            this.enter(link);
+            const res = this.entity(link, i > 0);
+            this.leave();
+            return res;
+        }).join('');
+    }
+    items(container) {
+        this.enter(container, true);
+        const res = withHiddenKeys(this.entries(container) ?? this.fail('attributes must be an array or an object'))
+            .map(([key, value, hidden]) => {
+            this.#path.push(key);
+            const text = (hidden ? '' : this.key(key) + ': ') + this.inline(value);
+            this.#path.pop();
+            return text;
+        })
+            .join(', ');
+        this.leave();
+        return res;
+    }
+    key(key) {
+        return isIntegerKey(key) ? key : this.string(key);
+    }
+    scalar(value) {
+        if (value === null) {
+            return 'null';
+        }
+        else if (typeof value === 'boolean') {
+            return String(value);
+        }
+        else if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        else if (typeof value === 'number') {
+            return Number.isSafeInteger(value) && !Object.is(value, -0)
+                ? String(value) // cannot be told from an integer; beyond 2^53 a number is a float, integers are bigint
+                : formatFloat(value) ?? this.fail('INF and NAN cannot be encoded to NEON', false);
+        }
+        else if (typeof value === 'string') {
+            if (!value.isWellFormed()) {
+                this.fail('a string with a lone surrogate');
+            }
+            return this.string(value);
+        }
+        else if (value instanceof NeonDate) {
+            return value.toString();
+        }
+        else if (value instanceof Date) {
+            return formatDate(value);
+        }
+        this.fail(`${typeof value === 'object' ? 'an instance of ' + value.constructor?.name : typeof value} cannot be encoded`);
+    }
+    string(s) {
+        if (s.includes('\n')) {
+            return this.multiline(s);
+        }
+        else if (!needsQuotes(s)) {
+            return s;
+        }
+        else if (/[\x00-\x08\x0B-\x1F]/.test(s)) { // eslint-disable-line no-control-regex
+            return jsonString(s);
+        }
+        return '\'' + s.replaceAll('\'', '\'\'') + '\'';
+    }
+    multiline(s) {
+        let delimiter = '\'\'\'';
+        let content = s;
+        const firstLine = /^\n*([^\n]*)/.exec(s)[1];
+        if (this.doubleQuoted || /[\x00-\x08\x0B-\x1F]/.test(s) || /(?:^|\n)[\t ]*'''/.test(s) || /^[\t ]/.test(firstLine)) { // eslint-disable-line no-control-regex
+            delimiter = '"""';
+            content = jsonString(s).slice(1, -1)
+                .replace(/\\(.)/g, (seq, c) => ({ 'n': '\n', 't': '\t', '"': '"' })[c] ?? seq)
+                .replaceAll('"""', '""\\"')
+                .replace(/^(\n*)([\t ]+)/, (_, newlines, space) => newlines + space.replaceAll(' ', '\\u0020').replaceAll('\t', '\\t'));
+        }
+        return delimiter + '\n' + indent(content, this.indentation) + '\n' + delimiter;
+    }
+    /** Entries of an array, a Map or a plain object; null for anything else. */
+    entries(value) {
+        if (Array.isArray(value)) {
+            const res = [];
+            for (let i = 0; i < value.length; i++) {
+                if (!(i in value)) {
+                    this.#path.push(String(i));
+                    this.fail('a sparse array cannot be encoded');
+                }
+                res.push([String(i), value[i]]);
+            }
+            return res;
+        }
+        else if (value instanceof Map) {
+            const keys = (new Set);
+            return [...value].map(([key, v]) => {
+                if (typeof key !== 'string' && typeof key !== 'number') {
+                    this.fail('a key of a Map must be a string or a number');
+                }
+                else if (keys.has(String(key))) {
+                    this.fail(`the keys of a Map give the key '${String(key)}' twice`);
+                }
+                keys.add(String(key));
+                return [String(key), v];
+            });
+        }
+        else if (isPlainObject(value)) {
+            return Object.keys(value).map((key) => [key, value[key]]);
+        }
+        return null;
+    }
+    /** Goes into a container, an array being one level of nesting. */
+    enter(container, array = false) {
+        if (this.#stack.includes(container)) {
+            this.fail('a cycle cannot be encoded');
+        }
+        else if (array && this.#arrays.length >= MaxDepth) {
+            this.fail(`arrays nested deeper than ${MaxDepth} levels`);
+        }
+        this.#stack.push(container);
+        if (array) {
+            this.#arrays.push(container);
+        }
+    }
+    leave() {
+        if (this.#arrays.at(-1) === this.#stack.pop()) {
+            this.#arrays.pop();
+        }
+    }
+    fail(reason, withPath = true) {
+        const at = withPath && this.#path.length ? ` at ${this.#path.join('.')}` : '';
+        throw new NeonError(withPath ? `Cannot encode: ${reason}${at}` : reason);
+    }
+}
+/** Marks the keys that decoding would assign anyway. */
+function withHiddenKeys(entries) {
+    let counter = 0n;
+    let hiding = true;
+    return entries.map(([key, value]) => {
+        const integer = isIntegerKey(key);
+        const hidden = hiding && integer && BigInt(key) === counter;
+        if (integer && hiding) {
+            const k = BigInt(key);
+            hiding = k === counter;
+            counter = k + 1n > counter ? k + 1n : counter;
+        }
+        return [key, value, hidden];
+    });
+}
+/** Whether the string has to be quoted. */
+export function needsQuotes(s) {
+    const token = new Scanner(s).next();
+    return !token || token.kind !== 'Literal' || token.end !== s.length
+        || /[\x00-\x1F]/.test(s) // eslint-disable-line no-control-regex
+        || /^[+\-.]?\d/.test(s)
+        || /^(?:true|false|yes|no|on|off|null)$/i.test(s)
+        || evaluateLiteral(s) !== s;
+}
+function jsonString(s) {
+    return JSON.stringify(s).replaceAll('\u2028', '\\u2028').replaceAll('\u2029', '\\u2029');
+}
+/** Shortest round-trip digits, positional for exponents -4 to 16; null for INF and NAN. */
+export function formatFloat(f) {
+    if (!Number.isFinite(f)) {
+        return null;
+    }
+    else if (f === 0) {
+        return Object.is(f, -0) ? '-0.0' : '0.0';
+    }
+    const [mantissa, exponent] = Math.abs(f).toExponential().split('e');
+    const digits = mantissa.replace('.', '');
+    const e = Number(exponent);
+    const sign = f < 0 ? '-' : '';
+    if (e >= -4 && e < 17) {
+        if (e < 0) {
+            return sign + '0.' + '0'.repeat(-e - 1) + digits;
+        }
+        const whole = digits.slice(0, e + 1).padEnd(e + 1, '0');
+        const fraction = digits.slice(e + 1);
+        return sign + whole + '.' + (fraction || '0');
+    }
+    return sign + (mantissa.includes('.') ? mantissa : mantissa + '.0') + 'e' + (e < 0 ? '-' : '+') + Math.abs(e);
+}
+/** An instant, written in UTC. */
+function formatDate(date) {
+    if (Number.isNaN(date.getTime())) {
+        throw new NeonError('Cannot encode: an invalid Date');
+    }
+    try {
+        return NeonDate.fromDate(date).toString();
+    }
+    catch {
+        throw new NeonError('Cannot encode: a Date out of the years 0 to 9999');
+    }
+}
+/** Prefixes every non-empty line. */
+function indent(text, indentation) {
+    return text.split('\n').map((line) => line === '' ? line : indentation + line).join('\n'); // a regex would also split at CR and U+2028
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function isMapLike(value) {
+    return value instanceof Map || isPlainObject(value);
+}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+import type { Position } from './token.ts';
+/** Error of the scanner, the parser or the evaluation of values. */
+export declare class NeonError extends Error {
+    readonly position: Position | null;
+    name: string;
+    constructor(message: string, position?: Position | null);
+    toString(): string;
+}

package/dist/errors.js

@@ -0,0 +1,14 @@
+/** Error of the scanner, the parser or the evaluation of values. */
+export class NeonError extends Error {
+    position;
+    name = 'NeonError';
+    constructor(message, position = null) {
+        super(message);
+        this.position = position;
+    }
+    toString() {
+        return this.position
+            ? `${this.message} on line ${this.position.line} at column ${this.position.column}`
+            : this.message;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { Builder } from './builder.ts';
+export { dump } from './dumper.ts';
+export { CommentPolicy } from './editing.ts';
+export type { PathSegment } from './editing.ts';
+export { Layout } from './layout.ts';
+export type { EncodeOptions } from './encoder.ts';
+export { NeonError } from './errors.ts';
+export { decode, encode, Neon } from './neon.ts';
+export { tokenize } from './lexer.ts';
+export { ArrayItemNode, BlockArrayNode, DocumentNode, EntityChainNode, EntityNode, InlineArrayNode, LiteralNode, Node, StringNode, ValueNode, } from './nodes.ts';
+export { parse } from './parser.ts';
+export { locateAll, print, printText } from './printer.ts';
+export { Token, Trivia } from './token.ts';
+export { TraverseAction, Traverser } from './traverser.ts';
+export type { Visitor, VisitResult } from './traverser.ts';
+export type { Position, TokenKind, TriviaKind } from './token.ts';
+export { decodeUtf8 } from './utf8.ts';
+export { Chain, Entity, NeonDate } from './values.ts';
+export type { NeonValue } from './values.ts';

package/dist/index.js

@@ -0,0 +1,14 @@
+export { Builder } from "./builder.js";
+export { dump } from "./dumper.js";
+export { CommentPolicy } from "./editing.js";
+export { Layout } from "./layout.js";
+export { NeonError } from "./errors.js";
+export { decode, encode, Neon } from "./neon.js";
+export { tokenize } from "./lexer.js";
+export { ArrayItemNode, BlockArrayNode, DocumentNode, EntityChainNode, EntityNode, InlineArrayNode, LiteralNode, Node, StringNode, ValueNode, } from "./nodes.js";
+export { parse } from "./parser.js";
+export { locateAll, print, printText } from "./printer.js";
+export { Token, Trivia } from "./token.js";
+export { TraverseAction, Traverser } from "./traverser.js";
+export { decodeUtf8 } from "./utf8.js";
+export { Chain, Entity, NeonDate } from "./values.js";

package/dist/internal.d.ts

@@ -0,0 +1,11 @@
+/** Keys of the members that only the tree itself may call. They are not exported from the package. */
+export declare const setParent: unique symbol;
+export declare const setItems: unique symbol;
+export declare const setSlots: unique symbol;
+export declare const setLeading: unique symbol;
+export declare const setTrailing: unique symbol;
+export declare const forgetOrigin: unique symbol;
+/** Notes how to undo a write of the tree, while an atomic() operation runs. */
+export declare function record(undo: () => void): void;
+/** Runs an operation; if it throws, every write it made is undone, so a refused operation changes nothing. */
+export declare function atomic<T>(operation: () => T): T;

package/dist/internal.js

@@ -0,0 +1,32 @@
+/** Keys of the members that only the tree itself may call. They are not exported from the package. */
+export const setParent = Symbol('setParent');
+export const setItems = Symbol('setItems');
+export const setSlots = Symbol('setSlots');
+export const setLeading = Symbol('setLeading');
+export const setTrailing = Symbol('setTrailing');
+export const forgetOrigin = Symbol('forgetOrigin');
+let journal = null;
+/** Notes how to undo a write of the tree, while an atomic() operation runs. */
+export function record(undo) {
+    journal?.push(undo);
+}
+/** Runs an operation; if it throws, every write it made is undone, so a refused operation changes nothing. */
+export function atomic(operation) {
+    if (journal) {
+        return operation();
+    }
+    const list = journal = [];
+    try {
+        return operation();
+    }
+    catch (e) {
+        journal = null;
+        for (let i = list.length - 1; i >= 0; i--) {
+            list[i]();
+        }
+        throw e;
+    }
+    finally {
+        journal = null;
+    }
+}

package/dist/layout.d.ts

@@ -0,0 +1,14 @@
+import { ArrayItemNode, type Node } from './nodes.ts';
+import { type Token } from './token.ts';
+/** Layout of new text, derived from the neighbourhood of the place of an edit. */
+export declare class Layout {
+    /** The difference of indentation between a nested block and its parent. */
+    static unit(at: Node): string;
+    /**
+     * The indentation of the block the item is in. It is the indentation of the line of the item, except
+     * for the first item of a block opened on the line of a dash, which stands after the dash.
+     */
+    static indentation(item: ArrayItemNode): string;
+    /** The line ending of the nearest preceding token, else the first of the document, else LF. */
+    static lineEnding(at: Node | Token): string;
+}

package/dist/layout.js

@@ -0,0 +1,105 @@
+import { ArrayItemNode, BlockArrayNode, DocumentNode } from "./nodes.js";
+import { iterateNeighbours } from "./token.js";
+/** Layout of new text, derived from the neighbourhood of the place of an edit. */
+export class Layout {
+    /** The difference of indentation between a nested block and its parent. */
+    static unit(at) {
+        for (const candidate of candidates(at)) {
+            const unit = unitOf(candidate);
+            if (unit) {
+                return unit;
+            }
+        }
+        return '\t';
+    }
+    /**
+     * The indentation of the block the item is in. It is the indentation of the line of the item, except
+     * for the first item of a block opened on the line of a dash, which stands after the dash.
+     */
+    static indentation(item) {
+        const block = item.parent;
+        const owner = block?.parent;
+        if (block instanceof BlockArrayNode && owner instanceof ArrayItemNode && owner.bullet
+            && !owner.bullet.trailingTrivia.some((t) => t.kind === 'LineEnding')) {
+            const second = block.items[1];
+            if (second) {
+                return second.getIndentation();
+            }
+            // as the parser decides: a tab if the next line within the block starts with one
+            const outer = Layout.indentation(owner);
+            const next = block.getTokens().slice(1).find((token) => token.leadingTrivia.some((t) => t.kind === 'Whitespace')
+                && !!token.leadingTrivia.length);
+            const nextIndent = next?.leadingTrivia.at(-1)?.text ?? '';
+            return outer + (nextIndent.startsWith(outer + '\t') ? '\t' : '  ');
+        }
+        return item.getIndentation();
+    }
+    /** The line ending of the nearest preceding token, else the first of the document, else LF. */
+    static lineEnding(at) {
+        const root = rootOf(at);
+        if (!root) {
+            return '\n';
+        }
+        const token = at instanceof ArrayItemNode || 'getFirstToken' in at ? at.getFirstToken() : at;
+        const first = root.getFirstToken();
+        const find = (list) => {
+            for (const token of list) {
+                const trivia = [...token.trailingTrivia, ...token.leadingTrivia].find((t) => t.kind === 'LineEnding');
+                if (trivia) {
+                    return trivia.text;
+                }
+            }
+            return null;
+        };
+        return find(iterateNeighbours(token, true)) ?? find([first]) ?? find(iterateNeighbours(first, false)) ?? '\n';
+    }
+}
+/** The blocks to take the unit from: the siblings, the nearest first, then the ancestors, then the whole document. */
+function* candidates(at) {
+    const block = at instanceof BlockArrayNode ? at : at.findAncestor(BlockArrayNode);
+    if (block) {
+        const item = at instanceof ArrayItemNode ? at : at.findAncestor(ArrayItemNode);
+        const index = item ? Math.max(block.items.indexOf(item), 0) : 0;
+        for (let distance = 0; distance < block.items.length; distance++) {
+            for (const i of distance ? [index - distance, index + distance] : [index]) {
+                const value = block.items[i]?.value;
+                if (value instanceof BlockArrayNode) {
+                    yield value;
+                }
+            }
+        }
+    }
+    for (let node = block; node; node = node.parent) {
+        if (node instanceof BlockArrayNode) {
+            yield node;
+        }
+    }
+    const root = rootOf(at);
+    if (root) {
+        yield* root.find(BlockArrayNode);
+    }
+}
+/** Unit of a nested block, or null for a block opened on the line of a dash or not nested. */
+function unitOf(block) {
+    const owner = block.parent;
+    if (!(owner instanceof ArrayItemNode)) {
+        return null;
+    }
+    const head = owner.colon ?? owner.bullet;
+    if (!head?.trailingTrivia.some((t) => t.kind === 'LineEnding')) {
+        return null; // opened on the line of the dash
+    }
+    const outer = owner.getIndentation();
+    const inner = block.items[0].getIndentation();
+    return inner.length > outer.length && inner.startsWith(outer) ? inner.slice(outer.length) : null;
+}
+function rootOf(at) {
+    let node = at.parent;
+    if (at instanceof DocumentNode) {
+        return at;
+    }
+    while (node?.parent) {
+        node = node.parent;
+    }
+    return node instanceof DocumentNode ? node : null;
+}

package/dist/lexer.d.ts

@@ -0,0 +1,8 @@
+import { type Token } from './token.ts';
+/**
+ * Splits the input into tokens with their trivia attached. The last token is EndOfFile.
+ * Printing all tokens in order gives back the input.
+ */
+export declare function tokenize(input: string): Token[];
+/** Text quoted by 'Unexpected': cut to 40 code points, a line ending counting as one, shown as <new line>. */
+export declare function quote(text: string): string;

package/dist/lexer.js

@@ -0,0 +1,59 @@
+import { NeonError } from "./errors.js";
+import { Scanner } from "./scanner.js";
+import { Cursor } from "./position.js";
+import { Trivia, trustedToken } from "./token.js";
+/**
+ * Splits the input into tokens with their trivia attached. The last token is EndOfFile.
+ * Printing all tokens in order gives back the input.
+ */
+export function tokenize(input) {
+    checkWellFormed(input);
+    const scanner = new Scanner(input);
+    const cursor = new Cursor(input);
+    const tokens = [];
+    let pending = []; // trivia not yet attached
+    let last = null;
+    const flush = () => {
+        if (last) {
+            tokens.push(trustedToken(last.kind, last.text, last.leading, last.trailing, last.origin));
+        }
+    };
+    while (true) {
+        const item = scanner.next();
+        if (!item) {
+            if (scanner.errorAt >= 0) {
+                throw new NeonError(`Unexpected '${quote(input.slice(scanner.errorAt))}'`, cursor.at(scanner.errorAt));
+            }
+            break;
+        }
+        const text = input.slice(item.start, item.end);
+        if (item.kind === 'Trivia') {
+            const trivia = new Trivia(item.triviaKind, text);
+            // trailing trivia of the last token run up to and including the first line ending
+            if (last && !pending.length && !last.trailing.some((t) => t.kind === 'LineEnding')) {
+                last.trailing.push(trivia);
+            }
+            else {
+                pending.push(trivia);
+            }
+        }
+        else {
+            flush();
+            last = { kind: item.kind, text, leading: pending, trailing: [], origin: cursor.at(item.start) };
+            pending = [];
+        }
+    }
+    flush();
+    tokens.push(trustedToken('EndOfFile', '', pending, [], cursor.at(input.length)));
+    return tokens;
+}
+/** Text quoted by 'Unexpected': cut to 40 code points, a line ending counting as one, shown as <new line>. */
+export function quote(text) {
+    return Array.from(text.replaceAll('\r\n', '\n')).slice(0, 40).join('').replaceAll('\n', '<new line>');
+}
+function checkWellFormed(input) {
+    if (!input.isWellFormed()) {
+        const i = input.search(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/);
+        throw new NeonError('Invalid UTF-8 sequence.', new Cursor(input).at(i));
+    }
+}

package/dist/neon.d.ts

@@ -0,0 +1,19 @@
+import { type BlockFilter, type EncodeOptions } from './encoder.ts';
+import type { Node } from './nodes.ts';
+import { parse } from './parser.ts';
+import { type NeonValue } from './values.ts';
+/** Parses NEON and returns its value. */
+export declare function decode(input: string): NeonValue;
+/**
+ * Writes a value as NEON. In block mode, arrays are written one item per line; a function
+ * `blockMode(value, path)` is asked for every array and writes it as a block if true.
+ */
+export declare function encode(value: unknown, blockMode?: boolean | BlockFilter | EncodeOptions, indentation?: string): string;
+/** The facade, read as `Neon.decode(text)` like in PHP. */
+export declare const Neon: {
+    readonly decode: typeof decode;
+    readonly encode: typeof encode;
+    readonly parse: typeof parse;
+    readonly print: (node: Node) => string;
+    readonly Chain: "!!chain";
+};

package/dist/neon.js

@@ -0,0 +1,22 @@
+import { encode as encodeValue } from "./encoder.js";
+import { parse } from "./parser.js";
+import { Chain } from "./values.js";
+/** Parses NEON and returns its value. */
+export function decode(input) {
+    return parse(input).toValue();
+}
+/**
+ * Writes a value as NEON. In block mode, arrays are written one item per line; a function
+ * `blockMode(value, path)` is asked for every array and writes it as a block if true.
+ */
+export function encode(value, blockMode = false, indentation = '\t') {
+    return encodeValue(value, typeof blockMode === 'object' ? blockMode : { blockMode, indentation });
+}
+/** The facade, read as `Neon.decode(text)` like in PHP. */
+export const Neon = {
+    decode,
+    encode,
+    parse,
+    print: (node) => node.print(),
+    Chain,
+};