yaml 2.0.0-3 → 2.0.0-7

package/dist/errors.js

@@ -1,85 +1,62 @@
 'use strict';
 
-var Node = require('./cst/Node.js');
-var sourceUtils = require('./cst/source-utils.js');
-var Range = require('./cst/Range.js');
-
 class YAMLError extends Error {
-  constructor(name, source, message) {
-    if (!message || !(source instanceof Node.Node)) throw new Error(`Invalid arguments for new ${name}`);
-    super();
-    this.name = name;
-    this.message = message;
-    this.source = source;
-  }
-
-  makePretty() {
-    if (!this.source) return;
-    this.nodeType = this.source.type;
-    const cst = this.source.context && this.source.context.root;
-
-    if (typeof this.offset === 'number') {
-      this.range = new Range.Range(this.offset, this.offset + 1);
-      const start = cst && sourceUtils.getLinePos(this.offset, cst);
-
-      if (start) {
-        const end = {
-          line: start.line,
-          col: start.col + 1
-        };
-        this.linePos = {
-          start,
-          end
-        };
-      }
-
-      delete this.offset;
-    } else {
-      this.range = this.source.range;
-      this.linePos = this.source.rangeAsLinePos;
+    constructor(name, pos, code, message) {
+        super();
+        this.name = name;
+        this.code = code;
+        this.message = message;
+        this.pos = pos;
     }
-
-    if (this.linePos) {
-      const {
-        line,
-        col
-      } = this.linePos.start;
-      this.message += ` at line ${line}, column ${col}`;
-      const ctx = cst && sourceUtils.getPrettyContext(this.linePos, cst);
-      if (ctx) this.message += `:\n\n${ctx}\n`;
-    }
-
-    delete this.source;
-  }
-
-}
-class YAMLReferenceError extends YAMLError {
-  constructor(source, message) {
-    super('YAMLReferenceError', source, message);
-  }
-
-}
-class YAMLSemanticError extends YAMLError {
-  constructor(source, message) {
-    super('YAMLSemanticError', source, message);
-  }
-
 }
-class YAMLSyntaxError extends YAMLError {
-  constructor(source, message) {
-    super('YAMLSyntaxError', source, message);
-  }
-
+class YAMLParseError extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
+    }
 }
 class YAMLWarning extends YAMLError {
-  constructor(source, message) {
-    super('YAMLWarning', source, message);
-  }
-
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
+    }
 }
+const prettifyError = (src, lc) => (error) => {
+    if (error.pos[0] === -1)
+        return;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
+    error.message += ` at line ${line}, column ${col}`;
+    let ci = col - 1;
+    let lineStr = src
+        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])
+        .replace(/[\n\r]+$/, '');
+    // Trim to max 80 chars, keeping col position near the middle
+    if (ci >= 60 && lineStr.length > 80) {
+        const trimStart = Math.min(ci - 39, lineStr.length - 79);
+        lineStr = '…' + lineStr.substring(trimStart);
+        ci -= trimStart - 1;
+    }
+    if (lineStr.length > 80)
+        lineStr = lineStr.substring(0, 79) + '…';
+    // Include previous line in context if pointing at line start
+    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+        // Regexp won't match if start is trimmed
+        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+        if (prev.length > 80)
+            prev = prev.substring(0, 79) + '…\n';
+        lineStr = prev + lineStr;
+    }
+    if (/[^ ]/.test(lineStr)) {
+        let count = 1;
+        const end = error.linePos[1];
+        if (end && end.line === line && end.col > col) {
+            count = Math.min(end.col - col, 80 - ci);
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
+        error.message += `:\n\n${lineStr}\n${pointer}\n`;
+    }
+};
 
 exports.YAMLError = YAMLError;
-exports.YAMLReferenceError = YAMLReferenceError;
-exports.YAMLSemanticError = YAMLSemanticError;
-exports.YAMLSyntaxError = YAMLSyntaxError;
+exports.YAMLParseError = YAMLParseError;
 exports.YAMLWarning = YAMLWarning;
