vaderjs 1.1.2 → 1.1.4

package/website/node_modules/yaml/dist/parse/cst-visit.d.ts

@@ -1,39 +0,0 @@
-import type { CollectionItem, Document } from './cst.js';
-export type VisitPath = readonly ['key' | 'value', number][];
-export type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
-/**
- * Apply a visitor to a CST document or item.
- *
- * Walks through the tree (depth-first) starting from the root, calling a
- * `visitor` function with two arguments when entering each item:
- *   - `item`: The current item, which included the following members:
- *     - `start: SourceToken[]` – Source tokens before the key or value,
- *       possibly including its anchor or tag.
- *     - `key?: Token | null` – Set for pair values. May then be `null`, if
- *       the key before the `:` separator is empty.
- *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
- *       which should include the `:` map value indicator if `value` is set.
- *     - `value?: Token` – The value of a sequence item, or of a map pair.
- *   - `path`: The steps from the root to the current node, as an array of
- *     `['key' | 'value', number]` tuples.
- *
- * The return value of the visitor may be used to control the traversal:
- *   - `undefined` (default): Do nothing and continue
- *   - `visit.SKIP`: Do not visit the children of this token, continue with
- *      next sibling
- *   - `visit.BREAK`: Terminate traversal completely
- *   - `visit.REMOVE`: Remove the current item, then continue with the next one
- *   - `number`: Set the index of the next step. This is useful especially if
- *     the index of the current token has changed.
- *   - `function`: Define the next visitor for this item. After the original
- *     visitor is called on item entry, next visitors are called after handling
- *     a non-empty `key` and when exiting the item.
- */
-export declare function visit(cst: Document | CollectionItem, visitor: Visitor): void;
-export declare namespace visit {
-    var BREAK: symbol;
-    var SKIP: symbol;
-    var REMOVE: symbol;
-    var itemAtPath: (cst: Document | CollectionItem, path: VisitPath) => CollectionItem | undefined;
-    var parentCollection: (cst: Document | CollectionItem, path: VisitPath) => import("./cst.js").BlockMap | import("./cst.js").BlockSequence | import("./cst.js").FlowCollection;
-}

package/website/node_modules/yaml/dist/parse/cst-visit.js

@@ -1,99 +0,0 @@
-'use strict';
-
-const BREAK = Symbol('break visit');
-const SKIP = Symbol('skip children');
-const REMOVE = Symbol('remove item');
-/**
- * Apply a visitor to a CST document or item.
- *
- * Walks through the tree (depth-first) starting from the root, calling a
- * `visitor` function with two arguments when entering each item:
- *   - `item`: The current item, which included the following members:
- *     - `start: SourceToken[]` – Source tokens before the key or value,
- *       possibly including its anchor or tag.
- *     - `key?: Token | null` – Set for pair values. May then be `null`, if
- *       the key before the `:` separator is empty.
- *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
- *       which should include the `:` map value indicator if `value` is set.
- *     - `value?: Token` – The value of a sequence item, or of a map pair.
- *   - `path`: The steps from the root to the current node, as an array of
- *     `['key' | 'value', number]` tuples.
- *
- * The return value of the visitor may be used to control the traversal:
- *   - `undefined` (default): Do nothing and continue
- *   - `visit.SKIP`: Do not visit the children of this token, continue with
- *      next sibling
- *   - `visit.BREAK`: Terminate traversal completely
- *   - `visit.REMOVE`: Remove the current item, then continue with the next one
- *   - `number`: Set the index of the next step. This is useful especially if
- *     the index of the current token has changed.
- *   - `function`: Define the next visitor for this item. After the original
- *     visitor is called on item entry, next visitors are called after handling
- *     a non-empty `key` and when exiting the item.
- */
-function visit(cst, visitor) {
-    if ('type' in cst && cst.type === 'document')
-        cst = { start: cst.start, value: cst.value };
-    _visit(Object.freeze([]), cst, visitor);
-}
-// Without the `as symbol` casts, TS declares these in the `visit`
-// namespace using `var`, but then complains about that because
-// `unique symbol` must be `const`.
-/** Terminate visit traversal completely */
-visit.BREAK = BREAK;
-/** Do not visit the children of the current item */
-visit.SKIP = SKIP;
-/** Remove the current item */
-visit.REMOVE = REMOVE;
-/** Find the item at `path` from `cst` as the root */
-visit.itemAtPath = (cst, path) => {
-    let item = cst;
-    for (const [field, index] of path) {
-        const tok = item?.[field];
-        if (tok && 'items' in tok) {
-            item = tok.items[index];
-        }
-        else
-            return undefined;
-    }
-    return item;
-};
-/**
- * Get the immediate parent collection of the item at `path` from `cst` as the root.
- *
- * Throws an error if the collection is not found, which should never happen if the item itself exists.
- */
-visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
-    const field = path[path.length - 1][0];
-    const coll = parent?.[field];
-    if (coll && 'items' in coll)
-        return coll;
-    throw new Error('Parent collection not found');
-};
-function _visit(path, item, visitor) {
-    let ctrl = visitor(item, path);
-    if (typeof ctrl === 'symbol')
-        return ctrl;
-    for (const field of ['key', 'value']) {
-        const token = item[field];
-        if (token && 'items' in token) {
-            for (let i = 0; i < token.items.length; ++i) {
-                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
-                if (typeof ci === 'number')
-                    i = ci - 1;
-                else if (ci === BREAK)
-                    return BREAK;
-                else if (ci === REMOVE) {
-                    token.items.splice(i, 1);
-                    i -= 1;
-                }
-            }
-            if (typeof ctrl === 'function' && field === 'key')
-                ctrl = ctrl(item, path);
-        }
-    }
-    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
-}
-
-exports.visit = visit;

