astn 0.110.5 → 0.110.8

package/LICENSE

@@ -0,0 +1,17 @@
+Apache License  
+Version 2.0, January 2004  
+http://www.apache.org/licenses/
+
+Copyright (c) 2025 Corno
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,414 @@
+# ASTN (Abstract Syntax Tree Notation)
+
+A TypeScript library for parsing and formatting ASTN documents (Abstract Syntax Tree Notation) - a human-editable data format designed for structured content.
+
+**ASTN is a superset of JSON** - any valid JSON document is also valid ASTN, but ASTN provides a number additional features for enhanced readability and functionality.
+
+## Features of the ASTN specification
+
+- 📋 **Multiple string types** - Support for quoted, backticked, apostrophed, and undelimited strings
+- 💬 **Comments** - Line and block comment support
+- 🏗️ **Rich data structures** - dictionaries, lists, groups, tagged values, include, set, not set
+- 📄 **Document headers** - Optional header metadata for documents
+- 🔗 **File inclusion** - Import other ASTN files with `@` syntax
+- ✨ **Flexible punctuation** - Commas are optional, trailing commas are allowed
+
+## Features of this tool
+
+- 🚀 **Fast parsing** - Efficient lexer and parser implementation
+- 📝 **Format validation** - Comprehensive error reporting with location information
+- 🎨 **Code formatting** - Built-in formatter for consistent code style
+
+## Installation
+
+```bash
+npm install astn
+```
+
+## Quick Start
+
+### Parsing ASTN
+
+```typescript
+import { Parser } from 'astn';
+
+const source = `
+! header "example"
+{
+    \`name\`: "John Doe"
+    \`age\`: | 'number' "30"
+    \`hobbies\`: [
+        "reading"
+        "coding"
+    ]
+}
+`;
+
+const result = Parser.parse(source, { 'tab size': 4 });
+
+if (result[0] === 'success') {
+    console.log('Parsed successfully:', result[1]);
+} else {
+    console.error('Parse error:', result[1]);
+}
+```
+
+### Formatting ASTN
+
+```typescript
+import * as format from 'astn/format';
+import * as types from 'astn';
+
+// Format a parsed document
+const edits = format.Document(document, {
+    'remove commas': false,
+    'indentation string': '    ',
+    'current indentation': ''
+});
+```
+
+### Error Handling
+
+```typescript
+import * as create_error_message from 'astn/create_error_message';
+
+const result = Parser.parse(invalidSource, { 'tab size': 4 });
+
+if (result[0] === 'failure') {
+    const errorMessage = create_error_message.Parse_Error(result[1], {
+        'position info': ['one based', null]
+    });
+    console.error('Parse Error:', errorMessage);
+}
+```
+
+## ASTN Syntax Overview
+
+ASTN supports various data types and structures:
+
+### JSON Compatibility
+
+Since ASTN is a superset of JSON, any valid JSON works as-is:
+
+```json
+{
+    "name": "John Doe",
+    "age": 30,
+    "hobbies": ["reading", "coding"],
+    "active": true,
+    "metadata": null
+}
+```
+
+But ASTN extends JSON with additional features for better readability and functionality.
+
+### JSON vs ASTN Comparison
+
+Here's the same data structure in JSON vs ASTN, showing ASTN's enhanced features:
+
+<table>
+<tr>
+<th>JSON</th>
+<th>ASTN</th>
+</tr>
+<tr>
+<td>
+
+```json
+{
+  "config": {
+    "name": "MyApp",
+    "version": "1.2.3",
+    "enabled": true,
+    "created": "2025-07-21T10:30:00Z",
+    "tags": ["web", "typescript"],
+    "databases": {
+      "local": {
+        "host": "localhost",
+        "port": 5432,
+        "ssl": null
+      },
+      "remote": {
+        "host": "localhost",
+        "port": 1234,
+        "ssl": null
+      },
+    }
+  }
+}
+```
+
+</td>
+<td>
+
+```astn
+! "Application Configuration"
+(
+    'config': {
+        'name': "MyApp"
+        'version': "1.2.3"
+        'enabled': true
+        'created': 2025-07-21  // undelimited date
+        'tags': ["web", "typescript"]
+        'databases': (
+             `local`: {
+                'host': "localhost"
+                'port': | 'number' "5432"     // tagged value
+                'ssl': ~                       // not set
+            }, 
+             `remote": <"localhost" 'number' 1234 ~>
+        )
+    }
+)
+```
+
+</td>
+</tr>
+</table>
+
+**ASTN advantages shown above:**
+- 📄 **Headers** - `! header "..."` for document metadata
+- 💬 **Comments** - `//` and `/* */` supported throughout
+- 🏷️ **Tagged values** - `| 'number' "5432"` for type information
+- ✨ **Flexible literals** - `2025-07-21` without quotes
+- 🚫 **Explicit "not set"** - `~` instead of `null`
+-  **Instance keys** - `` `key` `` for data identifiers
+- ✨ **Optional commas** - cleaner syntax without mandatory commas
+
+### Schema vs Instance Data Distinction
+
+One of ASTN's key improvements over JSON is the clear distinction between **schema keys** (fixed structure) and **instance keys** (dynamic data):
+
+**JSON Problem:** In JSON, it's difficult to distinguish between:
+```json
+{
+  "config": {           // Is this a schema key or instance data?
+    "host": "localhost" // Are these fixed fields or dynamic entries?
+  }
+}
+```
+
+**ASTN Solution:** Uses different structures for different purposes:
+
+```astn
+// Verbose Group - for schema/structure ( () and apostrophe keys)
+('config': (
+    'host': "localhost"     // Fixed schema fields
+    'port': 5432
+))
+
+// Dictionary - for instance/dynamic data ( {} and backtick keys)  
+{
+    `user_123`: "John"      // Dynamic user IDs
+    `user_456`: "Jane"      // Runtime-determined keys
+}
+```
+
+This makes the data's intent much clearer to both humans and tools!
+
+### Lists vs Concise Groups Distinction
+
+ASTN also distinguishes between **lists** (ordered instance data) and **groups** (ordered schema data):
+
+**JSON Problem:** Arrays in JSON are ambiguous about their purpose:
+```json
+{
+  "coordinates": [10, 20, 30],    // Is this a list or structured data?
+  "users": ["John", "Jane"]       // Dynamic list or fixed schema fields?
+}
+```
+
+**ASTN Solution:** Four different structures for different purposes:
+
+```astn
+// 1. List - for dynamic/instance data (square brackets)
+{
+    `users`: [                  // Dynamic list of users
+        "John"
+        "Jane" 
+        "Bob"                   // Can add/remove items
+    ]
+}
+
+// 2. Dictionary - for key-value instance data (curly braces + backticks)
+{
+    `user_data`: {
+        `user_123`: "John"      // Dynamic user IDs as keys
+        `user_456`: "Jane"      // Runtime-determined keys
+        `user_789`: "Bob"
+    }
+}
+
+// 3. Concise Group - for schema/structure (angle brackets)  
+{
+    `coordinates`: <10 20 30>   // Fixed x, y, z coordinates
+    `rgb_color`: <255 128 0>    // Fixed red, green, blue values
+}
+
+// 4. Verbose Group - explicit schema names (parentheses)
+{
+    `coordinates`: (
+        'x': 10
+        'y': 20 
+        'z': 30
+    )
+}
+```
+
+**Example: Same data in concise vs verbose groups:**
+```astn
+// Concise - implicit positional names
+`person`: <"John" 30 "Engineer">
+
+// Verbose - explicit schema names (equivalent to above)
+`person`: (
+    'name': "John"
+    'age': 30
+    'job': "Engineer"  
+)
+```
+schema-aware tooling can create support to toggle between these 2 representations
+
+**Concise vs Verbose Groups:** These are interchangeable - concise groups are just verbose groups with implicit position-based schema names (first, second, third, etc.).
+
+### Document Structure
+```astn
+// Optional header
+! header "Document metadata or title"
+
+// Main document content
+{
+    "content": "value"
+}
+```
+
+### Basic Values
+```astn
+"quoted string"        // Can contain newlines and escape sequences
+'apostrophed string'   // Used for schema/meta names (keys, state names)
+`backticked string`    // Used for identifiers
+undelimited_string     // Flexible literals (dates, numbers, booleans, etc.)
+```
+
+**String Type Usage:**
+- **Quoted strings** (`"..."`) - General purpose strings that support newlines and escape sequences like `\n`, `\t`, `\"`, etc.
+- **Apostrophed strings** (`'...'`) - Specifically for schema and metadata names such as verbose group keys and tagged value state names
+- **Backticked strings** (`` `...` ``) - Used for identifiers and instance data such as dictionary keys
+- **Undelimited strings** - More flexible than JSON primitives; can represent:
+  - Booleans: `true`, `false`
+  - Numbers: `42`, `3.14`, `-123`
+  - Dates: `2025-07-21`, `2025-07-21T10:30:00Z`
+  - Custom literals: `null`, `undefined`, or domain-specific values
+
+### Collections
+```astn
+// Dictionary (commas optional, trailing commas allowed)
+{
+    `key`: "value"              // backtick for instance data key
+    `number`: | 'number' "42"   // backtick for key, apostrophe for state name
+    `description`: "Multi-line
+    strings are supported
+    in quoted strings"
+    `date`: 2025-07-21          // undelimited date
+    `enabled`: true             // undelimited boolean
+}
+
+// List with flexible comma usage
+[
+    "item1"
+    'schema_name'               // apostrophe for schema identifier
+    `instance_id`               // backtick for instance identifier
+    2025-07-21                  // undelimited date
+    42                          // undelimited number
+]
+
+// Concise Group
+<"item1" 'meta_name' `instance_id`>
+
+// Verbose Group (apostrophes for schema keys)
+('schema_key': "value1" 'another_key': "value2")
+```
+
+### Special Values
+```astn
+// Tagged values (apostrophe for state names)
+| 'number' "42"
+| 'date' 2025-07-21
+| 'boolean' true
+| 'custom_type' "some value"
+
+// Optional values
+* "optional value"
+* 2025-12-31              // undelimited date as optional
+
+// Not set
+~
+
+// File inclusion
+@ "path/to/config.astn"
+@ "../shared/constants.astn"
+```
+
+### Comments
+```astn
+// Line comment
+/* Block comment */
+{
+    "key": "value" // Trailing comment
+}
+```
+
+## VS Code Extension
+
+For the best development experience with ASTN files, install the **ASTN** VS Code extension:
+
+- **Extension ID**: `astn`
+- **Features**: Syntax highlighting, error detection, and formatting support
+- **Installation**: Search for "astn" in the VS Code Extensions marketplace
+
+The extension provides:
+- 🎨 Syntax highlighting for `.astn` files
+- 🔍 Real-time error detection and validation
+- 📝 IntelliSense and autocompletion
+- 🔧 Integrated formatting support
+
+## CLI Usage
+
+Validate ASTN files:
+
+```bash
+npx astn-validate < input.astn
+```
+
+## API Reference
+
+### Types
+
+- `Document` - Root document structure
+- `Value` - Any ASTN value
+- `StringX` - String with type information
+- `Parse_Error` - Detailed error information
+- `Location` - Position information in source
+
+### Functions
+
+- `Parser.parse(source, options)` - Parse ASTN source
+- `format.Document(doc, options)` - Format a document
+- `create_error_message.Parse_Error(error, options)` - Create human-readable error messages
+
+## Documentation
+
+- [Railroad Diagrams](./documentation/railroad_diagram/index.md)
+- [EBNF Grammar](./extra/astn.ebnf)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+Apache 2.0 License - see LICENSE file for details.
+
+## Version
+
+Current version: 0.110.5

package/dist/bin/validate_astn.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/validate_astn.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _er = __importStar(require("exupery-core-resources"));
+const _ea = __importStar(require("exupery-core-alg"));
+const parse = __importStar(require("../lib/transformations/parse"));
+const create_error_message = __importStar(require("../lib/transformations/create_error_message"));
+_er.temp_resources.process["get instream data"](($) => {
+    _ea.cc(parse.Parse_Result($, {
+        'tab size': 4,
+    }), ($) => {
+        switch ($[0]) {
+            case 'failure': return _ea.ss($, ($) => {
+                _er.temp_resources.console.error(`Parse Error: ${create_error_message.Parse_Error($, { 'position info': ['one based', null] })}`);
+                // process.exit(1)
+            });
+            case 'success': return _ea.ss($, ($) => {
+                _er.temp_resources.console.log(`document is valid ASTN`);
+                // process.exit(0)
+            });
+            default: return _ea.au($[0]);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGVfYXN0bi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iaW4vdmFsaWRhdGVfYXN0bi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVBLDREQUE2QztBQUM3QyxzREFBdUM7QUFFdkMsb0VBQXFEO0FBQ3JELGtHQUFtRjtBQUduRixHQUFHLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7SUFDbEQsR0FBRyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUNyQixDQUFDLEVBQ0Q7UUFDSSxVQUFVLEVBQUUsQ0FBQztLQUNoQixDQUNKLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtRQUNMLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDWCxLQUFLLFNBQVMsQ0FBQyxDQUFDLE9BQU8sR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtnQkFDbkMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLGdCQUFnQixvQkFBb0IsQ0FBQyxXQUFXLENBQUMsQ0FBQyxFQUFFLEVBQUUsZUFBZSxFQUFFLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUE7Z0JBQ2pJLGtCQUFrQjtZQUN0QixDQUFDLENBQUMsQ0FBQTtZQUNGLEtBQUssU0FBUyxDQUFDLENBQUMsT0FBTyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFO2dCQUNuQyxHQUFHLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsd0JBQXdCLENBQUMsQ0FBQTtnQkFDeEQsa0JBQWtCO1lBQ3RCLENBQUMsQ0FBQyxDQUFBO1lBQ0YsT0FBTyxDQUFDLENBQUMsT0FBTyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ2hDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFBIn0=

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export * from "./lib/types";
-export * from "./lib/parse";
-export * as format from "./lib/format";
-export * as create_error_message from "./lib/create_error_message";
+export * as d_ast from "./lib/types/ast";
+export * as d_ide from "./lib/types/ide";
+export * as d_parse_result from "./lib/types/parse_result";
+export * as d_tokenize_result from "./lib/types/tokenize_result";
+export * as t_parse from "./lib/transformations/parse";
+export * as t_format from "./lib/transformations/format";
+export * as t_create_error_message from "./lib/transformations/create_error_message";

package/dist/index.js

@@ -15,9 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -26,9 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.create_error_message = exports.format = void 0;
-__exportStar(require("./lib/types"), exports);
-__exportStar(require("./lib/parse"), exports);
-exports.format = __importStar(require("./lib/format"));
-exports.create_error_message = __importStar(require("./lib/create_error_message"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw4Q0FBMkI7QUFDM0IsOENBQTJCO0FBQzNCLHVEQUFzQztBQUN0QyxtRkFBa0UifQ==
+exports.t_create_error_message = exports.t_format = exports.t_parse = exports.d_tokenize_result = exports.d_parse_result = exports.d_ide = exports.d_ast = void 0;
+exports.d_ast = __importStar(require("./lib/types/ast"));
+exports.d_ide = __importStar(require("./lib/types/ide"));
+exports.d_parse_result = __importStar(require("./lib/types/parse_result"));
+exports.d_tokenize_result = __importStar(require("./lib/types/tokenize_result"));
+exports.t_parse = __importStar(require("./lib/transformations/parse"));
+exports.t_format = __importStar(require("./lib/transformations/format"));
+exports.t_create_error_message = __importStar(require("./lib/transformations/create_error_message"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5REFBd0M7QUFDeEMseURBQXdDO0FBQ3hDLDJFQUEwRDtBQUMxRCxpRkFBZ0U7QUFFaEUsdUVBQXNEO0FBQ3RELHlFQUF3RDtBQUN4RCxxR0FBb0YifQ==

package/dist/lib/create_error_message.d.ts

@@ -1,5 +1,5 @@
-import * as parse from "./parse";
-export declare const Parse_Error_Type: ($: parse.Parse_Error_Type) => string;
-export declare const Parse_Error: ($: parse.Parse_Error, $p: {
+import * as parse_result from "./types/parse_result";
+export declare const Parse_Error_Type: ($: parse_result.Parse_Error_Type) => string;
+export declare const Parse_Error: ($: parse_result.Parse_Error, $p: {
     "position info": ["zero based", null] | ["one based", null];
 }) => string;

package/dist/lib/create_error_message.js

@@ -72,4 +72,4 @@ const Parse_Error = ($, $p) => {
     return `failed to parse ASTN, ${(0, exports.Parse_Error_Type)($.type)} @ ${$.range.start.relative.line + extra}:${$.range.start.relative.column + extra}`;
 };
 exports.Parse_Error = Parse_Error;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/format.d.ts

@@ -1,62 +1,42 @@
-import * as _et from 'exupery-core-types';
-import * as types from "./types";
-export type Range = types.Range;
-export type Text_Edit = [
-    'insert',
-    {
-        'location': types.Relative_Location;
-        'text': string;
-    }
-] | [
-    'replace',
-    {
-        'range': Range;
-        'text': string;
-    }
-] | [
-    'delete',
-    {
-        'range': Range;
-    }
-];
-export type Text_Edits = _et.Array<Text_Edit>;
-export declare const Whitespace: ($: types.Whitespace, $p: {
+import * as ast from "./types/ast";
+import * as ide from "./types/ide";
+export declare const Whitespace: ($: ast.Whitespace, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Trivia: ($: types.Trivia, $p: {
+}) => ide.Text_Edits;
+export declare const Trivia: ($: ast.Trivia, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Structural_Token: ($: types.Structural_Token, $p: {
+}) => ide.Text_Edits;
+export declare const Structural_Token: ($: ast.Structural_Token, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const String: ($: types.StringX, $p: {
+}) => ide.Text_Edits;
+export declare const String: ($: ast.StringX, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Key_Value_Pairs: ($: types.Key_Value_Pairs, $p: {
+}) => ide.Text_Edits;
+export declare const Key_Value_Pairs: ($: ast.Key_Value_Pairs, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Elements: ($: types.Elements, $p: {
+}) => ide.Text_Edits;
+export declare const Elements: ($: ast.Elements, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Value: ($: types.Value, $p: {
+}) => ide.Text_Edits;
+export declare const Value: ($: ast.Value, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
-export declare const Document: ($: types.Document, $p: {
+}) => ide.Text_Edits;
+export declare const Document: ($: ast.Document, $p: {
     "remove commas": boolean;
     "indentation string": string;
     "current indentation": string;
-}) => Text_Edits;
+}) => ide.Text_Edits;