+exports.prettifyError = prettifyError;

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { Composer } from './compose/composer.js';
+export { Document } from './doc/Document.js';
+export { Schema } from './schema/Schema.js';
+export { YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
+export { Alias } from './nodes/Alias.js';
+export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, Node, ParsedNode } from './nodes/Node.js';
+export { Pair } from './nodes/Pair.js';
+export { Scalar } from './nodes/Scalar.js';
+export { YAMLMap } from './nodes/YAMLMap.js';
+export { YAMLSeq } from './nodes/YAMLSeq.js';
+export { CreateNodeOptions, defaultOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from './options.js';
+export * as CST from './parse/cst.js';
+export { Lexer } from './parse/lexer.js';
+export { LineCounter } from './parse/line-counter.js';
+export { Parser } from './parse/parser.js';
+export { EmptyStream, parse, parseAllDocuments, parseDocument, stringify } from './public-api.js';
+export type { TagId, Tags } from './schema/tags';
+export type { CollectionTag, ScalarTag } from './schema/types';
+export { visit, visitor, visitorFn } from './visit.js';

package/dist/index.js

@@ -1,82 +1,51 @@
 'use strict';
 
-var constants = require('./constants.js');
-var parse$1 = require('./cst/parse.js');
+var composer = require('./compose/composer.js');
 var Document = require('./doc/Document.js');
+var Schema = require('./schema/Schema.js');
 var errors = require('./errors.js');
-var log = require('./log.js');
+var Alias = require('./nodes/Alias.js');
+var Node = require('./nodes/Node.js');
+var Pair = require('./nodes/Pair.js');
+var Scalar = require('./nodes/Scalar.js');
+var YAMLMap = require('./nodes/YAMLMap.js');
+var YAMLSeq = require('./nodes/YAMLSeq.js');
 var options = require('./options.js');
+var cst = require('./parse/cst.js');
+var lexer = require('./parse/lexer.js');
+var lineCounter = require('./parse/line-counter.js');
+var parser = require('./parse/parser.js');
+var publicApi = require('./public-api.js');
 var visit = require('./visit.js');
 
-function parseAllDocuments(src, options) {
-  const stream = [];
-  let prev;
 
-  for (const cstDoc of parse$1.parse(src)) {
-    const doc = new Document.Document(undefined, null, options);
-    doc.parse(cstDoc, prev);
-    stream.push(doc);
-    prev = doc;
-  }
 
-  return stream;
-}
-function parseDocument(src, options) {
-  const cst = parse$1.parse(src);
-  const doc = new Document.Document(cst[0], null, options);
-
-  if (cst.length > 1 && constants.LogLevel.indexOf(doc.options.logLevel) >= constants.LogLevel.ERROR) {
-    const errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
-    doc.errors.unshift(new errors.YAMLSemanticError(cst[1], errMsg));
-  }
-
-  return doc;
-}
-function parse(src, reviver, options) {
-  if (options === undefined && reviver && typeof reviver === 'object') {
-    options = reviver;
-    reviver = undefined;
-  }
-
-  const doc = parseDocument(src, options);
-  doc.warnings.forEach(warning => log.warn(doc.options.logLevel, warning));
-
-  if (doc.errors.length > 0) {
-    if (constants.LogLevel.indexOf(doc.options.logLevel) >= constants.LogLevel.ERROR) throw doc.errors[0];else doc.errors = [];
-  }
-
-  return doc.toJS({
-    reviver
-  });
-}
-function stringify(value, replacer, options) {
-  if (typeof options === 'string') options = options.length;
-
-  if (typeof options === 'number') {
-    const indent = Math.round(options);
-    options = indent < 1 ? undefined : indent > 8 ? {
-      indent: 8
-    } : {
-      indent
-    };
-  }
-
-  if (value === undefined) {
-    const {
-      keepUndefined
-    } = options || replacer || {};
-    if (!keepUndefined) return undefined;
-  }
-
-  return new Document.Document(value, replacer, options).toString();
-}
-
-exports.parseCST = parse$1.parse;
+exports.Composer = composer.Composer;
 exports.Document = Document.Document;
+exports.Schema = Schema.Schema;
+exports.YAMLError = errors.YAMLError;
+exports.YAMLParseError = errors.YAMLParseError;
+exports.YAMLWarning = errors.YAMLWarning;
+exports.Alias = Alias.Alias;
+exports.isAlias = Node.isAlias;
+exports.isCollection = Node.isCollection;
+exports.isDocument = Node.isDocument;
+exports.isMap = Node.isMap;
+exports.isNode = Node.isNode;
+exports.isPair = Node.isPair;
+exports.isScalar = Node.isScalar;
+exports.isSeq = Node.isSeq;
+exports.Pair = Pair.Pair;
+exports.Scalar = Scalar.Scalar;
+exports.YAMLMap = YAMLMap.YAMLMap;
+exports.YAMLSeq = YAMLSeq.YAMLSeq;
 exports.defaultOptions = options.defaultOptions;
-exports.scalarOptions = options.scalarOptions;
+exports.CST = cst;
+exports.Lexer = lexer.Lexer;
+exports.LineCounter = lineCounter.LineCounter;
+exports.Parser = parser.Parser;
+exports.parse = publicApi.parse;
+exports.parseAllDocuments = publicApi.parseAllDocuments;
+exports.parseDocument = publicApi.parseDocument;
+exports.stringify = publicApi.stringify;
 exports.visit = visit.visit;
-exports.parse = parse;
-exports.parseAllDocuments = parseAllDocuments;
-exports.parseDocument = parseDocument;
-exports.stringify = stringify;

package/dist/log.d.ts

@@ -0,0 +1,3 @@
+export declare type LogLevelId = 'silent' | 'error' | 'warn' | 'debug';
+export declare function debug(logLevel: LogLevelId, ...messages: any[]): void;
+export declare function warn(logLevel: LogLevelId, warning: string | Error): void;

package/dist/log.js

@@ -1,12 +1,17 @@
 'use strict';
 
-var constants = require('./constants.js');
-
-/* global console, process */
+function debug(logLevel, ...messages) {
+    if (logLevel === 'debug')
+        console.log(...messages);
+}
 function warn(logLevel, warning) {
-  if (constants.LogLevel.indexOf(logLevel) >= constants.LogLevel.WARN) {
-    if (typeof process !== 'undefined' && process.emitWarning) process.emitWarning(warning);else console.warn(warning);
-  }
+    if (logLevel === 'debug' || logLevel === 'warn') {
+        if (typeof process !== 'undefined' && process.emitWarning)
+            process.emitWarning(warning);
+        else
+            console.warn(warning);
+    }
 }
 
+exports.debug = debug;
 exports.warn = warn;

package/dist/nodes/Alias.d.ts

@@ -0,0 +1,24 @@
+import type { Document } from '../doc/Document';
+import type { StringifyContext } from '../stringify/stringify.js';
+import { NodeBase, Range } from './Node.js';
+import type { Scalar } from './Scalar';
+import type { ToJSContext } from './toJS.js';
+import type { YAMLMap } from './YAMLMap';
+import type { YAMLSeq } from './YAMLSeq';
+export declare namespace Alias {
+    interface Parsed extends Alias {
+        range: Range;
+    }
+}
+export declare class Alias extends NodeBase {
+    source: string;
+    anchor?: never;
+    constructor(source: string);
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined;
+    toJSON(_arg?: unknown, ctx?: ToJSContext): unknown;
+    toString(ctx?: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
+}

package/dist/nodes/Alias.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var anchors = require('../doc/anchors.js');
+var visit = require('../visit.js');
+var Node = require('./Node.js');
+
+class Alias extends Node.NodeBase {
+    constructor(source) {
+        super(Node.ALIAS);
+        this.source = source;
+        Object.defineProperty(this, 'tag', {
+            set() {
+                throw new Error('Alias nodes cannot have tags');
+            }
+        });
+    }
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc) {
+        let found = undefined;
+        visit.visit(doc, {
+            Node: (_key, node) => {
+                if (node === this)
+                    return visit.visit.BREAK;
+                if (node.anchor === this.source)
+                    found = node;
+            }
+        });
+        return found;
+    }
+    toJSON(_arg, ctx) {
+        if (!ctx)
+            return { source: this.source };
+        const { anchors, doc, maxAliasCount } = ctx;
+        const source = this.resolve(doc);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        const data = anchors.get(source);
+        /* istanbul ignore if */
+        if (!data || data.res === undefined) {
+            const msg = 'This should not happen: Alias anchor was not resolved?';
+            throw new ReferenceError(msg);
+        }
+        if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+                data.aliasCount = getAliasCount(doc, source, anchors);
+            if (data.count * data.aliasCount > maxAliasCount) {
+                const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                throw new ReferenceError(msg);
+            }
+        }
+        return data.res;
+    }
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchors.anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
+    }
+}
+function getAliasCount(doc, node, anchors) {
+    if (Node.isAlias(node)) {
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
+        return anchor ? anchor.count * anchor.aliasCount : 0;
+    }
+    else if (Node.isCollection(node)) {
+        let count = 0;
+        for (const item of node.items) {
+            const c = getAliasCount(doc, item, anchors);
+            if (c > count)
+                count = c;
+        }
+        return count;
+    }
+    else if (Node.isPair(node)) {
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
+        return Math.max(kc, vc);
+    }
+    return 1;
+}
+
+exports.Alias = Alias;

