@nette/neon 0.0.0-stage → 1.0.1

package/dist/traverser.js

@@ -0,0 +1,96 @@
+import { ArrayItemNode, ValueNode } from "./nodes.js";
+/** What a visitor returns to steer the walk; symbols, so that no other value means an action by accident. */
+export const TraverseAction = Object.freeze({
+    SkipChildren: Symbol('SkipChildren'),
+    Stop: Symbol('Stop'),
+    Remove: Symbol('Remove'),
+});
+/**
+ * Walks the tree depth-first, calling enter() before the children of a node and leave() after them.
+ * The children of a node are taken when it is entered, so nodes inserted around the visited one later
+ * are not visited, and a child taken out of the node meanwhile is skipped; a node the visitor takes out
+ * of its place itself is neither walked into nor left. A replacement is visited from its children on.
+ * Stop ends the walk at once: no node is entered or left after it. The walk is not one atomic edit:
+ * the edits before a failure stay.
+ */
+export class Traverser {
+    enter;
+    leave;
+    #stopped = false;
+    /** The nodes being walked, from the first one, each with the parent it was entered under. */
+    #path = [];
+    constructor(enter, leave) {
+        this.enter = enter;
+        this.leave = leave;
+    }
+    static traverse(node, enter, leave) {
+        return new Traverser(enter, leave).visit(node);
+    }
+    /** Returns the node that stands in the place of the visited one afterwards, null if it was removed or taken out. */
+    visit(node) {
+        const level = this.#path.length;
+        this.#path.push([node, node.parent]);
+        try {
+            let result = this.enter?.(node);
+            const current = this.apply(node, result);
+            if (!current) {
+                return null;
+            }
+            this.#path[level] = [current, this.#path[level][1]];
+            if (!this.isInPlace(level)) {
+                return null;
+            }
+            else if (this.#stopped) {
+                return current;
+            }
+            if (result !== TraverseAction.SkipChildren) {
+                for (const child of current.getChildren()) {
+                    if ('getChildren' in child && child.parent === current) { // nodes only, tokens are not visited
+                        this.visit(child);
+                        if (this.#stopped) {
+                            return current;
+                        }
+                        else if (!this.isInPlace(level)) {
+                            return null;
+                        }
+                    }
+                }
+            }
+            result = this.leave?.(current);
+            return this.apply(current, result);
+        }
+        finally {
+            this.#path.pop();
+        }
+    }
+    /** Whether the node at the level and the nodes above it still stand where they were entered. */
+    isInPlace(level) {
+        for (let i = level; i >= 0; i--) {
+            const [node, parent] = this.#path[i];
+            if (node.parent !== parent) {
+                return false;
+            }
+        }
+        return true;
+    }
+    apply(node, result) {
+        if (result === TraverseAction.Stop) {
+            this.#stopped = true;
+        }
+        else if (result === TraverseAction.Remove) {
+            if (!(node instanceof ArrayItemNode)) {
+                throw new Error('Only an item can be removed; replace any other node.');
+            }
+            node.remove();
+            return null;
+        }
+        else if (result instanceof ValueNode) {
+            if (!(node instanceof ValueNode)) {
+                throw new Error('Only a value node can be replaced.');
+            }
+            node.replaceWith(result);
+            return result;
+        }
+        return node;
+    }
+}

package/dist/utf8.d.ts

@@ -0,0 +1,2 @@
+/** Decodes UTF-8 bytes; invalid ones fail with the position of the first invalid byte. */
+export declare function decodeUtf8(bytes: Uint8Array): string;

package/dist/utf8.js

