yaml 2.0.0-10 → 2.0.0-5

package/dist/nodes/addPairToJSMap.js

@@ -9,7 +9,6 @@ var toJS = require('./toJS.js');
 const MERGE_KEY = '<<';
 function addPairToJSMap(ctx, map, { key, value }) {
     if (ctx && ctx.doc.schema.merge && isMergeKey(key)) {
-        value = Node.isAlias(value) ? value.resolve(ctx.doc) : value;
         if (Node.isSeq(value))
             for (const it of value.items)
                 mergeToJSMap(ctx, map, it);
@@ -55,9 +54,9 @@ const isMergeKey = (key) => key === MERGE_KEY ||
 // Keys in mapping nodes earlier in the sequence override keys specified in
 // later mapping nodes. -- http://yaml.org/type/merge.html
 function mergeToJSMap(ctx, map, value) {
-    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : value;
+    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : null;
     if (!Node.isMap(source))
-        throw new Error('Merge sources must be maps or map aliases');
+        throw new Error('Merge sources must be map aliases');
     const srcMap = source.toJSON(null, ctx, Map);
     for (const [key, value] of srcMap) {
         if (map instanceof Map) {

package/dist/options.d.ts

@@ -1,11 +1,10 @@
 import type { Reviver } from './doc/applyReviver.js';
 import type { Directives } from './doc/directives.js';
 import type { LogLevelId } from './log.js';
-import type { ParsedNode } from './nodes/Node.js';
 import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { LineCounter } from './parse/line-counter.js';
-import type { Schema } from './schema/Schema.js';
+import type { SchemaName } from './schema/Schema.js';
 import type { Tags } from './schema/tags.js';
 import type { CollectionTag, ScalarTag } from './schema/types.js';
 export declare type ParseOptions = {
@@ -17,13 +16,6 @@ export declare type ParseOptions = {
      * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt
      */
     intAsBigInt?: boolean;
-    /**
-     * Include a `srcToken` value on each parsed `Node`, containing the CST token
-     * that was composed into this node.
-     *
-     * Default: `false`
-     */
-    keepSourceTokens?: boolean;
     /**
      * If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)`
      * to provide the `{ line, col }` positions within the input.
@@ -42,19 +34,6 @@ export declare type ParseOptions = {
      * Default: `true`
      */
     strict?: boolean;
-    /**
-     * YAML requires map keys to be unique. By default, this is checked by
-     * comparing scalar values with `===`; deep equality is not checked for
-     * aliases or collections. If merge keys are enabled by the schema,
-     * multiple `<<` keys are allowed.
-     *
-     * Set `false` to disable, or provide your own comparator function to
-     * customise. The comparator will be passed two `ParsedNode` values, and
-     * is expected to return a `boolean` indicating their equality.
-     *
-     * Default: `true`
-     */
-    uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean);
 };
 export declare type DocumentOptions = {
     /**
@@ -76,14 +55,6 @@ export declare type DocumentOptions = {
     version?: '1.1' | '1.2';
 };
 export declare type SchemaOptions = {
-    /**
-     * When parsing, warn about compatibility issues with the given schema.
-     * When stringifying, use scalar styles that are parsed correctly
-     * by the `compat` schema as well as the actual schema.
-     *
-     * Default: `null`
-     */
-    compat?: string | Tags | null;
     /**
      * Array of additional tags to include in the schema, or a function that may
      * modify the schema's base tag array.
@@ -107,39 +78,18 @@ export declare type SchemaOptions = {
     /**
      * The base schema to use.
      *
-     * The core library has built-in support for the following:
-     * - `'failsafe'`: A minimal schema that parses all scalars as strings
-     * - `'core'`: The YAML 1.2 core schema
-     * - `'json'`: The YAML 1.2 JSON schema, with minimal rules for JSON compatibility
-     * - `'yaml-1.1'`: The YAML 1.1 schema
-     *
-     * If using another (custom) schema, the `customTags` array needs to
-     * fully define the schema's tags.
-     *
-     * Default: `'core'` for YAML 1.2, `'yaml-1.1'` for earlier versions
+     * Default: `"core"` for YAML 1.2, `"yaml-1.1"` for earlier versions
      */
-    schema?: string | Schema;
+    schema?: SchemaName;
     /**
      * When adding to or stringifying a map, sort the entries.
      * If `true`, sort by comparing key values with `<`.
-     * Does not affect item order when parsing.
      *
      * Default: `false`
      */
     sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
-    /**
-     * Override default values for `toString()` options.
-     */
-    toStringDefaults?: ToStringOptions;
 };
 export declare type CreateNodeOptions = {
-    /**
-     * During node construction, use anchors and aliases to keep strictly equal
-     * non-null objects as equivalent in YAML.
-     *
-     * Default: `true`
-     */
-    aliasDuplicateObjects?: boolean;
     /**
      * Default prefix for anchors.
      *
@@ -189,30 +139,6 @@ export declare type ToJSOptions = {
     reviver?: Reviver;
 };
 export declare type ToStringOptions = {
-    /**
-     * Use block quote styles for scalar values where applicable.
-     * Set to `false` to disable block quotes completely.
-     *
-     * Default: `true`
-     */
-    blockQuote?: boolean | 'folded' | 'literal';
-    /**
-     * Enforce `'block'` or `'flow'` style on maps and sequences.
-     * Empty collections will always be stringified as `{}` or `[]`.
-     *
-     * Default: `'any'`, allowing each node to set its style separately
-     * with its `flow: boolean` (default `false`) property.
-     */
-    collectionStyle?: 'any' | 'block' | 'flow';
-    /**
-     * Comment stringifier.
-     * Output should be valid for the current schema.
-     *
-     * By default, empty comment lines are left empty,
-     * lines consisting of a single space are replaced by `#`,
-     * and all other lines are prefixed with a `#`.
-     */
-    commentString?: (comment: string) => string;
     /**
      * The default type of string literal used to stringify implicit key values.
      * Output may use other types if required to fully represent the value.
@@ -306,12 +232,11 @@ export declare type ToStringOptions = {
      */
     simpleKeys?: boolean;
     /**
-     * Use 'single quote' rather than "double quote" where applicable.
-     * Set to `false` to disable single quotes completely.
+     * Prefer 'single quote' rather than "double quote" where applicable.
      *
-     * Default: `null`
+     * Default: `false`
      */
-    singleQuote?: boolean | null;
+    singleQuote?: boolean;
     /**
      * String representation for `true`.
      * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.

package/dist/options.js

@@ -9,11 +9,9 @@
  */
 const defaultOptions = {
     intAsBigInt: false,
-    keepSourceTokens: false,
     logLevel: 'warn',
     prettyErrors: true,
     strict: true,
-    uniqueKeys: true,
     version: '1.2'
 };
 

package/dist/parse/cst-scalar.d.ts

@@ -6,12 +6,6 @@ import type { BlockScalar, FlowScalar, SourceToken, Token } from './cst.js';
  * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
  * Otherwise, return `null`.
  */
-export declare function resolveAsScalar(token: FlowScalar | BlockScalar, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
-    value: string;
-    type: Scalar.Type | null;
-    comment: string;
-    range: Range;
-};
 export declare function resolveAsScalar(token: Token | null | undefined, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
     value: string;
     type: Scalar.Type | null;

package/dist/parse/cst-scalar.js

@@ -5,6 +5,10 @@ var resolveFlowScalar = require('../compose/resolve-flow-scalar.js');
 var errors = require('../errors.js');
 var stringifyString = require('../stringify/stringifyString.js');
 
+/**
+ * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
+ * Otherwise, return `null`.
+ */
 function resolveAsScalar(token, strict = true, onError) {
     if (token) {
         const _onError = (pos, code, message) => {
@@ -46,7 +50,7 @@ function createScalarToken(value, context) {
         implicitKey,
         indent: indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { blockQuote: true, lineWidth: -1 }
+        options: { lineWidth: -1 }
     });
     const end = (_a = context.end) !== null && _a !== void 0 ? _a : [
         { type: 'newline', offset: -1, indent, source: '\n' }
@@ -115,7 +119,7 @@ function setScalarValue(token, value, context = {}) {
         implicitKey: implicitKey || indent === null,
         indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { blockQuote: true, lineWidth: -1 }
+        options: { lineWidth: -1 }
     });
     switch (source[0]) {
         case '|':

package/dist/parse/lexer.d.ts

@@ -47,8 +47,6 @@ export declare class Lexer {
     private indentNext;
     /** Indentation level of the current line. */
     private indentValue;
-    /** Position of the next \n character. */
-    private lineEndPos;
     /** Stores the state of the lexer if reaching the end of incpomplete input */
     private next;
     /** A pointer to `buffer`; the current position of the lexer. */
@@ -80,7 +78,7 @@ export declare class Lexer {
     private pushCount;
     private pushToIndex;
     private pushIndicators;
-    private pushTag;
+    private pushVerbatimTag;
     private pushNewline;
     private pushSpaces;
     private pushUntil;

package/dist/parse/lexer.js

@@ -81,11 +81,9 @@ function isEmpty(ch) {
             return false;
     }
 }
-const hexDigits = '0123456789ABCDEFabcdef'.split('');
-const tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split('');
-const invalidFlowScalarChars = ',[]{}'.split('');
-const invalidAnchorChars = ' ,[]{}\n\r\t'.split('');
-const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);
+const invalidFlowScalarChars = [',', '[', ']', '{', '}'];
+const invalidIdentifierChars = [' ', ',', '[', ']', '{', '}', '\n', '\r', '\t'];
+const isNotIdentifierChar = (ch) => !ch || invalidIdentifierChars.includes(ch);
 /**
  * Splits an input string into lexical tokens, i.e. smaller strings that are
  * easily identifiable by `tokens.tokenType()`.
@@ -136,8 +134,6 @@ class Lexer {
         this.indentNext = 0;
         /** Indentation level of the current line. */
         this.indentValue = 0;
-        /** Position of the next \n character. */
-        this.lineEndPos = null;
         /** Stores the state of the lexer if reaching the end of incpomplete input */
         this.next = null;
         /** A pointer to `buffer`; the current position of the lexer. */
@@ -150,10 +146,8 @@ class Lexer {
      * @returns A generator of lexical tokens
      */
     *lex(source, incomplete = false) {
-        if (source) {
+        if (source)
             this.buffer = this.buffer ? this.buffer + source : source;
-            this.lineEndPos = null;
-        }
         this.atEnd = !incomplete;
         let next = this.next || 'stream';
         while (next && (incomplete || this.hasChars(1)))
@@ -196,11 +190,7 @@ class Lexer {
         return offset;
     }
     getLine() {
-        let end = this.lineEndPos;
-        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
-            end = this.buffer.indexOf('\n', this.pos);
-            this.lineEndPos = end;
-        }
+        let end = this.buffer.indexOf('\n', this.pos);
         if (end === -1)
             return this.atEnd ? this.buffer.substring(this.pos) : null;
         if (this.buffer[end - 1] === '\r')
@@ -213,7 +203,6 @@ class Lexer {
     setNext(state) {
         this.buffer = this.buffer.substring(this.pos);
         this.pos = 0;
-        this.lineEndPos = null;
         this.next = state;
         return null;
     }
@@ -338,7 +327,7 @@ class Lexer {
                 yield* this.pushCount(1);
                 return 'doc';
             case '*':
-                yield* this.pushUntil(isNotAnchorChar);
+                yield* this.pushUntil(isNotIdentifierChar);
                 return 'doc';
             case '"':
             case "'":
@@ -366,7 +355,7 @@ class Lexer {
         const line = this.getLine();
         if (line === null)
             return this.setNext('flow');
-        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
+        if ((indent !== -1 && indent < this.indentNext) ||
             (indent === 0 &&
                 (line.startsWith('---') || line.startsWith('...')) &&
                 isEmpty(line[3]))) {
@@ -384,11 +373,8 @@ class Lexer {
             }
         }
         let n = 0;
-        while (line[n] === ',') {
-            n += yield* this.pushCount(1);
-            n += yield* this.pushSpaces(true);
-            this.flowKey = false;
-        }
+        while (line[n] === ',')
+            n += (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
         n += yield* this.pushIndicators();
         switch (line[n]) {
             case undefined:
@@ -409,7 +395,7 @@ class Lexer {
                 this.flowLevel -= 1;
                 return this.flowLevel ? 'flow' : 'doc';
             case '*':
-                yield* this.pushUntil(isNotAnchorChar);
+                yield* this.pushUntil(isNotIdentifierChar);
                 return 'flow';
             case '"':
             case "'":
@@ -418,7 +404,6 @@ class Lexer {
             case ':': {
                 const next = this.charAt(1);
                 if (this.flowKey || isEmpty(next) || next === ',') {
-                    this.flowKey = false;
                     yield* this.pushCount(1);
                     yield* this.pushSpaces(true);
                     return 'flow';
@@ -448,19 +433,17 @@ class Lexer {
                 end = this.buffer.indexOf('"', end + 1);
             }
         }
-        // Only looking for newlines within the quotes
-        const qb = this.buffer.substring(0, end);
-        let nl = qb.indexOf('\n', this.pos);
-        if (nl !== -1) {
-            while (nl !== -1) {
+        let nl = this.buffer.indexOf('\n', this.pos);
+        if (nl !== -1 && nl < end) {
+            while (nl !== -1 && nl < end) {
                 const cs = this.continueScalar(nl + 1);
                 if (cs === -1)
                     break;
-                nl = qb.indexOf('\n', cs);
+                nl = this.buffer.indexOf('\n', cs);
             }
-            if (nl !== -1) {
+            if (nl !== -1 && nl < end) {
                 // this is an error caused by an unexpected unindent
-                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
+                end = nl - 1;
             }
         }
         if (end === -1) {
@@ -560,18 +543,17 @@ class Lexer {
                 end = i;
             }
             else if (isEmpty(ch)) {
-                let next = this.buffer[i + 1];
+                const next = this.buffer[i + 1];
+                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
+                    break;
                 if (ch === '\r') {
                     if (next === '\n') {
                         i += 1;
                         ch = '\n';
-                        next = this.buffer[i + 1];
                     }
                     else
                         end = i;
                 }
-                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
-                    break;
                 if (ch === '\n') {
                     const cs = this.continueScalar(i + 1);
                     if (cs === -1)
@@ -613,11 +595,13 @@ class Lexer {
     *pushIndicators() {
         switch (this.charAt(0)) {
             case '!':
-                return ((yield* this.pushTag()) +
-                    (yield* this.pushSpaces(true)) +
-                    (yield* this.pushIndicators()));
+                if (this.charAt(1) === '<')
+                    return ((yield* this.pushVerbatimTag()) +
+                        (yield* this.pushSpaces(true)) +
+                        (yield* this.pushIndicators()));
+            // fallthrough
             case '&':
-                return ((yield* this.pushUntil(isNotAnchorChar)) +
+                return ((yield* this.pushUntil(isNotIdentifierChar)) +
                     (yield* this.pushSpaces(true)) +
                     (yield* this.pushIndicators()));
             case ':':
@@ -626,8 +610,6 @@ class Lexer {
                 if (isEmpty(this.charAt(1))) {
                     if (this.flowLevel === 0)
                         this.indentNext = this.indentValue + 1;
-                    else if (this.flowKey)
-                        this.flowKey = false;
                     return ((yield* this.pushCount(1)) +
                         (yield* this.pushSpaces(true)) +
                         (yield* this.pushIndicators()));
@@ -635,30 +617,12 @@ class Lexer {
         }
         return 0;
     }
-    *pushTag() {
-        if (this.charAt(1) === '<') {
-            let i = this.pos + 2;
-            let ch = this.buffer[i];
-            while (!isEmpty(ch) && ch !== '>')
-                ch = this.buffer[++i];
-            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
-        }
-        else {
-            let i = this.pos + 1;
-            let ch = this.buffer[i];
-            while (ch) {
-                if (tagChars.includes(ch))
-                    ch = this.buffer[++i];
-                else if (ch === '%' &&
-                    hexDigits.includes(this.buffer[i + 1]) &&
-                    hexDigits.includes(this.buffer[i + 2])) {
-                    ch = this.buffer[(i += 3)];
-                }
-                else
-                    break;
-            }
-            return yield* this.pushToIndex(i, false);
-        }
+    *pushVerbatimTag() {
+        let i = this.pos + 2;
+        let ch = this.buffer[i];
+        while (!isEmpty(ch) && ch !== '>')
+            ch = this.buffer[++i];
+        return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
     }
     *pushNewline() {
         const ch = this.buffer[this.pos];

package/dist/parse/parser.d.ts

@@ -78,7 +78,6 @@ export declare class Parser {
     private flowCollection;
     private flowScalar;
     private startBlockValue;
-    private atIndentedComment;
     private documentEnd;
     private lineEnd;
 }

package/dist/parse/parser.js

@@ -22,6 +22,38 @@ function includesNonEmpty(list) {
     }
     return false;
 }
+function atFirstEmptyLineAfterComments(start) {
+    let hasComment = false;
+    for (let i = 0; i < start.length; ++i) {
+        switch (start[i].type) {
+            case 'space':
+                break;
+            case 'comment':
+                hasComment = true;
+                break;
+            case 'newline':
+                if (!hasComment)
+                    return false;
+                break;
+            default:
+                return false;
+        }
+    }
+    if (hasComment) {
+        for (let i = start.length - 1; i >= 0; --i) {
+            switch (start[i].type) {
+                /* istanbul ignore next */
+                case 'space':
+                    break;
+                case 'newline':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+    return false;
+}
 function isFlowToken(token) {
     switch (token === null || token === void 0 ? void 0 : token.type) {
         case 'alias':
@@ -207,7 +239,6 @@ class Parser {
                         this.indent += source.length;
                     break;
                 case 'doc-mode':
-                case 'flow-error-end':
                     return;
                 default:
                     this.atNewLine = false;
@@ -280,14 +311,9 @@ class Parser {
         }
         else {
             const top = this.peek(1);
-            if (token.type === 'block-scalar') {
-                // Block scalars use their parent rather than header indent
-                token.indent = 'indent' in top ? top.indent : 0;
-            }
-            else if (token.type === 'flow-collection' && top.type === 'document') {
-                // Ignore all indent for top-level flow collections
-                token.indent = 0;
-            }
+            // For these, parent indent is needed instead of own
+            if (token.type === 'block-scalar' || token.type === 'flow-collection')
+                token.indent = 'indent' in top ? top.indent : -1;
             if (token.type === 'flow-collection')
                 fixFlowSeqItems(token);
             switch (top.type) {
@@ -480,38 +506,24 @@ class Parser {
         switch (this.type) {
             case 'newline':
                 this.onKeyLine = false;
-                if (it.value) {
-                    const end = 'end' in it.value ? it.value.end : undefined;
-                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
-                    else
-                        map.items.push({ start: [this.sourceToken] });
+                if (!it.sep && atFirstEmptyLineAfterComments(it.start)) {
+                    const prev = map.items[map.items.length - 2];
+                    const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                    if (Array.isArray(end)) {
+                        Array.prototype.push.apply(end, it.start);
+                        it.start = [this.sourceToken];
+                        return;
+                    }
                 }
-                else if (it.sep)
-                    it.sep.push(this.sourceToken);
-                else
-                    it.start.push(this.sourceToken);
-                return;
+            // fallthrough
             case 'space':
             case 'comment':
                 if (it.value)
                     map.items.push({ start: [this.sourceToken] });
                 else if (it.sep)
                     it.sep.push(this.sourceToken);
-                else {
-                    if (this.atIndentedComment(it.start, map.indent)) {
-                        const prev = map.items[map.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
-                        if (Array.isArray(end)) {
-                            Array.prototype.push.apply(end, it.start);
-                            end.push(this.sourceToken);
-                            map.items.pop();
-                            return;
-                        }
-                    }
+                else
                     it.start.push(this.sourceToken);
-                }
                 return;
         }
         if (this.indent >= map.indent) {
@@ -616,34 +628,22 @@ class Parser {
         const it = seq.items[seq.items.length - 1];
         switch (this.type) {
             case 'newline':
-                if (it.value) {
-                    const end = 'end' in it.value ? it.value.end : undefined;
-                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
-                    else
-                        seq.items.push({ start: [this.sourceToken] });
+                if (!it.value && atFirstEmptyLineAfterComments(it.start)) {
+                    const prev = seq.items[seq.items.length - 2];
+                    const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                    if (Array.isArray(end)) {
+                        Array.prototype.push.apply(end, it.start);
+                        it.start = [this.sourceToken];
+                        return;
+                    }
                 }
-                else
-                    it.start.push(this.sourceToken);
-                return;
+            // fallthrough
             case 'space':
             case 'comment':
                 if (it.value)
                     seq.items.push({ start: [this.sourceToken] });
-                else {
-                    if (this.atIndentedComment(it.start, seq.indent)) {
-                        const prev = seq.items[seq.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
-                        if (Array.isArray(end)) {
-                            Array.prototype.push.apply(end, it.start);
-                            end.push(this.sourceToken);
-                            seq.items.pop();
-                            return;
-                        }
-                    }
+                else
                     it.start.push(this.sourceToken);
-                }
                 return;
             case 'anchor':
             case 'tag':
@@ -838,13 +838,6 @@ class Parser {
         }
         return null;
     }
-    atIndentedComment(start, indent) {
-        if (this.type !== 'comment')
-            return false;
-        if (this.indent <= indent)
-            return false;
-        return start.every(st => st.type === 'newline' || st.type === 'space');
-    }
     *documentEnd(docEnd) {
         if (this.type !== 'doc-mode') {
             if (docEnd.end)

package/dist/public-api.js

@@ -8,8 +8,10 @@ var lineCounter = require('./parse/line-counter.js');
 var parser = require('./parse/parser.js');
 
 function parseOptions(options) {
-    const prettyErrors = options.prettyErrors !== false;
-    const lineCounter$1 = options.lineCounter || (prettyErrors && new lineCounter.LineCounter()) || null;
+    const prettyErrors = !options || options.prettyErrors !== false;
+    const lineCounter$1 = (options && options.lineCounter) ||
+        (prettyErrors && new lineCounter.LineCounter()) ||
+        null;
     return { lineCounter: lineCounter$1, prettyErrors };
 }
 /**