package/website/node_modules/yaml/dist/parse/cst.d.ts

@@ -1,106 +0,0 @@
-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: '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;
-    source: string;
-    message: string;
-}
-export interface Directive {
-    type: 'directive';
-    offset: number;
-    source: string;
-}
-export interface Document {
-    type: 'document';
-    offset: number;
-    start: SourceToken[];
-    value?: Token;
-    end?: SourceToken[];
-}
-export interface DocumentEnd {
-    type: 'doc-end';
-    offset: number;
-    source: string;
-    end?: SourceToken[];
-}
-export interface FlowScalar {
-    type: 'alias' | 'scalar' | 'single-quoted-scalar' | 'double-quoted-scalar';
-    offset: number;
-    indent: number;
-    source: string;
-    end?: SourceToken[];
-}
-export interface BlockScalar {
-    type: 'block-scalar';
-    offset: number;
-    indent: number;
-    props: Token[];
-    source: string;
-}
-export interface BlockMap {
-    type: 'block-map';
-    offset: number;
-    indent: number;
-    items: Array<{
-        start: SourceToken[];
-        key?: never;
-        sep?: never;
-        value?: never;
-    } | {
-        start: SourceToken[];
-        key: Token | null;
-        sep: SourceToken[];
-        value?: Token;
-    }>;
-}
-export interface BlockSequence {
-    type: 'block-seq';
-    offset: number;
-    indent: number;
-    items: Array<{
-        start: SourceToken[];
-        key?: never;
-        sep?: never;
-        value?: Token;
-    }>;
-}
-export type CollectionItem = {
-    start: SourceToken[];
-    key?: Token | null;
-    sep?: SourceToken[];
-    value?: Token;
-};
-export interface FlowCollection {
-    type: 'flow-collection';
-    offset: number;
-    indent: number;
-    start: SourceToken;
-    items: CollectionItem[];
-    end: SourceToken[];
-}
-export type Token = SourceToken | ErrorToken | Directive | Document | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
-export type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];
-/** The byte order mark */
-export declare const BOM = "\uFEFF";
-/** Start of doc-mode */
-export declare const DOCUMENT = "\u0002";
-/** Unexpected end of flow-mode */
-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): TokenType | null;

package/website/node_modules/yaml/dist/parse/cst.js