@@ -0,0 +1,44 @@
+import { NeonError } from "./errors.js";
+import { Cursor } from "./position.js";
+const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+/** Decodes UTF-8 bytes; invalid ones fail with the position of the first invalid byte. */
+export function decodeUtf8(bytes) {
+    try {
+        return decoder.decode(bytes);
+    }
+    catch {
+        let valid = 0;
+        for (let n; (n = sequenceLength(bytes, valid)); valid += n) {
+            ;
+        }
+        const prefix = decoder.decode(bytes.subarray(0, valid));
+        throw new NeonError('Invalid UTF-8 sequence.', new Cursor(prefix).at(prefix.length));
+    }
+}
+/** Ranges of the bytes of the well-formed sequences, by the first byte (Unicode table 3-7). */
+const Sequences = [
+    [0x00, 0x7F, []],
+    [0xC2, 0xDF, [[0x80, 0xBF]]],
+    [0xE0, 0xE0, [[0xA0, 0xBF], [0x80, 0xBF]]],
+    [0xE1, 0xEC, [[0x80, 0xBF], [0x80, 0xBF]]],
+    [0xED, 0xED, [[0x80, 0x9F], [0x80, 0xBF]]],
+    [0xEE, 0xEF, [[0x80, 0xBF], [0x80, 0xBF]]],
+    [0xF0, 0xF0, [[0x90, 0xBF], [0x80, 0xBF], [0x80, 0xBF]]],
+    [0xF1, 0xF3, [[0x80, 0xBF], [0x80, 0xBF], [0x80, 0xBF]]],
+    [0xF4, 0xF4, [[0x80, 0x8F], [0x80, 0xBF], [0x80, 0xBF]]],
+];
+/** Length of the well-formed sequence at the offset, or 0. */
+function sequenceLength(bytes, i) {
+    const first = bytes[i];
+    const sequence = first === undefined ? undefined : Sequences.find(([lo, hi]) => first >= lo && first <= hi);
+    if (!sequence) {
+        return 0;
+    }
+    const rest = sequence[2];
+    return rest.every(([lo, hi], k) => {
+        const b = bytes[i + k + 1];
+        return b !== undefined && b >= lo && b <= hi;
+    })
+        ? rest.length + 1
+        : 0;
+}

package/dist/values.d.ts

@@ -0,0 +1,75 @@
+/** Value of the neutral model mapped to JavaScript. */
+export type NeonValue = null | boolean | number | bigint | string | NeonDate | Entity | NeonValue[] | {
+    [key: string]: NeonValue;
+};
+/** The value of an entity, `value(attributes)`; a chain is an entity whose value is Chain. */
+export declare class Entity {
+    value: NeonValue;
+    attributes: NeonValue[] | {
+        [key: string]: NeonValue;
+    };
+    constructor(value: NeonValue, attributes?: NeonValue[] | {
+        [key: string]: NeonValue;
+    });
+}
+/** The value of an entity that represents a chain; its attributes are the links. */
+export declare const Chain = "!!chain";
+/** A date as written: components and an offset, or none for a local date. */
+export declare class NeonDate {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number | null;
+    readonly minute: number | null;
+    readonly second: number | null;
+    /** Digits of the fraction of a second as written, without the point. */
+    readonly fraction: string | null;
+    /** `+HH:MM` or `-HH:MM`, or null for a local date. */
+    readonly offset: string | null;
+    constructor(year: number, month: number, day: number, hour?: number | null, minute?: number | null, second?: number | null, 
+    /** Digits of the fraction of a second as written, without the point. */
+    fraction?: string | null, 
+    /** `+HH:MM` or `-HH:MM`, or null for a local date. */
+    offset?: string | null);
+    /** An instant as a date in UTC. */
+    static fromDate(date: Date): NeonDate;
+    /** Parses the text of a date literal; null if the text is not one, its components making no valid date included. */
+    static parse(text: string): NeonDate | null;
+    /** Converts the date to an instant; a local date needs the time zone offset in minutes or 'UTC'. */
+    toDate(zone?: 'UTC' | number): Date;
+    /** The date as the encoder writes it, without the fraction of a second. */
+    toString(): string;
+    /** Equality of components, including the presence of an offset and the written fraction. */
+    equals(other: NeonDate): boolean;
+}
+/**
+ * Equality of values between a value of the host and a decoded one. A number and a bigint of the
+ * same integer are equal; a plain object does not keep the order of integer-like keys, so with one the
+ * order does not count.
+ */
+export declare function valuesEqual(a: unknown, b: unknown): boolean;
+/** Entries of an array of the host with canonical keys, whether they make a list, and whether their order is kept. */
+export declare function entriesOf(value: unknown): {
+    entries: [string, unknown][];
+    list: boolean;
+    ordered: boolean;
+} | null;
+declare const Int64Max: bigint;
+/** A number literal as a number or a bigint, or undefined if the text is not a number. */
+export declare function evaluateNumber(text: string): number | bigint | undefined;
+/** Value of a literal that is not a key. */
+export declare function evaluateLiteral(text: string): NeonValue;
+/** Canonical key of a key literal or a string key. */
+export declare function canonicalKey(value: string | number | bigint, isFloat?: boolean): string;
+/** Canonical key of a literal written as a key. */
+export declare function literalKey(text: string): string;
+/** Whether a canonical key is an integer key: what PHP converts to an integer array key. */
+export declare function isIntegerKey(key: string): boolean;
+export { Int64Max };
+/** How deep arrays nest (a block, an inline array and attributes each count as one level). */
+export declare const MaxDepth = 500;
+/** Value of a string token. Throws EscapeError for an invalid escape sequence. */
+export declare function evaluateString(text: string): string;
+/** An invalid escape sequence; the parser reports it at the position of the string. */
+export declare class EscapeError extends Error {
+}

