vaderjs 1.1.2 → 1.1.4

package/website/node_modules/yaml/dist/options.d.ts

@@ -1,338 +0,0 @@
-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 { Tags } from './schema/tags.js';
-import type { CollectionTag, ScalarTag } from './schema/types.js';
-export type ParseOptions = {
-    /**
-     * Whether integers should be parsed into BigInt rather than number values.
-     *
-     * Default: `false`
-     *
-     * 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.
-     */
-    lineCounter?: LineCounter;
-    /**
-     * Include line/col position & node type directly in parse errors.
-     *
-     * Default: `true`
-     */
-    prettyErrors?: boolean;
-    /**
-     * Detect and report errors that are required by the YAML 1.2 spec,
-     * but are caused by unambiguous content.
-     *
-     * 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 type DocumentOptions = {
-    /**
-     * @internal
-     * Used internally by Composer. If set and includes an explicit version,
-     * that overrides the `version` option.
-     */
-    _directives?: Directives;
-    /**
-     * Control the logging level during parsing
-     *
-     * Default: `'warn'`
-     */
-    logLevel?: LogLevelId;
-    /**
-     * The YAML version used by documents without a `%YAML` directive.
-     *
-     * Default: `"1.2"`
-     */
-    version?: '1.1' | '1.2' | 'next';
-};
-export 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.
-     */
-    customTags?: Tags | ((tags: Tags) => Tags) | null;
-    /**
-     * Enable support for `<<` merge keys.
-     *
-     * Default: `false` for YAML 1.2, `true` for earlier versions
-     */
-    merge?: boolean;
-    /**
-     * When using the `'core'` schema, support parsing values with these
-     * explicit YAML 1.1 tags:
-     *
-     * `!!binary`, `!!omap`, `!!pairs`, `!!set`, `!!timestamp`.
-     *
-     * Default `true`
-     */
-    resolveKnownTags?: boolean;
-    /**
-     * 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
-     */
-    schema?: string | Schema;
-    /**
-     * 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 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.
-     *
-     * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
-     */
-    anchorPrefix?: string;
-    /** Force the top-level collection node to use flow style. */
-    flow?: boolean;
-    /**
-     * Keep `undefined` object values when creating mappings, rather than
-     * discarding them.
-     *
-     * Default: `false`
-     */
-    keepUndefined?: boolean | null;
-    onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
-    /**
-     * Specify the top-level collection type, e.g. `"!!omap"`. Note that this
-     * requires the corresponding tag to be available in this document's schema.
-     */
-    tag?: string;
-};
-export type ToJSOptions = {
-    /**
-     * Use Map rather than Object to represent mappings.
-     *
-     * Default: `false`
-     */
-    mapAsMap?: boolean;
-    /**
-     * Prevent exponential entity expansion attacks by limiting data aliasing count;
-     * set to `-1` to disable checks; `0` disallows all alias nodes.
-     *
-     * Default: `100`
-     */
-    maxAliasCount?: number;
-    /**
-     * If defined, called with the resolved `value` and reference `count` for
-     * each anchor in the document.
-     */
-    onAnchor?: (value: unknown, count: number) => void;
-    /**
-     * Optional function that may filter or modify the output JS value
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#using_the_reviver_parameter
-     */
-    reviver?: Reviver;
-};
-export 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.
-     *
-     * If `null`, the value of `defaultStringType` is used.
-     *
-     * Default: `null`
-     */
-    defaultKeyType?: Scalar.Type | null;
-    /**
-     * The default type of string literal used to stringify values in general.
-     * Output may use other types if required to fully represent the value.
-     *
-     * Default: `'PLAIN'`
-     */
-    defaultStringType?: Scalar.Type;
-    /**
-     * Include directives in the output.
-     *
-     * - If `true`, at least the document-start marker `---` is always included.
-     *   This does not force the `%YAML` directive to be included. To do that,
-     *   set `doc.directives.yaml.explicit = true`.
-     * - If `false`, no directives or marker is ever included. If using the `%TAG`
-     *   directive, you are expected to include it manually in the stream before
-     *   its use.
-     * - If `null`, directives and marker may be included if required.
-     *
-     * Default: `null`
-     */
-    directives?: boolean | null;
-    /**
-     * Restrict double-quoted strings to use JSON-compatible syntax.
-     *
-     * Default: `false`
-     */
-    doubleQuotedAsJSON?: boolean;
-    /**
-     * Minimum length for double-quoted strings to use multiple lines to
-     * represent the value. Ignored if `doubleQuotedAsJSON` is set.
-     *
-     * Default: `40`
-     */
-    doubleQuotedMinMultiLineLength?: number;
-    /**
-     * String representation for `false`.
-     * With the core schema, use `'false'`, `'False'`, or `'FALSE'`.
-     *
-     * Default: `'false'`
-     */
-    falseStr?: string;
-    /**
-     * When true, a single space of padding will be added inside the delimiters
-     * of non-empty single-line flow collections.
-     *
-     * Default: `true`
-     */
-    flowCollectionPadding?: boolean;
-    /**
-     * The number of spaces to use when indenting code.
-     *
-     * Default: `2`
-     */
-    indent?: number;
-    /**
-     * Whether block sequences should be indented.
-     *
-     * Default: `true`
-     */
-    indentSeq?: boolean;
-    /**
-     * Maximum line width (set to `0` to disable folding).
-     *
-     * This is a soft limit, as only double-quoted semantics allow for inserting
-     * a line break in the middle of a word, as well as being influenced by the
-     * `minContentWidth` option.
-     *
-     * Default: `80`
-     */
-    lineWidth?: number;
-    /**
-     * Minimum line width for highly-indented content (set to `0` to disable).
-     *
-     * Default: `20`
-     */
-    minContentWidth?: number;
-    /**
-     * String representation for `null`.
-     * With the core schema, use `'null'`, `'Null'`, `'NULL'`, `'~'`, or an empty
-     * string `''`.
-     *
-     * Default: `'null'`
-     */
-    nullStr?: string;
-    /**
-     * Require keys to be scalars and to use implicit rather than explicit notation.
-     *
-     * Default: `false`
-     */
-    simpleKeys?: boolean;
-    /**
-     * Use 'single quote' rather than "double quote" where applicable.
-     * Set to `false` to disable single quotes completely.
-     *
-     * Default: `null`
-     */
-    singleQuote?: boolean | null;
-    /**
-     * String representation for `true`.
-     * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.
-     *
-     * Default: `'true'`
-     */
-    trueStr?: string;
-    /**
-     * The anchor used by an alias must be defined before the alias node. As it's
-     * possible for the document to be modified manually, the order may be
-     * verified during stringification.
-     *
-     * Default: `'true'`
-     */
-    verifyAliasOrder?: boolean;
-};

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

