@xyagent/cli 0.0.1

package/src-shared/vendor/yaml/dist/parse/line-counter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tracks newlines during parsing in order to provide an efficient API for
+ * determining the one-indexed `{ line, col }` position for any offset
+ * within the input.
+ */
+export declare class LineCounter {
+    lineStarts: number[];
+    /**
+     * Should be called in ascending order. Otherwise, call
+     * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+     */
+    addNewLine: (offset: number) => number;
+    /**
+     * Performs a binary search and returns the 1-indexed { line, col }
+     * position of `offset`. If `line === 0`, `addNewLine` has never been
+     * called or `offset` is before the first known newline.
+     */
+    linePos: (offset: number) => {
+        line: number;
+        col: number;
+    };
+}

package/src-shared/vendor/yaml/dist/parse/line-counter.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Tracks newlines during parsing in order to provide an efficient API for
+ * determining the one-indexed `{ line, col }` position for any offset
+ * within the input.
+ */
+class LineCounter {
+    constructor() {
+        this.lineStarts = [];
+        /**
+         * Should be called in ascending order. Otherwise, call
+         * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+         */
+        this.addNewLine = (offset) => this.lineStarts.push(offset);
+        /**
+         * Performs a binary search and returns the 1-indexed { line, col }
+         * position of `offset`. If `line === 0`, `addNewLine` has never been
+         * called or `offset` is before the first known newline.
+         */
+        this.linePos = (offset) => {
+            let low = 0;
+            let high = this.lineStarts.length;
+            while (low < high) {
+                const mid = (low + high) >> 1; // Math.floor((low + high) / 2)
+                if (this.lineStarts[mid] < offset)
+                    low = mid + 1;
+                else
+                    high = mid;
+            }
+            if (this.lineStarts[low] === offset)
+                return { line: low + 1, col: 1 };
+            if (low === 0)
+                return { line: 0, col: offset };
+            const start = this.lineStarts[low - 1];
+            return { line: low, col: offset - start + 1 };
+        };
+    }
+}
+
+exports.LineCounter = LineCounter;

package/src-shared/vendor/yaml/dist/parse/parser.d.ts

@@ -0,0 +1,84 @@
+import { Token } from './cst.js';
+/**
+ * A YAML concrete syntax tree (CST) parser
+ *
+ * ```ts
+ * const src: string = ...
+ * for (const token of new Parser().parse(src)) {
+ *   // token: Token
+ * }
+ * ```
+ *
+ * To use the parser with a user-provided lexer:
+ *
+ * ```ts
+ * function* parse(source: string, lexer: Lexer) {
+ *   const parser = new Parser()
+ *   for (const lexeme of lexer.lex(source))
+ *     yield* parser.next(lexeme)
+ *   yield* parser.end()
+ * }
+ *
+ * const src: string = ...
+ * const lexer = new Lexer()
+ * for (const token of parse(src, lexer)) {
+ *   // token: Token
+ * }
+ * ```
+ */
+export declare class Parser {
+    private onNewLine?;
+    /** If true, space and sequence indicators count as indentation */
+    private atNewLine;
+    /** If true, next token is a scalar value */
+    private atScalar;
+    /** Current indentation level */
+    private indent;
+    /** Current offset since the start of parsing */
+    offset: number;
+    /** On the same line with a block map key */
+    private onKeyLine;
+    /** Top indicates the node that's currently being built */
+    stack: Token[];
+    /** The source of the current token, set in parse() */
+    private source;
+    /** The type of the current token, set in parse() */
+    private type;
+    /**
+     * @param onNewLine - If defined, called separately with the start position of
+     *   each new line (in `parse()`, including the start of input).
+     */
+    constructor(onNewLine?: (offset: number) => void);
+    /**
+     * Parse `source` as a YAML stream.
+     * If `incomplete`, a part of the last line may be left as a buffer for the next call.
+     *
+     * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
+     *
+     * @returns A generator of tokens representing each directive, document, and other structure.
+     */
+    parse(source: string, incomplete?: boolean): Generator<Token, void, unknown>;
+    /**
+     * Advance the parser by the `source` of one lexical token.
+     */
+    next(source: string): Generator<Token, void, unknown>;
+    private lexer;
+    /** Call at end of input to push out any remaining constructions */
+    end(): Generator<Token, void, unknown>;
+    private get sourceToken();
+    private step;
+    private peek;
+    private pop;
+    private stream;
+    private document;
+    private scalar;
+    private blockScalar;
+    private blockMap;
+    private blockSequence;
+    private flowCollection;
+    private flowScalar;
+    private startBlockValue;
+    private atIndentedComment;
+    private documentEnd;
+    private lineEnd;
+}