package/dist/values.js

@@ -0,0 +1,313 @@
+/** The value of an entity, `value(attributes)`; a chain is an entity whose value is Chain. */
+export class Entity {
+    value;
+    attributes;
+    constructor(value, attributes = []) {
+        this.value = value;
+        this.attributes = attributes;
+    }
+}
+/** The value of an entity that represents a chain; its attributes are the links. */
+export const Chain = '!!chain';
+/** A date as written: components and an offset, or none for a local date. */
+export class NeonDate {
+    year;
+    month;
+    day;
+    hour;
+    minute;
+    second;
+    fraction;
+    offset;
+    constructor(year, month, day, hour = null, minute = null, second = null, 
+    /** Digits of the fraction of a second as written, without the point. */
+    fraction = null, 
+    /** `+HH:MM` or `-HH:MM`, or null for a local date. */
+    offset = null) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hour = hour;
+        this.minute = minute;
+        this.second = second;
+        this.fraction = fraction;
+        this.offset = offset;
+        const time = [hour, minute, second];
+        if (!inRange(year, 0, 9999) || !inRange(month, 1, 12) || !inRange(day, 1, daysInMonth(year, month))
+            || (hour === null
+                ? time.some((n) => n !== null) || fraction !== null || offset !== null
+                : !inRange(hour, 0, 23) || !inRange(minute, 0, 59) || !inRange(second, 0, 59))
+            || (fraction !== null && !/^\d+$/.test(fraction))
+            || (offset !== null && !/^[-+](?:(?:0\d|1[0-3]):[0-5]\d|14:00)$/.test(offset))) {
+            throw new RangeError('A component of the date is out of range.');
+        }
+        Object.freeze(this);
+    }
+    /** An instant as a date in UTC. */
+    static fromDate(date) {
+        const ms = date.getUTCMilliseconds();
+        return new NeonDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), ms ? String(ms).padStart(3, '0').replace(/0+$/, '') : null, '+00:00');
+    }
+    /** Parses the text of a date literal; null if the text is not one, its components making no valid date included. */
+    static parse(text) {
+        const m = DatePattern.exec(text);
+        if (!m) {
+            return null;
+        }
+        const [, year, month, day, hour, minute, second, fraction, zone] = m;
+        const num = (s) => s === undefined ? null : Number(s);
+        let offset = null;
+        if (zone === 'Z') {
+            offset = '+00:00';
+        }
+        else if (zone) {
+            const z = /^([-+])(\d\d?)(?::?(\d\d))?$/.exec(zone);
+            offset = z[1] + z[2].padStart(2, '0') + ':' + (z[3] ?? '00');
+        }
+        try {
+            return new NeonDate(Number(year), Number(month), Number(day), num(hour), num(minute), num(second), fraction || null, offset);
+        }
+        catch (e) {
+            if (e instanceof RangeError) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    /** Converts the date to an instant; a local date needs the time zone offset in minutes or 'UTC'. */
+    toDate(zone) {
+        let offset;
+        if (this.offset) {
+            const sign = this.offset[0] === '-' ? -1 : 1;
+            offset = sign * (Number(this.offset.slice(1, 3)) * 60 + Number(this.offset.slice(4, 6)));
+        }
+        else if (zone === undefined) {
+            throw new TypeError('A local date needs a time zone to become an instant.');
+        }
+        else {
+            offset = zone === 'UTC' ? 0 : zone;
+        }
+        const ms = Number((this.fraction ?? '').padEnd(3, '0').slice(0, 3));
+        const res = new Date(0);
+        res.setUTCFullYear(this.year, this.month - 1, this.day); // Date.UTC() would map years 0-99 to 1900-1999
+        res.setUTCHours(this.hour ?? 0, (this.minute ?? 0) - offset, this.second ?? 0, ms);
+        return res;
+    }
+    /** The date as the encoder writes it, without the fraction of a second. */
+    toString() {
+        const pad = (n, width = 2) => String(n).padStart(width, '0');
+        let res = `${pad(this.year, 4)}-${pad(this.month)}-${pad(this.day)}`;
+        if (this.hour !== null) {
+            res += ` ${pad(this.hour)}:${pad(this.minute)}:${pad(this.second)}`;
+        }
+        if (this.offset) {
+            res += ' ' + this.offset.replace(':', '');
+        }
+        return res;
+    }
+    /** Equality of components, including the presence of an offset and the written fraction. */
+    equals(other) {
+        return this.year === other.year && this.month === other.month && this.day === other.day
+            && this.hour === other.hour && this.minute === other.minute && this.second === other.second
+            && this.fraction === other.fraction && this.offset === other.offset;
+    }
+}
+function daysInMonth(year, month) {
+    return month === 2
+        ? (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28)
+        : [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function inRange(n, min, max) {
+    return Number.isInteger(n) && n >= min && n <= max;
+}
+/**
+ * Equality of values between a value of the host and a decoded one. A number and a bigint of the
+ * same integer are equal; a plain object does not keep the order of integer-like keys, so with one the
+ * order does not count.
+ */
+export function valuesEqual(a, b) {
+    if (typeof b === 'number' || typeof b === 'bigint') {
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a === b || (Number.isNaN(a) && Number.isNaN(b));
+        }
+        const [n, big] = typeof a === 'number' ? [a, b] : [b, a];
+        return typeof n === 'number' ? typeof big === 'bigint' && Number.isInteger(n) && BigInt(n) === big : n === big;
+    }
+    else if (b instanceof NeonDate) {
+        let date = a;
+        try {
+            date = a instanceof Date ? NeonDate.fromDate(a) : a;
+        }
+        catch {
+            // a Date out of the range of the model equals no date
+        }
+        return date instanceof NeonDate && b.equals(date);
+    }
+    else if (b instanceof Entity) {
+        return a instanceof Entity && valuesEqual(a.value, b.value) && valuesEqual(a.attributes, b.attributes);
+    }
+    else if (typeof b === 'object' && b !== null) {
+        const x = entriesOf(a);
+        const y = entriesOf(b);
+        if (!x || !y || x.list !== y.list || x.entries.length !== y.entries.length) {
+            return false;
+        }
+        else if (x.ordered && y.ordered) {
+            return x.entries.every(([key, v], i) => y.entries[i][0] === key && valuesEqual(v, y.entries[i][1]));
+        }
+        const map = new Map(y.entries);
+        return x.entries.every(([key, v]) => map.has(key) && valuesEqual(v, map.get(key)));
+    }
+    return a === b;
+}
+/** Entries of an array of the host with canonical keys, whether they make a list, and whether their order is kept. */
+export function entriesOf(value) {
+    let entries;
+    if (Array.isArray(value)) {
+        return { entries: value.map((v, i) => [String(i), v]), list: true, ordered: true };
+    }
+    else if (value instanceof Map) {
+        entries = [...value].map(([key, v]) => [String(key), v]);
+    }
+    else if (typeof value === 'object' && value !== null && [Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        entries = Object.entries(value);
+    }
+    else {
+        return null;
+    }
+    return { entries, list: entries.length > 0 && entries.every(([key], i) => key === String(i)), ordered: value instanceof Map };
+}
+const DatePattern = /^(\d{4})-(\d\d?)-(\d\d?)(?:(?:[Tt]| +)(\d\d?):(\d\d):(\d\d)(?:\.(\d*))? *(Z|[-+]\d\d?(?::?\d\d)?)?)?$/;
+const SimpleTypes = {
+    true: true, True: true, TRUE: true, yes: true, Yes: true, YES: true,
+    false: false, False: false, FALSE: false, no: false, No: false, NO: false,
+    null: null, Null: null, NULL: null,
+};
+const DecimalPattern = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const IntegerPattern = /^[+-]?\d+$/;
+const BasePattern = /^0(?:x[0-9a-fA-F]+|o[0-7]+|b[01]+)$/;
+const MaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+const Int64Max = 2n ** 63n - 1n;
+const Int64Min = -(2n ** 63n);
+/** A number literal as a number or a bigint, or undefined if the text is not a number. */
+export function evaluateNumber(text) {
+    if (IntegerPattern.test(text) || BasePattern.test(text)) {
+        return integer(BigInt(text.replace(/^\+/, '')));
+    }
+    else if (DecimalPattern.test(text)) {
+        return Number(text);
+    }
+    return undefined;
+}
+/** Value of a literal that is not a key. */
+export function evaluateLiteral(text) {
+    if (Object.hasOwn(SimpleTypes, text)) {
+        return SimpleTypes[text];
+    }
+    return evaluateNumber(text) ?? NeonDate.parse(text) ?? text;
+}
+/** Canonical key of a key literal or a string key. */
+export function canonicalKey(value, isFloat = false) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else if (typeof value === 'bigint' || (!isFloat && Number.isInteger(value))) {
+        return String(BigInt(value));
+    }
+    return floatKey(value);
+}
+/** Canonical key of a literal written as a key. */
+export function literalKey(text) {
+    const num = evaluateNumber(text);
+    if (num === undefined) {
+        return text;
+    }
+    return canonicalKey(num, typeof num === 'number' && !IntegerPattern.test(text) && !BasePattern.test(text));
+}
+/** A float as PHP converts it to a string: 14 significant digits. */
+function floatKey(f) {
+    if (Number.isNaN(f)) {
+        return 'NAN';
+    }
+    else if (!Number.isFinite(f)) {
+        return f > 0 ? 'INF' : '-INF';
+    }
+    else if (f === 0) {
+        return Object.is(f, -0) ? '-0' : '0';
+    }
+    const [mantissa, exponent] = f.toExponential(13).split('e');
+    const e = Number(exponent);
+    if (e >= -4 && e < 14) { // toPrecision() is positional in this range
+        const digits = f.toPrecision(14);
+        return digits.includes('.') ? digits.replace(/\.?0+$/, '') : digits;
+    }
+    let m = mantissa.replace(/0+$/, '').replace(/\.$/, '');
+    if (!m.includes('.')) {
+        m += '.0';
+    }
+    return `${m}E${e < 0 ? '-' : '+'}${Math.abs(e)}`;
+}
+/** Whether a canonical key is an integer key: what PHP converts to an integer array key. */
+export function isIntegerKey(key) {
+    if (!/^(?:0|-?[1-9]\d*)$/.test(key)) {
+        return false;
+    }
+    const n = BigInt(key);
+    return n >= Int64Min && n <= Int64Max;
+}
+export { Int64Max };
+/** How deep arrays nest (a block, an inline array and attributes each count as one level). */
+export const MaxDepth = 500;
+function integer(n) {
+    return n <= MaxSafe && n >= -MaxSafe ? Number(n) : n;
+}
+const Escapes = {
+    't': '\t', 'n': '\n', 'r': '\r', 'f': '\f', 'b': '\b', '"': '"', '\\': '\\', '/': '/', '_': String.fromCharCode(0xA0),
+};
+/** Value of a string token. Throws EscapeError for an invalid escape sequence. */
+export function evaluateString(text) {
+    text = text.replaceAll('\r', '');
+    let res;
+    const multiline = /^('''|""")\n/.test(text);
+    if (multiline) {
+        const indent = /^...\n+([\t ]*)/.exec(text)[1];
+        res = text.slice(3, -3);
+        if (indent !== '') {
+            res = res.replaceAll('\n' + indent, '\n');
+        }
+        res = res.replace(/^\n/, '').replace(/\n[\t ]*$/, '');
+    }
+    else {
+        res = text.slice(1, -1);
+        if (text[0] === '\'') {
+            res = res.replaceAll('\'\'', '\'');
+        }
+    }
+    if (text[0] === '\'') {
+        return res;
+    }
+    // the pattern of nette/neon 3.x, case-insensitive, so \U0041 and \uD801\UDC01 are one sequence each
+    return res.replace(/\\(?:ud[89ab][0-9a-f]{2}\\ud[c-f][0-9a-f]{2}|u[0-9a-f]{4}|[^\n])/gi, (seq) => {
+        const c = seq[1];
+        if (Object.hasOwn(Escapes, c)) {
+            return Escapes[c];
+        }
+        else if (c !== 'u' || seq.length < 6) {
+            throw new EscapeError(`Invalid escaping sequence ${seq}`);
+        }
+        else if (seq.length === 12) {
+            if (seq[7] !== 'u') {
+                throw new EscapeError(`Invalid UTF-8 sequence ${seq}`);
+            }
+            return String.fromCharCode(parseInt(seq.slice(2, 6), 16), parseInt(seq.slice(8), 16));
+        }
+        const code = parseInt(seq.slice(2), 16);
+        if (code >= 0xD800 && code <= 0xDFFF) {
+            throw new EscapeError(`Invalid UTF-8 sequence ${seq}`);
+        }
+        return String.fromCharCode(code);
+    });
+}
+/** An invalid escape sequence; the parser reports it at the position of the string. */
+export class EscapeError extends Error {
+}

package/license.md

@@ -0,0 +1,21 @@
+MIT License
+===========
+
+Copyright (c) 2026 David Grudl (https://davidgrudl.com)
+
+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/package.json

@@ -1,6 +1,60 @@
-{
-  "name": "@nette/neon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+	"name": "@nette/neon",
+	"version": "1.0.1",
+	"description": "NEON parser, encoder and lossless editor: change a value in a config file and keep its comments and formatting.",
+	"keywords": [
+		"neon",
+		"nette",
+		"parser",
+		"config",
+		"format-preserving",
+		"round-trip",
+		"yaml-alternative",
+		"cst"
+	],
+	"type": "module",
+	"license": "MIT",
+	"author": "David Grudl",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nette/neon-js.git"
+	},
+	"homepage": "https://neon.nette.org",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"bin": {
+		"neon-lint": "bin/neon-lint.js"
+	},
+	"files": [
+		"dist",
+		"bin"
+	],
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"prepare": "npm run build",
+		"spec": "node tests/fetch-spec.mjs",
+		"test": "tsc --noEmit && tsc --noEmit -p tsconfig.core.json && vitest run",
+		"smoke": "npm run build && node tests/package-smoke.mjs",
+		"lint": "eslint --cache",
+		"lint:fix": "eslint --cache --fix",
+		"verify-examples": "tsx examples/verify.ts"
+	},
+	"devDependencies": {
+		"@nette/eslint-plugin": "^0.3.1",
+		"@types/node": "^22.20.5",
+		"eslint": "^10.12.0",
+		"globals": "^17.13.0",
+		"tsx": "^4.23.15",
+		"typescript": "~6.0.3",
+		"typescript-eslint": "^8.71.0",
+		"vitest": "^5.0.3"
+	}
+}