@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/node_modules/yaml/dist/schema/tags.js

@@ -1,99 +0,0 @@
-'use strict';
-
-var map = require('./common/map.js');
-var _null = require('./common/null.js');
-var seq = require('./common/seq.js');
-var string = require('./common/string.js');
-var bool = require('./core/bool.js');
-var float = require('./core/float.js');
-var int = require('./core/int.js');
-var schema = require('./core/schema.js');
-var schema$1 = require('./json/schema.js');
-var binary = require('./yaml-1.1/binary.js');
-var merge = require('./yaml-1.1/merge.js');
-var omap = require('./yaml-1.1/omap.js');
-var pairs = require('./yaml-1.1/pairs.js');
-var schema$2 = require('./yaml-1.1/schema.js');
-var set = require('./yaml-1.1/set.js');
-var timestamp = require('./yaml-1.1/timestamp.js');
-
-const schemas = new Map([
-    ['core', schema.schema],
-    ['failsafe', [map.map, seq.seq, string.string]],
-    ['json', schema$1.schema],
-    ['yaml11', schema$2.schema],
-    ['yaml-1.1', schema$2.schema]
-]);
-const tagsByName = {
-    binary: binary.binary,
-    bool: bool.boolTag,
-    float: float.float,
-    floatExp: float.floatExp,
-    floatNaN: float.floatNaN,
-    floatTime: timestamp.floatTime,
-    int: int.int,
-    intHex: int.intHex,
-    intOct: int.intOct,
-    intTime: timestamp.intTime,
-    map: map.map,
-    merge: merge.merge,
-    null: _null.nullTag,
-    omap: omap.omap,
-    pairs: pairs.pairs,
-    seq: seq.seq,
-    set: set.set,
-    timestamp: timestamp.timestamp
-};
-const coreKnownTags = {
-    'tag:yaml.org,2002:binary': binary.binary,
-    'tag:yaml.org,2002:merge': merge.merge,
-    'tag:yaml.org,2002:omap': omap.omap,
-    'tag:yaml.org,2002:pairs': pairs.pairs,
-    'tag:yaml.org,2002:set': set.set,
-    'tag:yaml.org,2002:timestamp': timestamp.timestamp
-};
-function getTags(customTags, schemaName, addMergeTag) {
-    const schemaTags = schemas.get(schemaName);
-    if (schemaTags && !customTags) {
-        return addMergeTag && !schemaTags.includes(merge.merge)
-            ? schemaTags.concat(merge.merge)
-            : schemaTags.slice();
-    }
-    let tags = schemaTags;
-    if (!tags) {
-        if (Array.isArray(customTags))
-            tags = [];
-        else {
-            const keys = Array.from(schemas.keys())
-                .filter(key => key !== 'yaml11')
-                .map(key => JSON.stringify(key))
-                .join(', ');
-            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
-        }
-    }
-    if (Array.isArray(customTags)) {
-        for (const tag of customTags)
-            tags = tags.concat(tag);
-    }
-    else if (typeof customTags === 'function') {
-        tags = customTags(tags.slice());
-    }
-    if (addMergeTag)
-        tags = tags.concat(merge.merge);
-    return tags.reduce((tags, tag) => {
-        const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;
-        if (!tagObj) {
-            const tagName = JSON.stringify(tag);
-            const keys = Object.keys(tagsByName)
-                .map(key => JSON.stringify(key))
-                .join(', ');
-            throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
-        }
-        if (!tags.includes(tagObj))
-            tags.push(tagObj);
-        return tags;
-    }, []);
-}
-
-exports.coreKnownTags = coreKnownTags;
-exports.getTags = getTags;

package/node_modules/yaml/dist/schema/types.d.ts