@@ -1,64 +0,0 @@
-import { ErrorCode } from '../errors.js';
-import { Range } from '../nodes/Node.js';
-import type { Scalar } from '../nodes/Scalar.js';
-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;
-    comment: string;
-    range: Range;
-} | null;
-/**
- * Create a new scalar token with `value`
- *
- * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
- * as this function does not support any schema operations and won't check for such conflicts.
- *
- * @param value The string representation of the value, which will have its content properly indented.
- * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
- * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
- * @param context.indent The indent level of the token.
- * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
- * @param context.offset The offset position of the token.
- * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
- */
-export declare function createScalarToken(value: string, context: {
-    end?: SourceToken[];
-    implicitKey?: boolean;
-    indent: number;
-    inFlow?: boolean;
-    offset?: number;
-    type?: Scalar.Type;
-}): BlockScalar | FlowScalar;
-/**
- * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
- *
- * Best efforts are made to retain any comments previously associated with the `token`,
- * though all contents within a collection's `items` will be overwritten.
- *
- * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
- * as this function does not support any schema operations and won't check for such conflicts.
- *
- * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
- * @param value The string representation of the value, which will have its content properly indented.
- * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
- * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
- * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
- * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
- */
-export declare function setScalarValue(token: Token, value: string, context?: {
-    afterKey?: boolean;
-    implicitKey?: boolean;
-    inFlow?: boolean;
-    type?: Scalar.Type;
-}): void;

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