package/dist/nodes/Collection.d.ts

@@ -0,0 +1,67 @@
+import type { Schema } from '../schema/Schema.js';
+import { NodeBase, NODE_TYPE } from './Node.js';
+export declare function collectionFromPath(schema: Schema, path: unknown[], value: unknown): import("./Node.js").Node;
+export declare const isEmptyPath: (path: Iterable<unknown> | null | undefined) => boolean;
+export declare abstract class Collection extends NodeBase {
+    static maxFlowStringSingleLineLength: number;
+    schema: Schema | undefined;
+    [NODE_TYPE]: symbol;
+    items: unknown[];
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
+    /**
+     * If true, stringify this and all child nodes using flow rather than
+     * block styles.
+     */
+    flow?: boolean;
+    constructor(type: symbol, schema?: Schema);
+    /** Adds a value to the collection. */
+    abstract add(value: unknown): void;
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    abstract delete(key: unknown): boolean;
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    abstract get(key: unknown, keepScalar?: boolean): unknown;
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    abstract has(key: unknown): boolean;
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    abstract set(key: unknown, value: unknown): void;
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path: Iterable<unknown>, value: unknown): void;
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn([key, ...rest]: Iterable<unknown>): boolean;
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn([key, ...rest]: Iterable<unknown>, keepScalar?: boolean): unknown;
+    hasAllNullValues(allowScalar?: boolean): boolean;
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn([key, ...rest]: Iterable<unknown>): boolean;
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn([key, ...rest]: Iterable<unknown>, value: unknown): void;
+}

