yaml 2.0.0-4 → 2.0.0-8

package/dist/parse/{tokens.d.ts → cst.d.ts}

@@ -1,17 +1,21 @@
-export declare type SourceTokenType = 'byte-order-mark' | 'doc-mode' | 'scalar' | 'doc-start' | 'doc-end' | 'space' | 'comment' | 'newline' | 'directive-line' | 'alias' | 'anchor' | 'tag' | 'seq-item-ind' | 'explicit-key-ind' | 'map-value-ind' | 'flow-map-start' | 'flow-map-end' | 'flow-seq-start' | 'flow-seq-end' | 'flow-error-end' | 'comma' | 'single-quoted-scalar' | 'double-quoted-scalar' | 'block-scalar-header';
+export { createScalarToken, resolveAsScalar, setScalarValue } from './cst-scalar.js';
+export { stringify } from './cst-stringify.js';
+export { visit, Visitor, VisitPath } from './cst-visit.js';
 export interface SourceToken {
-    type: Exclude<SourceTokenType, DocumentEnd['type'] | FlowScalar['type']>;
+    type: 'byte-order-mark' | 'doc-mode' | 'doc-start' | 'space' | 'comment' | 'newline' | 'directive-line' | 'anchor' | 'tag' | 'seq-item-ind' | 'explicit-key-ind' | 'map-value-ind' | 'flow-map-start' | 'flow-map-end' | 'flow-seq-start' | 'flow-seq-end' | 'flow-error-end' | 'comma' | 'block-scalar-header';
+    offset: number;
     indent: number;
     source: string;
 }
 export interface ErrorToken {
     type: 'error';
-    offset?: number;
+    offset: number;
     source: string;
     message: string;
 }
 export interface Directive {
     type: 'directive';
+    offset: number;
     source: string;
 }
 export interface Document {
@@ -39,7 +43,7 @@ export interface BlockScalar {
     offset: number;
     indent: number;
     props: Token[];
-    source?: string;
+    source: string;
 }
 export interface BlockMap {
     type: 'block-map';
@@ -63,19 +67,27 @@ export interface BlockSequence {
     indent: number;
     items: Array<{
         start: SourceToken[];
-        value?: Token;
+        key?: never;
         sep?: never;
+        value?: Token;
     }>;
 }
+export declare type CollectionItem = {
+    start: SourceToken[];
+    key?: Token | null;
+    sep?: SourceToken[];
+    value?: Token;
+};
 export interface FlowCollection {
     type: 'flow-collection';
     offset: number;
     indent: number;
     start: SourceToken;
-    items: Array<Token>;
+    items: CollectionItem[];
     end: SourceToken[];
 }
 export declare type Token = SourceToken | ErrorToken | Directive | Document | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
+export declare type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];
 /** The byte order mark */
 export declare const BOM = "\uFEFF";
 /** Start of doc-mode */
@@ -84,7 +96,11 @@ export declare const DOCUMENT = "\u0002";
 export declare const FLOW_END = "\u0018";
 /** Next token is a scalar value */
 export declare const SCALAR = "\u001F";
+/** @returns `true` if `token` is a flow or block collection */
+export declare const isCollection: (token: Token | null | undefined) => token is BlockMap | BlockSequence | FlowCollection;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+export declare const isScalar: (token: Token | null | undefined) => token is BlockScalar | FlowScalar;
 /** Get a printable representation of a lexer token */
 export declare function prettyToken(token: string): string;
 /** Identify the type of a lexer token. May return `null` for unknown tokens. */
-export declare function tokenType(source: string): SourceTokenType | null;
+export declare function tokenType(source: string): TokenType | null;

package/{browser/dist/parse/tokens.js → dist/parse/cst.js}

@@ -1,3 +1,9 @@
+'use strict';
+
+var cstScalar = require('./cst-scalar.js');
+var cstStringify = require('./cst-stringify.js');
+var cstVisit = require('./cst-visit.js');
+
 /** The byte order mark */
 const BOM = '\u{FEFF}';
 /** Start of doc-mode */
@@ -6,6 +12,14 @@ const DOCUMENT = '\x02'; // C0: Start of Text
 const FLOW_END = '\x18'; // C0: Cancel
 /** Next token is a scalar value */
 const SCALAR = '\x1f'; // C0: Unit Separator
+/** @returns `true` if `token` is a flow or block collection */
+const isCollection = (token) => !!token && 'items' in token;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+const isScalar = (token) => !!token &&
+    (token.type === 'scalar' ||
+        token.type === 'single-quoted-scalar' ||
+        token.type === 'double-quoted-scalar' ||
+        token.type === 'block-scalar');
 /* istanbul ignore next */
 /** Get a printable representation of a lexer token */
 function prettyToken(token) {
@@ -83,4 +97,16 @@ function tokenType(source) {
     return null;
 }
 
-export { BOM, DOCUMENT, FLOW_END, SCALAR, prettyToken, tokenType };
+exports.createScalarToken = cstScalar.createScalarToken;
+exports.resolveAsScalar = cstScalar.resolveAsScalar;
+exports.setScalarValue = cstScalar.setScalarValue;
+exports.stringify = cstStringify.stringify;
+exports.visit = cstVisit.visit;
+exports.BOM = BOM;
+exports.DOCUMENT = DOCUMENT;
+exports.FLOW_END = FLOW_END;
+exports.SCALAR = SCALAR;
+exports.isCollection = isCollection;
+exports.isScalar = isScalar;
+exports.prettyToken = prettyToken;
+exports.tokenType = tokenType;

package/dist/parse/lexer.d.ts

@@ -14,7 +14,6 @@
  * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
  */
 export declare class Lexer {
-    private push;
     /**
      * Flag indicating whether the end of the current buffer marks the end of
      * all input
@@ -48,25 +47,19 @@ 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. */
     private pos;
     /**
-     * Define/initialise a YAML lexer. `push` will be called separately with each
-     * token when `lex()` is passed an input string.
+     * Generate YAML tokens from the `source` string. If `incomplete`,
+     * a part of the last line may be left as a buffer for the next call.
      *
-     * @public
+     * @returns A generator of lexical tokens
      */
-    constructor(push: (token: string) => void);
-    /**
-     * Read YAML tokens from the `source` string, calling the callback
-     * defined in the constructor for each one. If `incomplete`, a part
-     * of the last line may be left as a buffer for the next call.
-     *
-     * @public
-     */
-    lex(source: string, incomplete: boolean): void;
+    lex(source: string, incomplete?: boolean): Generator<string, void, unknown>;
     private atLineEnd;
     private charAt;
     private continueScalar;
@@ -87,7 +80,7 @@ export declare class Lexer {
     private pushCount;
     private pushToIndex;
     private pushIndicators;
-    private pushVerbatimTag;
+    private pushTag;
     private pushNewline;
     private pushSpaces;
     private pushUntil;