@@ -1,92 +0,0 @@
-import type { CreateNodeContext } from '../doc/createNode';
-import type { Node } from '../nodes/Node';
-import type { Scalar } from '../nodes/Scalar';
-import type { YAMLMap } from '../nodes/YAMLMap';
-import type { YAMLSeq } from '../nodes/YAMLSeq';
-import type { ParseOptions } from '../options';
-import type { StringifyContext } from '../stringify/stringify';
-import type { Schema } from './Schema';
-interface TagBase {
-    /**
-     * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
-     */
-    createNode?: (schema: Schema, value: unknown, ctx: CreateNodeContext) => Node;
-    /**
-     * If `true`, allows for values to be stringified without
-     * an explicit tag together with `test`.
-     * If `'key'`, this only applies if the value is used as a mapping key.
-     * For most cases, it's unlikely that you'll actually want to use this,
-     * even if you first think you do.
-     */
-    default?: boolean | 'key';
-    /**
-     * If a tag has multiple forms that should be parsed and/or stringified
-     * differently, use `format` to identify them.
-     */
-    format?: string;
-    /**
-     * Used by `YAML.createNode` to detect your data type, e.g. using `typeof` or
-     * `instanceof`.
-     */
-    identify?: (value: unknown) => boolean;
-    /**
-     * The identifier for your data type, with which its stringified form will be
-     * prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified
-     * `tag:domain,date:foo`.
-     */
-    tag: string;
-}
-export interface ScalarTag extends TagBase {
-    collection?: never;
-    nodeClass?: never;
-    /**
-     * Turns a value into an AST node.
-     * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
-     */
-    resolve(value: string, onError: (message: string) => void, options: ParseOptions): unknown;
-    /**
-     * Optional function stringifying a Scalar node. If your data includes a
-     * suitable `.toString()` method, you can probably leave this undefined and
-     * use the default stringifier.
-     *
-     * @param item The node being stringified.
-     * @param ctx Contains the stringifying context variables.
-     * @param onComment Callback to signal that the stringifier includes the
-     *   item's comment in its output.
-     * @param onChompKeep Callback to signal that the output uses a block scalar
-     *   type with the `+` chomping indicator.
-     */
-    stringify?: (item: Scalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void) => string;
-    /**
-     * Together with `default` allows for values to be stringified without an
-     * explicit tag and detected using a regular expression. For most cases, it's
-     * unlikely that you'll actually want to use these, even if you first think
-     * you do.
-     */
-    test?: RegExp;
-}
-export interface CollectionTag extends TagBase {
-    stringify?: never;
-    test?: never;
-    /** The source collection type supported by this tag. */
-    collection: 'map' | 'seq';
-    /**
-     * The `Node` child class that implements this tag.
-     * If set, used to select this tag when stringifying.
-     *
-     * If the class provides a static `from` method, then that
-     * will be used if the tag object doesn't have a `createNode` method.
-     */
-    nodeClass?: {
-        new (schema?: Schema): Node;
-        from?: (schema: Schema, obj: unknown, ctx: CreateNodeContext) => Node;
-    };
-    /**
-     * Turns a value into an AST node.
-     * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
-     *
-     * Note: this is required if nodeClass is not provided.
-     */
-    resolve?: (value: YAMLMap.Parsed | YAMLSeq.Parsed, onError: (message: string) => void, options: ParseOptions) => unknown;
-}
-export {};

package/node_modules/yaml/dist/schema/yaml-1.1/binary.d.ts

@@ -1,2 +0,0 @@
-import type { ScalarTag } from '../types';
-export declare const binary: ScalarTag;

package/node_modules/yaml/dist/schema/yaml-1.1/binary.js

