kenaz 0.3.3 → 0.3.5

package/core/k-cli/node_modules/yaml/dist/parse/line-counter.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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/core/k-cli/node_modules/yaml/dist/parse/line-counter.js

@@ -1,41 +0,0 @@
-'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/core/k-cli/node_modules/yaml/dist/parse/parser.d.ts

@@ -1,84 +0,0 @@
-import type { Token } from './cst';
-/**
- * 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>;
-    /**
-     * Advance the parser by the `source` of one lexical token.
-     */
-    next(source: string): Generator<Token, void>;
-    private lexer;
-    /** Call at end of input to push out any remaining constructions */
-    end(): Generator<Token, void>;
-    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;
-}