@@ -1,218 +0,0 @@
-'use strict';
-
-var resolveBlockScalar = require('../compose/resolve-block-scalar.js');
-var resolveFlowScalar = require('../compose/resolve-flow-scalar.js');
-var errors = require('../errors.js');
-var stringifyString = require('../stringify/stringifyString.js');
-
-function resolveAsScalar(token, strict = true, onError) {
-    if (token) {
-        const _onError = (pos, code, message) => {
-            const offset = typeof pos === 'number' ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
-            if (onError)
-                onError(offset, code, message);
-            else
-                throw new errors.YAMLParseError([offset, offset + 1], code, message);
-        };
-        switch (token.type) {
-            case 'scalar':
-            case 'single-quoted-scalar':
-            case 'double-quoted-scalar':
-                return resolveFlowScalar.resolveFlowScalar(token, strict, _onError);
-            case 'block-scalar':
-                return resolveBlockScalar.resolveBlockScalar(token, strict, _onError);
-        }
-    }
-    return null;
-}
-/**
- * Create a new scalar token with `value`
- *
- * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
- * as this function does not support any schema operations and won't check for such conflicts.
- *
- * @param value The string representation of the value, which will have its content properly indented.
- * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
- * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
- * @param context.indent The indent level of the token.
- * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
- * @param context.offset The offset position of the token.
- * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
- */
-function createScalarToken(value, context) {
-    const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
-    const source = stringifyString.stringifyString({ type, value }, {
-        implicitKey,
-        indent: indent > 0 ? ' '.repeat(indent) : '',
-        inFlow,
-        options: { blockQuote: true, lineWidth: -1 }
-    });
-    const end = context.end ?? [
-        { type: 'newline', offset: -1, indent, source: '\n' }
-    ];
-    switch (source[0]) {
-        case '|':
-        case '>': {
-            const he = source.indexOf('\n');
-            const head = source.substring(0, he);
-            const body = source.substring(he + 1) + '\n';
-            const props = [
-                { type: 'block-scalar-header', offset, indent, source: head }
-            ];
-            if (!addEndtoBlockProps(props, end))
-                props.push({ type: 'newline', offset: -1, indent, source: '\n' });
-            return { type: 'block-scalar', offset, indent, props, source: body };
-        }
-        case '"':
-            return { type: 'double-quoted-scalar', offset, indent, source, end };
-        case "'":
-            return { type: 'single-quoted-scalar', offset, indent, source, end };
-        default:
-            return { type: 'scalar', offset, indent, source, end };
-    }
-}
-/**
- * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
- *
- * Best efforts are made to retain any comments previously associated with the `token`,
- * though all contents within a collection's `items` will be overwritten.
- *
- * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
- * as this function does not support any schema operations and won't check for such conflicts.
- *
- * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
- * @param value The string representation of the value, which will have its content properly indented.
- * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
- * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
- * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
- * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
- */
-function setScalarValue(token, value, context = {}) {
-    let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
-    let indent = 'indent' in token ? token.indent : null;
-    if (afterKey && typeof indent === 'number')
-        indent += 2;
-    if (!type)
-        switch (token.type) {
-            case 'single-quoted-scalar':
-                type = 'QUOTE_SINGLE';
-                break;
-            case 'double-quoted-scalar':
-                type = 'QUOTE_DOUBLE';
-                break;
-            case 'block-scalar': {
-                const header = token.props[0];
-                if (header.type !== 'block-scalar-header')
-                    throw new Error('Invalid block scalar header');
-                type = header.source[0] === '>' ? 'BLOCK_FOLDED' : 'BLOCK_LITERAL';
-                break;
-            }
-            default:
-                type = 'PLAIN';
-        }
-    const source = stringifyString.stringifyString({ type, value }, {
-        implicitKey: implicitKey || indent === null,
-        indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
-        inFlow,
-        options: { blockQuote: true, lineWidth: -1 }
-    });
-    switch (source[0]) {
-        case '|':
-        case '>':
-            setBlockScalarValue(token, source);
-            break;
-        case '"':
-            setFlowScalarValue(token, source, 'double-quoted-scalar');
-            break;
-        case "'":
-            setFlowScalarValue(token, source, 'single-quoted-scalar');
-            break;
-        default:
-            setFlowScalarValue(token, source, 'scalar');
-    }
-}
-function setBlockScalarValue(token, source) {
-    const he = source.indexOf('\n');
-    const head = source.substring(0, he);
-    const body = source.substring(he + 1) + '\n';
-    if (token.type === 'block-scalar') {
-        const header = token.props[0];
-        if (header.type !== 'block-scalar-header')
-            throw new Error('Invalid block scalar header');
-        header.source = head;
-        token.source = body;
-    }
-    else {
-        const { offset } = token;
-        const indent = 'indent' in token ? token.indent : -1;
-        const props = [
-            { type: 'block-scalar-header', offset, indent, source: head }
-        ];
-        if (!addEndtoBlockProps(props, 'end' in token ? token.end : undefined))
-            props.push({ type: 'newline', offset: -1, indent, source: '\n' });
-        for (const key of Object.keys(token))
-            if (key !== 'type' && key !== 'offset')
-                delete token[key];
-        Object.assign(token, { type: 'block-scalar', indent, props, source: body });
-    }
-}
-/** @returns `true` if last token is a newline */
-function addEndtoBlockProps(props, end) {
-    if (end)
-        for (const st of end)
-            switch (st.type) {
-                case 'space':
-                case 'comment':
-                    props.push(st);
-                    break;
-                case 'newline':
-                    props.push(st);
-                    return true;
-            }
-    return false;
-}
-function setFlowScalarValue(token, source, type) {
-    switch (token.type) {
-        case 'scalar':
-        case 'double-quoted-scalar':
-        case 'single-quoted-scalar':
-            token.type = type;
-            token.source = source;
-            break;
-        case 'block-scalar': {
-            const end = token.props.slice(1);
-            let oa = source.length;
-            if (token.props[0].type === 'block-scalar-header')
-                oa -= token.props[0].source.length;
-            for (const tok of end)
-                tok.offset += oa;
-            delete token.props;
-            Object.assign(token, { type, source, end });
-            break;
-        }
-        case 'block-map':
-        case 'block-seq': {
-            const offset = token.offset + source.length;
-            const nl = { type: 'newline', offset, indent: token.indent, source: '\n' };
-            delete token.items;
-            Object.assign(token, { type, source, end: [nl] });
-            break;
-        }
-        default: {
-            const indent = 'indent' in token ? token.indent : -1;
-            const end = 'end' in token && Array.isArray(token.end)
-                ? token.end.filter(st => st.type === 'space' ||
-                    st.type === 'comment' ||
-                    st.type === 'newline')
-                : [];
-            for (const key of Object.keys(token))
-                if (key !== 'type' && key !== 'offset')
-                    delete token[key];
-            Object.assign(token, { type, indent, source, end });
-        }
-    }
-}
-
-exports.createScalarToken = createScalarToken;
-exports.resolveAsScalar = resolveAsScalar;
-exports.setScalarValue = setScalarValue;

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