@@ -1,70 +0,0 @@
-'use strict';
-
-var node_buffer = require('buffer');
-var Scalar = require('../../nodes/Scalar.js');
-var stringifyString = require('../../stringify/stringifyString.js');
-
-const binary = {
-    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array
-    default: false,
-    tag: 'tag:yaml.org,2002:binary',
-    /**
-     * Returns a Buffer in node and an Uint8Array in browsers
-     *
-     * To use the resulting buffer as an image, you'll want to do something like:
-     *
-     *   const blob = new Blob([buffer], { type: 'image/jpeg' })
-     *   document.querySelector('#photo').src = URL.createObjectURL(blob)
-     */
-    resolve(src, onError) {
-        if (typeof node_buffer.Buffer === 'function') {
-            return node_buffer.Buffer.from(src, 'base64');
-        }
-        else if (typeof atob === 'function') {
-            // On IE 11, atob() can't handle newlines
-            const str = atob(src.replace(/[\n\r]/g, ''));
-            const buffer = new Uint8Array(str.length);
-            for (let i = 0; i < str.length; ++i)
-                buffer[i] = str.charCodeAt(i);
-            return buffer;
-        }
-        else {
-            onError('This environment does not support reading binary tags; either Buffer or atob is required');
-            return src;
-        }
-    },
-    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
-        if (!value)
-            return '';
-        const buf = value; // checked earlier by binary.identify()
-        let str;
-        if (typeof node_buffer.Buffer === 'function') {
-            str =
-                buf instanceof node_buffer.Buffer
-                    ? buf.toString('base64')
-                    : node_buffer.Buffer.from(buf.buffer).toString('base64');
-        }
-        else if (typeof btoa === 'function') {
-            let s = '';
-            for (let i = 0; i < buf.length; ++i)
-                s += String.fromCharCode(buf[i]);
-            str = btoa(s);
-        }
-        else {
-            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
-        }
-        type ?? (type = Scalar.Scalar.BLOCK_LITERAL);
-        if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
-            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
-            const n = Math.ceil(str.length / lineWidth);
-            const lines = new Array(n);
-            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
-                lines[i] = str.substr(o, lineWidth);
-            }
-            str = lines.join(type === Scalar.Scalar.BLOCK_LITERAL ? '\n' : ' ');
-        }
-        return stringifyString.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);
-    }
-};
-
-exports.binary = binary;

package/node_modules/yaml/dist/schema/yaml-1.1/bool.d.ts

@@ -1,7 +0,0 @@
-import type { ScalarTag } from '../types';
-export declare const trueTag: ScalarTag & {
-    test: RegExp;
-};
-export declare const falseTag: ScalarTag & {
-    test: RegExp;
-};

package/node_modules/yaml/dist/schema/yaml-1.1/bool.js

@@ -1,29 +0,0 @@
-'use strict';
-
-var Scalar = require('../../nodes/Scalar.js');
-
-function boolStringify({ value, source }, ctx) {
-    const boolObj = value ? trueTag : falseTag;
-    if (source && boolObj.test.test(source))
-        return source;
-    return value ? ctx.options.trueStr : ctx.options.falseStr;
-}
-const trueTag = {
-    identify: value => value === true,
-    default: true,
-    tag: 'tag:yaml.org,2002:bool',
-    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
-    resolve: () => new Scalar.Scalar(true),
-    stringify: boolStringify
-};
-const falseTag = {
-    identify: value => value === false,
-    default: true,
-    tag: 'tag:yaml.org,2002:bool',
-    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
-    resolve: () => new Scalar.Scalar(false),
-    stringify: boolStringify
-};
-
-exports.falseTag = falseTag;
-exports.trueTag = trueTag;

package/node_modules/yaml/dist/schema/yaml-1.1/float.d.ts

@@ -1,4 +0,0 @@
-import type { ScalarTag } from '../types';
-export declare const floatNaN: ScalarTag;
-export declare const floatExp: ScalarTag;
-export declare const float: ScalarTag;

package/node_modules/yaml/dist/schema/yaml-1.1/float.js

