@harness-engineering/cli 1.0.1 → 1.1.0

package/dist/agents/skills/node_modules/yaml/dist/options.d.ts

@@ -0,0 +1,344 @@
+import type { Reviver } from './doc/applyReviver';
+import type { Directives } from './doc/directives';
+import type { LogLevelId } from './log';
+import type { ParsedNode } from './nodes/Node';
+import type { Pair } from './nodes/Pair';
+import type { Scalar } from './nodes/Scalar';
+import type { LineCounter } from './parse/line-counter';
+import type { Schema } from './schema/Schema';
+import type { Tags } from './schema/tags';
+import type { CollectionTag, ScalarTag } from './schema/types';
+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;
+    /**
+     * Parse all mapping keys as strings. Treat all non-scalar keys as errors.
+     *
+     * Default: `false`
+     */
+    stringKeys?: 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/dist/agents/skills/node_modules/yaml/dist/parse/cst-scalar.d.ts

@@ -0,0 +1,64 @@
+import type { ErrorCode } from '../errors';
+import type { Range } from '../nodes/Node';
+import type { Scalar } from '../nodes/Scalar';
+import type { BlockScalar, FlowScalar, SourceToken, Token } from './cst';
+/**
+ * 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/dist/agents/skills/node_modules/yaml/dist/parse/cst-scalar.js

@@ -0,0 +1,218 @@
+'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({ options: { strict } }, token, _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/dist/agents/skills/node_modules/yaml/dist/parse/cst-stringify.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionItem, Token } from './cst';
+/**
+ * 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/dist/agents/skills/node_modules/yaml/dist/parse/cst-stringify.js

@@ -0,0 +1,63 @@
+'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;