@@ -1,112 +0,0 @@
-'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 */
-const DOCUMENT = '\x02'; // C0: Start of Text
-/** Unexpected end of flow-mode */
-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) {
-    switch (token) {
-        case BOM:
-            return '<BOM>';
-        case DOCUMENT:
-            return '<DOC>';
-        case FLOW_END:
-            return '<FLOW_END>';
-        case SCALAR:
-            return '<SCALAR>';
-        default:
-            return JSON.stringify(token);
-    }
-}
-/** Identify the type of a lexer token. May return `null` for unknown tokens. */
-function tokenType(source) {
-    switch (source) {
-        case BOM:
-            return 'byte-order-mark';
-        case DOCUMENT:
-            return 'doc-mode';
-        case FLOW_END:
-            return 'flow-error-end';
-        case SCALAR:
-            return 'scalar';
-        case '---':
-            return 'doc-start';
-        case '...':
-            return 'doc-end';
-        case '':
-        case '\n':
-        case '\r\n':
-            return 'newline';
-        case '-':
-            return 'seq-item-ind';
-        case '?':
-            return 'explicit-key-ind';
-        case ':':
-            return 'map-value-ind';
-        case '{':
-            return 'flow-map-start';
-        case '}':
-            return 'flow-map-end';
-        case '[':
-            return 'flow-seq-start';
-        case ']':
-            return 'flow-seq-end';
-        case ',':
-            return 'comma';
-    }
-    switch (source[0]) {
-        case ' ':
-        case '\t':
-            return 'space';
-        case '#':
-            return 'comment';
-        case '%':
-            return 'directive-line';
-        case '*':
-            return 'alias';
-        case '&':
-            return 'anchor';
-        case '!':
-            return 'tag';
-        case "'":
-            return 'single-quoted-scalar';
-        case '"':
-            return 'double-quoted-scalar';
-        case '|':
-        case '>':
-            return 'block-scalar-header';
-    }
-    return null;
-}
-
-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/website/node_modules/yaml/dist/parse/lexer.d.ts

@@ -1,87 +0,0 @@
-/**
- * Splits an input string into lexical tokens, i.e. smaller strings that are
- * easily identifiable by `tokens.tokenType()`.
- *
- * Lexing starts always in a "stream" context. Incomplete input may be buffered
- * until a complete token can be emitted.
- *
- * In addition to slices of the original input, the following control characters
- * may also be emitted:
- *
- * - `\x02` (Start of Text): A document starts with the next token
- * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
- * - `\x1f` (Unit Separator): Next token is a scalar value
- * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
- */
-export declare class Lexer {
-    /**
-     * Flag indicating whether the end of the current buffer marks the end of
-     * all input
-     */
-    private atEnd;
-    /**
-     * Explicit indent set in block scalar header, as an offset from the current
-     * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
-     * explicitly set.
-     */
-    private blockScalarIndent;
-    /**
-     * Block scalars that include a + (keep) chomping indicator in their header
-     * include trailing empty lines, which are otherwise excluded from the
-     * scalar's contents.
-     */
-    private blockScalarKeep;
-    /** Current input */
-    private buffer;
-    /**
-     * Flag noting whether the map value indicator : can immediately follow this
-     * node within a flow context.
-     */
-    private flowKey;
-    /** Count of surrounding flow collection levels. */
-    private flowLevel;
-    /**
-     * Minimum level of indentation required for next lines to be parsed as a
-     * part of the current scalar value.
-     */
-    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;
-    /**
-     * 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.
-     *
-     * @returns A generator of lexical tokens
-     */
-    lex(source: string, incomplete?: boolean): Generator<string, void, unknown>;
-    private atLineEnd;
-    private charAt;
-    private continueScalar;
-    private getLine;
-    private hasChars;
-    private setNext;
-    private peek;
-    private parseNext;
-    private parseStream;
-    private parseLineStart;
-    private parseBlockStart;
-    private parseDocument;
-    private parseFlowCollection;
-    private parseQuotedScalar;
-    private parseBlockScalarHeader;
-    private parseBlockScalar;
-    private parsePlainScalar;
-    private pushCount;
-    private pushToIndex;
-    private pushIndicators;
-    private pushTag;
-    private pushNewline;
-    private pushSpaces;
-    private pushUntil;
-}