@@ -1,50 +0,0 @@
-'use strict';
-
-var Scalar = require('../../nodes/Scalar.js');
-var stringifyNumber = require('../../stringify/stringifyNumber.js');
-
-const floatNaN = {
-    identify: value => typeof value === 'number',
-    default: true,
-    tag: 'tag:yaml.org,2002:float',
-    test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
-    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'
-        ? NaN
-        : str[0] === '-'
-            ? Number.NEGATIVE_INFINITY
-            : Number.POSITIVE_INFINITY,
-    stringify: stringifyNumber.stringifyNumber
-};
-const floatExp = {
-    identify: value => typeof value === 'number',
-    default: true,
-    tag: 'tag:yaml.org,2002:float',
-    format: 'EXP',
-    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
-    resolve: (str) => parseFloat(str.replace(/_/g, '')),
-    stringify(node) {
-        const num = Number(node.value);
-        return isFinite(num) ? num.toExponential() : stringifyNumber.stringifyNumber(node);
-    }
-};
-const float = {
-    identify: value => typeof value === 'number',
-    default: true,
-    tag: 'tag:yaml.org,2002:float',
-    test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
-    resolve(str) {
-        const node = new Scalar.Scalar(parseFloat(str.replace(/_/g, '')));
-        const dot = str.indexOf('.');
-        if (dot !== -1) {
-            const f = str.substring(dot + 1).replace(/_/g, '');
-            if (f[f.length - 1] === '0')
-                node.minFractionDigits = f.length;
-        }
-        return node;
-    },
-    stringify: stringifyNumber.stringifyNumber
-};
-
-exports.float = float;
-exports.floatExp = floatExp;
-exports.floatNaN = floatNaN;

package/node_modules/yaml/dist/schema/yaml-1.1/int.d.ts

@@ -1,5 +0,0 @@
-import type { ScalarTag } from '../types';
-export declare const intBin: ScalarTag;
-export declare const intOct: ScalarTag;
-export declare const int: ScalarTag;
-export declare const intHex: ScalarTag;

package/node_modules/yaml/dist/schema/yaml-1.1/int.js

@@ -1,76 +0,0 @@
-'use strict';
-
-var stringifyNumber = require('../../stringify/stringifyNumber.js');
-
-const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
-function intResolve(str, offset, radix, { intAsBigInt }) {
-    const sign = str[0];
-    if (sign === '-' || sign === '+')
-        offset += 1;
-    str = str.substring(offset).replace(/_/g, '');
-    if (intAsBigInt) {
-        switch (radix) {
-            case 2:
-                str = `0b${str}`;
-                break;
-            case 8:
-                str = `0o${str}`;
-                break;
-            case 16:
-                str = `0x${str}`;
-                break;
-        }
-        const n = BigInt(str);
-        return sign === '-' ? BigInt(-1) * n : n;
-    }
-    const n = parseInt(str, radix);
-    return sign === '-' ? -1 * n : n;
-}
-function intStringify(node, radix, prefix) {
-    const { value } = node;
-    if (intIdentify(value)) {
-        const str = value.toString(radix);
-        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
-    }
-    return stringifyNumber.stringifyNumber(node);
-}
-const intBin = {
-    identify: intIdentify,
-    default: true,
-    tag: 'tag:yaml.org,2002:int',
-    format: 'BIN',
-    test: /^[-+]?0b[0-1_]+$/,
-    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
-    stringify: node => intStringify(node, 2, '0b')
-};
-const intOct = {
-    identify: intIdentify,
-    default: true,
-    tag: 'tag:yaml.org,2002:int',
-    format: 'OCT',
-    test: /^[-+]?0[0-7_]+$/,
-    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
-    stringify: node => intStringify(node, 8, '0')
-};
-const int = {
-    identify: intIdentify,
-    default: true,
-    tag: 'tag:yaml.org,2002:int',
-    test: /^[-+]?[0-9][0-9_]*$/,
-    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
-    stringify: stringifyNumber.stringifyNumber
-};
-const intHex = {
-    identify: intIdentify,
-    default: true,
-    tag: 'tag:yaml.org,2002:int',
-    format: 'HEX',
-    test: /^[-+]?0x[0-9a-fA-F_]+$/,
-    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
-    stringify: node => intStringify(node, 16, '0x')
-};
-
-exports.int = int;
-exports.intBin = intBin;
-exports.intHex = intHex;
-exports.intOct = intOct;

package/node_modules/yaml/dist/schema/yaml-1.1/merge.d.ts