package/dist/nodes/Collection.js

@@ -0,0 +1,137 @@
+'use strict';
+
+var createNode = require('../doc/createNode.js');
+var Node = require('./Node.js');
+
+function collectionFromPath(schema, path, value) {
+    let v = value;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
+        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+            const a = [];
+            a[k] = v;
+            v = a;
+        }
+        else {
+            const o = {};
+            Object.defineProperty(o, typeof k === 'symbol' ? k : String(k), {
+                value: v,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            v = o;
+        }
+    }
+    return createNode.createNode(v, undefined, {
+        onAnchor() {
+            throw new Error('Repeated objects are not supported here');
+        },
+        schema,
+        sourceObjects: new Map()
+    });
+}
+// null, undefined, or an empty non-string iterable (e.g. [])
+const isEmptyPath = (path) => path == null ||
+    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
+class Collection extends Node.NodeBase {
+    constructor(type, schema) {
+        super(type);
+        Object.defineProperty(this, 'schema', {
+            value: schema,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+    }
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path, value) {
+        if (isEmptyPath(path))
+            this.add(value);
+        else {
+            const [key, ...rest] = path;
+            const node = this.get(key, true);
+            if (Node.isCollection(node))
+                node.addIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn([key, ...rest]) {
+        if (rest.length === 0)
+            return this.delete(key);
+        const node = this.get(key, true);
+        if (Node.isCollection(node))
+            return node.deleteIn(rest);
+        else
+            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn([key, ...rest], keepScalar) {
+        const node = this.get(key, true);
+        if (rest.length === 0)
+            return !keepScalar && Node.isScalar(node) ? node.value : node;
+        else
+            return Node.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+    }
+    hasAllNullValues(allowScalar) {
+        return this.items.every(node => {
+            if (!Node.isPair(node))
+                return false;
+            const n = node.value;
+            return (n == null ||
+                (allowScalar &&
+                    Node.isScalar(n) &&
+                    n.value == null &&
+                    !n.commentBefore &&
+                    !n.comment &&
+                    !n.tag));
+        });
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn([key, ...rest]) {
+        if (rest.length === 0)
+            return this.has(key);
+        const node = this.get(key, true);
+        return Node.isCollection(node) ? node.hasIn(rest) : false;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn([key, ...rest], value) {
+        if (rest.length === 0) {
+            this.set(key, value);
+        }
+        else {
+            const node = this.get(key, true);
+            if (Node.isCollection(node))
+                node.setIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+}
+Collection.maxFlowStringSingleLineLength = 60;
+
+exports.Collection = Collection;
+exports.collectionFromPath = collectionFromPath;
+exports.isEmptyPath = isEmptyPath;

package/dist/nodes/Node.d.ts

@@ -0,0 +1,48 @@
+import type { Document } from '../doc/Document.js';
+import type { StringifyContext } from '../stringify/stringify.js';
+import type { Alias } from './Alias.js';
+import type { Pair } from './Pair.js';
+import type { Scalar } from './Scalar.js';
+import type { YAMLMap } from './YAMLMap.js';
+import type { YAMLSeq } from './YAMLSeq.js';
+export declare type Node = Alias | Scalar | YAMLMap | YAMLSeq;
+export declare type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
+export declare type Range = [number, number, number];
+export declare const ALIAS: unique symbol;
+export declare const DOC: unique symbol;
+export declare const MAP: unique symbol;
+export declare const PAIR: unique symbol;
+export declare const SCALAR: unique symbol;
+export declare const SEQ: unique symbol;
+export declare const NODE_TYPE: unique symbol;
+export declare const isAlias: (node: any) => node is Alias;
+export declare const isDocument: (node: any) => node is Document<unknown>;
+export declare const isMap: (node: any) => node is YAMLMap<unknown, unknown>;
+export declare const isPair: (node: any) => node is Pair<unknown, unknown>;
+export declare const isScalar: (node: any) => node is Scalar<unknown>;
+export declare const isSeq: (node: any) => node is YAMLSeq<unknown>;
+export declare function isCollection(node: any): node is YAMLMap | YAMLSeq;
+export declare function isNode(node: any): node is Node;
+export declare const hasAnchor: (node: unknown) => node is YAMLMap<unknown, unknown> | YAMLSeq<unknown> | Scalar<unknown>;
+export declare abstract class NodeBase {
+    readonly [NODE_TYPE]: symbol;
+    /** A comment on or immediately after this */
+    comment?: string | null;
+    /** A comment before this */
+    commentBefore?: string | null;
+    /**
+     * The `[start, value-end, node-end]` character offsets for the part of the
+     * source parsed into this node (undefined if not parsed). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
+     */
+    range?: Range | null;
+    /** A blank line before this node and its commentBefore */
+    spaceBefore?: boolean;
+    /** A fully qualified tag, if required */
+    tag?: string;
+    /** A plain JS representation of this node */
+    abstract toJSON(): any;
+    abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+    constructor(type: symbol);
+}