@@ -1,8 +0,0 @@
-import type { CollectionItem, Token } from './cst.js';
-/**
- * Stringify a CST document, token, or collection item
- *
- * Fair warning: This applies no validation whatsoever, and
- * simply concatenates the sources in their logical order.
- */
-export declare const stringify: (cst: Token | CollectionItem) => string;

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

@@ -1,63 +0,0 @@
-'use strict';
-
-/**
- * Stringify a CST document, token, or collection item
- *
- * Fair warning: This applies no validation whatsoever, and
- * simply concatenates the sources in their logical order.
- */
-const stringify = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst);
-function stringifyToken(token) {
-    switch (token.type) {
-        case 'block-scalar': {
-            let res = '';
-            for (const tok of token.props)
-                res += stringifyToken(tok);
-            return res + token.source;
-        }
-        case 'block-map':
-        case 'block-seq': {
-            let res = '';
-            for (const item of token.items)
-                res += stringifyItem(item);
-            return res;
-        }
-        case 'flow-collection': {
-            let res = token.start.source;
-            for (const item of token.items)
-                res += stringifyItem(item);
-            for (const st of token.end)
-                res += st.source;
-            return res;
-        }
-        case 'document': {
-            let res = stringifyItem(token);
-            if (token.end)
-                for (const st of token.end)
-                    res += st.source;
-            return res;
-        }
-        default: {
-            let res = token.source;
-            if ('end' in token && token.end)
-                for (const st of token.end)
-                    res += st.source;
-            return res;
-        }
-    }
-}
-function stringifyItem({ start, key, sep, value }) {
-    let res = '';
-    for (const st of start)
-        res += st.source;
-    if (key)
-        res += stringifyToken(key);
-    if (sep)
-        for (const st of sep)
-            res += st.source;
-    if (value)
-        res += stringifyToken(value);
-    return res;
-}
-
-exports.stringify = stringify;