@@ -1,9 +0,0 @@
-import type { ToJSContext } from '../../nodes/toJS';
-import type { MapLike } from '../../nodes/YAMLMap';
-import type { ScalarTag } from '../types';
-export declare const merge: ScalarTag & {
-    identify(value: unknown): boolean;
-    test: RegExp;
-};
-export declare const isMergeKey: (ctx: ToJSContext | undefined, key: unknown) => boolean | undefined;
-export declare function addMergeToJSMap(ctx: ToJSContext | undefined, map: MapLike, value: unknown): void;

package/node_modules/yaml/dist/schema/yaml-1.1/merge.js

@@ -1,71 +0,0 @@
-'use strict';
-
-var identity = require('../../nodes/identity.js');
-var Scalar = require('../../nodes/Scalar.js');
-
-// If the value associated with a merge key is a single mapping node, each of
-// its key/value pairs is inserted into the current mapping, unless the key
-// already exists in it. If the value associated with the merge key is a
-// sequence, then this sequence is expected to contain mapping nodes and each
-// of these nodes is merged in turn according to its order in the sequence.
-// Keys in mapping nodes earlier in the sequence override keys specified in
-// later mapping nodes. -- http://yaml.org/type/merge.html
-const MERGE_KEY = '<<';
-const merge = {
-    identify: value => value === MERGE_KEY ||
-        (typeof value === 'symbol' && value.description === MERGE_KEY),
-    default: 'key',
-    tag: 'tag:yaml.org,2002:merge',
-    test: /^<<$/,
-    resolve: () => Object.assign(new Scalar.Scalar(Symbol(MERGE_KEY)), {
-        addToJSMap: addMergeToJSMap
-    }),
-    stringify: () => MERGE_KEY
-};
-const isMergeKey = (ctx, key) => (merge.identify(key) ||
-    (identity.isScalar(key) &&
-        (!key.type || key.type === Scalar.Scalar.PLAIN) &&
-        merge.identify(key.value))) &&
-    ctx?.doc.schema.tags.some(tag => tag.tag === merge.tag && tag.default);
-function addMergeToJSMap(ctx, map, value) {
-    const source = resolveAliasValue(ctx, value);
-    if (identity.isSeq(source))
-        for (const it of source.items)
-            mergeValue(ctx, map, it);
-    else if (Array.isArray(source))
-        for (const it of source)
-            mergeValue(ctx, map, it);
-    else
-        mergeValue(ctx, map, source);
-}
-function mergeValue(ctx, map, value) {
-    const source = resolveAliasValue(ctx, value);
-    if (!identity.isMap(source))
-        throw new Error('Merge sources must be maps or map aliases');
-    const srcMap = source.toJSON(null, ctx, Map);
-    for (const [key, value] of srcMap) {
-        if (map instanceof Map) {
-            if (!map.has(key))
-                map.set(key, value);
-        }
-        else if (map instanceof Set) {
-            map.add(key);
-        }
-        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
-            Object.defineProperty(map, key, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        }
-    }
-    return map;
-}
-function resolveAliasValue(ctx, value) {
-    return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
-}
-
-exports.addMergeToJSMap = addMergeToJSMap;
-exports.isMergeKey = isMergeKey;
-exports.merge = merge;

package/node_modules/yaml/dist/schema/yaml-1.1/omap.d.ts

@@ -1,22 +0,0 @@
-import type { ToJSContext } from '../../nodes/toJS';
-import { YAMLMap } from '../../nodes/YAMLMap';
-import { YAMLSeq } from '../../nodes/YAMLSeq';
-import type { CreateNodeContext } from '../../util';
-import type { Schema } from '../Schema';
-import type { CollectionTag } from '../types';
-export declare class YAMLOMap extends YAMLSeq {
-    static tag: string;
-    constructor();
-    add: typeof YAMLMap.prototype.add;
-    delete: typeof YAMLMap.prototype.delete;
-    get: typeof YAMLMap.prototype.get;
-    has: typeof YAMLMap.prototype.has;
-    set: typeof YAMLMap.prototype.set;
-    /**
-     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
-     * but TypeScript won't allow widening the signature of a child method.
-     */
-    toJSON(_?: unknown, ctx?: ToJSContext): unknown[];
-    static from(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLOMap;
-}
-export declare const omap: CollectionTag;

package/node_modules/yaml/dist/schema/yaml-1.1/omap.js

@@ -1,77 +0,0 @@
-'use strict';
-
-var identity = require('../../nodes/identity.js');
-var toJS = require('../../nodes/toJS.js');
-var YAMLMap = require('../../nodes/YAMLMap.js');
-var YAMLSeq = require('../../nodes/YAMLSeq.js');
-var pairs = require('./pairs.js');
-
-class YAMLOMap extends YAMLSeq.YAMLSeq {
-    constructor() {
-        super();
-        this.add = YAMLMap.YAMLMap.prototype.add.bind(this);
-        this.delete = YAMLMap.YAMLMap.prototype.delete.bind(this);
-        this.get = YAMLMap.YAMLMap.prototype.get.bind(this);
-        this.has = YAMLMap.YAMLMap.prototype.has.bind(this);
-        this.set = YAMLMap.YAMLMap.prototype.set.bind(this);
-        this.tag = YAMLOMap.tag;
-    }
-    /**
-     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
-     * but TypeScript won't allow widening the signature of a child method.
-     */
-    toJSON(_, ctx) {
-        if (!ctx)
-            return super.toJSON(_);
-        const map = new Map();
-        if (ctx?.onCreate)
-            ctx.onCreate(map);
-        for (const pair of this.items) {
-            let key, value;
-            if (identity.isPair(pair)) {
-                key = toJS.toJS(pair.key, '', ctx);
-                value = toJS.toJS(pair.value, key, ctx);
-            }
-            else {
-                key = toJS.toJS(pair, '', ctx);
-            }
-            if (map.has(key))
-                throw new Error('Ordered maps must not include duplicate keys');
-            map.set(key, value);
-        }
-        return map;
-    }
-    static from(schema, iterable, ctx) {
-        const pairs$1 = pairs.createPairs(schema, iterable, ctx);
-        const omap = new this();
-        omap.items = pairs$1.items;
-        return omap;
-    }
-}
-YAMLOMap.tag = 'tag:yaml.org,2002:omap';
-const omap = {
-    collection: 'seq',
-    identify: value => value instanceof Map,
-    nodeClass: YAMLOMap,
-    default: false,
-    tag: 'tag:yaml.org,2002:omap',
-    resolve(seq, onError) {
-        const pairs$1 = pairs.resolvePairs(seq, onError);
-        const seenKeys = [];
-        for (const { key } of pairs$1.items) {
-            if (identity.isScalar(key)) {
-                if (seenKeys.includes(key.value)) {
-                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);
-                }
-                else {
-                    seenKeys.push(key.value);
-                }
-            }
-        }
-        return Object.assign(new YAMLOMap(), pairs$1);
-    },
-    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
-};
-
-exports.YAMLOMap = YAMLOMap;
-exports.omap = omap;

package/node_modules/yaml/dist/schema/yaml-1.1/pairs.d.ts

@@ -1,10 +0,0 @@
-import type { CreateNodeContext } from '../../doc/createNode';
-import type { ParsedNode } from '../../nodes/Node';
-import { Pair } from '../../nodes/Pair';
-import type { YAMLMap } from '../../nodes/YAMLMap';
-import { YAMLSeq } from '../../nodes/YAMLSeq';
-import type { Schema } from '../../schema/Schema';
-import type { CollectionTag } from '../types';
-export declare function resolvePairs(seq: YAMLSeq.Parsed<ParsedNode | Pair<ParsedNode, ParsedNode | null>> | YAMLMap.Parsed, onError: (message: string) => void): YAMLSeq.Parsed<Pair<ParsedNode, ParsedNode | null>>;
-export declare function createPairs(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLSeq<unknown>;
-export declare const pairs: CollectionTag;