@quilted/create 0.1.56 → 0.1.58

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/public-api.esnext

@@ -0,0 +1,117 @@
+import { __exports as publicApi } from '../../../../../../_virtual/public-api.esnext';
+export { __exports as default } from '../../../../../../_virtual/public-api.esnext';
+import './compose/composer.esnext';
+import './doc/Document.esnext';
+import './errors.esnext';
+import './log.esnext';
+import './parse/line-counter.esnext';
+import './parse/parser.esnext';
+import { __exports as composer$1 } from '../../../../../../_virtual/composer.esnext';
+import { __exports as Document$1 } from '../../../../../../_virtual/Document.esnext';
+import { __exports as errors$1 } from '../../../../../../_virtual/errors.esnext';
+import { __exports as log$1 } from '../../../../../../_virtual/log.esnext';
+import { __exports as parser$1 } from '../../../../../../_virtual/parser.esnext';
+import { __exports as lineCounter$1 } from '../../../../../../_virtual/line-counter.esnext';
+
+var composer = composer$1;
+var Document = Document$1;
+var errors = errors$1;
+var log = log$1;
+var lineCounter = lineCounter$1;
+var parser = parser$1;
+
+function parseOptions(options) {
+    const prettyErrors = options.prettyErrors !== false;
+    const lineCounter$1 = options.lineCounter || (prettyErrors && new lineCounter.LineCounter()) || null;
+    return { lineCounter: lineCounter$1, prettyErrors };
+}
+/**
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ *
+ * @returns If an empty `docs` array is returned, it will be of type
+ *   EmptyStream and contain additional stream information. In
+ *   TypeScript, you should use `'empty' in docs` as a type guard for it.
+ */
+function parseAllDocuments(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser$1 = new parser.Parser(lineCounter?.addNewLine);
+    const composer$1 = new composer.Composer(options);
+    const docs = Array.from(composer$1.compose(parser$1.parse(source)));
+    if (prettyErrors && lineCounter)
+        for (const doc of docs) {
+            doc.errors.forEach(errors.prettifyError(source, lineCounter));
+            doc.warnings.forEach(errors.prettifyError(source, lineCounter));
+        }
+    if (docs.length > 0)
+        return docs;
+    return Object.assign([], { empty: true }, composer$1.streamInfo());
+}
+/** Parse an input string into a single YAML.Document */
+function parseDocument(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser$1 = new parser.Parser(lineCounter?.addNewLine);
+    const composer$1 = new composer.Composer(options);
+    // `doc` is always set by compose.end(true) at the very latest
+    let doc = null;
+    for (const _doc of composer$1.compose(parser$1.parse(source), true, source.length)) {
+        if (!doc)
+            doc = _doc;
+        else if (doc.options.logLevel !== 'silent') {
+            doc.errors.push(new errors.YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            break;
+        }
+    }
+    if (prettyErrors && lineCounter) {
+        doc.errors.forEach(errors.prettifyError(source, lineCounter));
+        doc.warnings.forEach(errors.prettifyError(source, lineCounter));
+    }
+    return doc;
+}
+function parse(src, reviver, options) {
+    let _reviver = undefined;
+    if (typeof reviver === 'function') {
+        _reviver = reviver;
+    }
+    else if (options === undefined && reviver && typeof reviver === 'object') {
+        options = reviver;
+    }
+    const doc = parseDocument(src, options);
+    if (!doc)
+        return null;
+    doc.warnings.forEach(warning => log.warn(doc.options.logLevel, warning));
+    if (doc.errors.length > 0) {
+        if (doc.options.logLevel !== 'silent')
+            throw doc.errors[0];
+        else
+            doc.errors = [];
+    }
+    return doc.toJS(Object.assign({ reviver: _reviver }, options));
+}
+function stringify(value, replacer, options) {
+    let _replacer = null;
+    if (typeof replacer === 'function' || Array.isArray(replacer)) {
+        _replacer = replacer;
+    }
+    else if (options === undefined && replacer) {
+        options = replacer;
+    }
+    if (typeof options === 'string')
+        options = options.length;
+    if (typeof options === 'number') {
+        const indent = Math.round(options);
+        options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };
+    }
+    if (value === undefined) {
+        const { keepUndefined } = options ?? replacer ?? {};
+        if (!keepUndefined)
+            return undefined;
+    }
+    return new Document.Document(value, _replacer, options).toString(options);
+}
+
+publicApi.parse = parse;
+publicApi.parseAllDocuments = parseAllDocuments;
+publicApi.parseDocument = parseDocument;
+publicApi.stringify = stringify;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/Schema.esnext

@@ -0,0 +1,51 @@
+import { __exports as Schema$1 } from '../../../../../../../_virtual/Schema.esnext';
+export { __exports as default } from '../../../../../../../_virtual/Schema.esnext';
+import '../nodes/Node.esnext';
+import './common/map.esnext';
+import './common/seq.esnext';
+import './common/string.esnext';
+import './tags.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+import { __exports as map$1 } from '../../../../../../../_virtual/map.esnext';
+import { __exports as seq$1 } from '../../../../../../../_virtual/seq.esnext';
+import { __exports as string$1 } from '../../../../../../../_virtual/string.esnext';
+import { __exports as tags$1 } from '../../../../../../../_virtual/tags.esnext';
+
+var Node = Node$1;
+var map = map$1;
+var seq = seq$1;
+var string = string$1;
+var tags = tags$1;
+
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+class Schema {
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+        this.compat = Array.isArray(compat)
+            ? tags.getTags(compat, 'compat')
+            : compat
+                ? tags.getTags(null, compat)
+                : null;
+        this.merge = !!merge;
+        this.name = (typeof schema === 'string' && schema) || 'core';
+        this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
+        this.tags = tags.getTags(customTags, this.name);
+        this.toStringOptions = toStringDefaults ?? null;
+        Object.defineProperty(this, Node.MAP, { value: map.map });
+        Object.defineProperty(this, Node.SCALAR, { value: string.string });
+        Object.defineProperty(this, Node.SEQ, { value: seq.seq });
+        // Used by createMap()
+        this.sortMapEntries =
+            typeof sortMapEntries === 'function'
+                ? sortMapEntries
+                : sortMapEntries === true
+                    ? sortMapEntriesByKey
+                    : null;
+    }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
+    }
+}
+
+Schema$1.Schema = Schema;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/common/map.esnext

@@ -0,0 +1,51 @@
+import { __exports as map$1 } from '../../../../../../../../_virtual/map.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/map.esnext';
+import '../../nodes/Node.esnext';
+import '../../nodes/Pair.esnext';
+import '../../nodes/YAMLMap.esnext';
+import { __exports as Node$1 } from '../../../../../../../../_virtual/Node.esnext';
+import { __exports as YAMLMap$1 } from '../../../../../../../../_virtual/YAMLMap.esnext';
+import { __exports as Pair$1 } from '../../../../../../../../_virtual/Pair.esnext';
+
+var Node = Node$1;
+var Pair = Pair$1;
+var YAMLMap = YAMLMap$1;
+
+function createMap(schema, obj, ctx) {
+    const { keepUndefined, replacer } = ctx;
+    const map = new YAMLMap.YAMLMap(schema);
+    const add = (key, value) => {
+        if (typeof replacer === 'function')
+            value = replacer.call(obj, key, value);
+        else if (Array.isArray(replacer) && !replacer.includes(key))
+            return;
+        if (value !== undefined || keepUndefined)
+            map.items.push(Pair.createPair(key, value, ctx));
+    };
+    if (obj instanceof Map) {
+        for (const [key, value] of obj)
+            add(key, value);
+    }
+    else if (obj && typeof obj === 'object') {
+        for (const key of Object.keys(obj))
+            add(key, obj[key]);
+    }
+    if (typeof schema.sortMapEntries === 'function') {
+        map.items.sort(schema.sortMapEntries);
+    }
+    return map;
+}
+const map = {
+    collection: 'map',
+    createNode: createMap,
+    default: true,
+    nodeClass: YAMLMap.YAMLMap,
+    tag: 'tag:yaml.org,2002:map',
+    resolve(map, onError) {
+        if (!Node.isMap(map))
+            onError('Expected a mapping for this tag');
+        return map;
+    }
+};
+
+map$1.map = map;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/common/null.esnext

@@ -0,0 +1,20 @@
+import { __exports as _null } from '../../../../../../../../_virtual/null.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/null.esnext';
+import '../../nodes/Scalar.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../../_virtual/Scalar.esnext';
+
+var Scalar = Scalar$1;
+
+const nullTag = {
+    identify: value => value == null,
+    createNode: () => new Scalar.Scalar(null),
+    default: true,
+    tag: 'tag:yaml.org,2002:null',
+    test: /^(?:~|[Nn]ull|NULL)?$/,
+    resolve: () => new Scalar.Scalar(null),
+    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)
+        ? source
+        : ctx.options.nullStr
+};
+
+_null.nullTag = nullTag;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/common/seq.esnext

@@ -0,0 +1,42 @@
+import { __exports as seq$1 } from '../../../../../../../../_virtual/seq.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/seq.esnext';
+import '../../doc/createNode.esnext';
+import '../../nodes/Node.esnext';
+import '../../nodes/YAMLSeq.esnext';
+import { __exports as Node$1 } from '../../../../../../../../_virtual/Node.esnext';
+import { __exports as YAMLSeq$1 } from '../../../../../../../../_virtual/YAMLSeq.esnext';
+import { __exports as createNode$1 } from '../../../../../../../../_virtual/createNode.esnext';
+
+var createNode = createNode$1;
+var Node = Node$1;
+var YAMLSeq = YAMLSeq$1;
+
+function createSeq(schema, obj, ctx) {
+    const { replacer } = ctx;
+    const seq = new YAMLSeq.YAMLSeq(schema);
+    if (obj && Symbol.iterator in Object(obj)) {
+        let i = 0;
+        for (let it of obj) {
+            if (typeof replacer === 'function') {
+                const key = obj instanceof Set ? it : String(i++);
+                it = replacer.call(obj, key, it);
+            }
+            seq.items.push(createNode.createNode(it, undefined, ctx));
+        }
+    }
+    return seq;
+}
+const seq = {
+    collection: 'seq',
+    createNode: createSeq,
+    default: true,
+    nodeClass: YAMLSeq.YAMLSeq,
+    tag: 'tag:yaml.org,2002:seq',
+    resolve(seq, onError) {
+        if (!Node.isSeq(seq))
+            onError('Expected a sequence for this tag');
+        return seq;
+    }
+};
+
+seq$1.seq = seq;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/common/string.esnext

@@ -0,0 +1,19 @@
+import { __exports as string$1 } from '../../../../../../../../_virtual/string.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/string.esnext';
+import '../../stringify/stringifyString.esnext';
+import { __exports as stringifyString$1 } from '../../../../../../../../_virtual/stringifyString.esnext';
+
+var stringifyString = stringifyString$1;
+
+const string = {
+    identify: value => typeof value === 'string',
+    default: true,
+    tag: 'tag:yaml.org,2002:str',
+    resolve: str => str,
+    stringify(item, ctx, onComment, onChompKeep) {
+        ctx = Object.assign({ actualString: true }, ctx);
+        return stringifyString.stringifyString(item, ctx, onComment, onChompKeep);
+    }
+};
+
+string$1.string = string;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/core/bool.esnext

@@ -0,0 +1,24 @@
+import { __exports as bool } from '../../../../../../../../_virtual/bool.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/bool.esnext';
+import '../../nodes/Scalar.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../../_virtual/Scalar.esnext';
+
+var Scalar = Scalar$1;
+
+const boolTag = {
+    identify: value => typeof value === 'boolean',
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+    resolve: str => new Scalar.Scalar(str[0] === 't' || str[0] === 'T'),
+    stringify({ source, value }, ctx) {
+        if (source && boolTag.test.test(source)) {
+            const sv = source[0] === 't' || source[0] === 'T';
+            if (value === sv)
+                return source;
+        }
+        return value ? ctx.options.trueStr : ctx.options.falseStr;
+    }
+};
+
+bool.boolTag = boolTag;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/core/float.esnext

@@ -0,0 +1,52 @@
+import { __exports as float$1 } from '../../../../../../../../_virtual/float.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/float.esnext';
+import '../../nodes/Scalar.esnext';
+import '../../stringify/stringifyNumber.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../../_virtual/Scalar.esnext';
+import { __exports as stringifyNumber$1 } from '../../../../../../../../_virtual/stringifyNumber.esnext';
+
+var Scalar = Scalar$1;
+var stringifyNumber = stringifyNumber$1;
+
+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),
+    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));
+        const dot = str.indexOf('.');
+        if (dot !== -1 && str[str.length - 1] === '0')
+            node.minFractionDigits = str.length - dot - 1;
+        return node;
+    },
+    stringify: stringifyNumber.stringifyNumber
+};
+
+float$1.float = float;
+float$1.floatExp = floatExp;
+float$1.floatNaN = floatNaN;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/core/int.esnext

@@ -0,0 +1,45 @@
+import { __exports as int$1 } from '../../../../../../../../_virtual/int.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/int.esnext';
+import '../../stringify/stringifyNumber.esnext';
+import { __exports as stringifyNumber$1 } from '../../../../../../../../_virtual/stringifyNumber.esnext';
+
+var stringifyNumber = stringifyNumber$1;
+
+const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
+const intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));
+function intStringify(node, radix, prefix) {
+    const { value } = node;
+    if (intIdentify(value) && value >= 0)
+        return prefix + value.toString(radix);
+    return stringifyNumber.stringifyNumber(node);
+}
+const intOct = {
+    identify: value => intIdentify(value) && value >= 0,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'OCT',
+    test: /^0o[0-7]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
+    stringify: node => intStringify(node, 8, '0o')
+};
+const int = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    test: /^[-+]?[0-9]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+    stringify: stringifyNumber.stringifyNumber
+};
+const intHex = {
+    identify: value => intIdentify(value) && value >= 0,
+    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')
+};
+
+int$1.int = int;
+int$1.intHex = intHex;
+int$1.intOct = intOct;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/core/schema.esnext

@@ -0,0 +1,40 @@
+import { __exports as schema$1 } from '../../../../../../../../_virtual/schema2.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/schema2.esnext';
+import '../common/map.esnext';
+import '../common/null.esnext';
+import '../common/seq.esnext';
+import '../common/string.esnext';
+import './bool.esnext';
+import './float.esnext';
+import './int.esnext';
+import { __exports as map$1 } from '../../../../../../../../_virtual/map.esnext';
+import { __exports as _null$1 } from '../../../../../../../../_virtual/null.esnext';
+import { __exports as seq$1 } from '../../../../../../../../_virtual/seq.esnext';
+import { __exports as string$1 } from '../../../../../../../../_virtual/string.esnext';
+import { __exports as bool$1 } from '../../../../../../../../_virtual/bool.esnext';
+import { __exports as float$1 } from '../../../../../../../../_virtual/float.esnext';
+import { __exports as int$1 } from '../../../../../../../../_virtual/int.esnext';
+
+var map = map$1;
+var _null = _null$1;
+var seq = seq$1;
+var string = string$1;
+var bool = bool$1;
+var float = float$1;
+var int = int$1;
+
+const schema = [
+    map.map,
+    seq.seq,
+    string.string,
+    _null.nullTag,
+    bool.boolTag,
+    int.intOct,
+    int.int,
+    int.intHex,
+    float.floatNaN,
+    float.floatExp,
+    float.float
+];
+
+schema$1.schema = schema;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/json/schema.esnext

@@ -0,0 +1,71 @@
+import { __exports as schema$1 } from '../../../../../../../../_virtual/schema3.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/schema3.esnext';
+import '../../nodes/Scalar.esnext';
+import '../common/map.esnext';
+import '../common/seq.esnext';
+import { __exports as map$1 } from '../../../../../../../../_virtual/map.esnext';
+import { __exports as seq$1 } from '../../../../../../../../_virtual/seq.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../../_virtual/Scalar.esnext';
+
+var Scalar = Scalar$1;
+var map = map$1;
+var seq = seq$1;
+
+function intIdentify(value) {
+    return typeof value === 'bigint' || Number.isInteger(value);
+}
+const stringifyJSON = ({ value }) => JSON.stringify(value);
+const jsonScalars = [
+    {
+        identify: value => typeof value === 'string',
+        default: true,
+        tag: 'tag:yaml.org,2002:str',
+        resolve: str => str,
+        stringify: stringifyJSON
+    },
+    {
+        identify: value => value == null,
+        createNode: () => new Scalar.Scalar(null),
+        default: true,
+        tag: 'tag:yaml.org,2002:null',
+        test: /^null$/,
+        resolve: () => null,
+        stringify: stringifyJSON
+    },
+    {
+        identify: value => typeof value === 'boolean',
+        default: true,
+        tag: 'tag:yaml.org,2002:bool',
+        test: /^true|false$/,
+        resolve: str => str === 'true',
+        stringify: stringifyJSON
+    },
+    {
+        identify: intIdentify,
+        default: true,
+        tag: 'tag:yaml.org,2002:int',
+        test: /^-?(?:0|[1-9][0-9]*)$/,
+        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+        stringify: ({ value }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
+    },
+    {
+        identify: value => typeof value === 'number',
+        default: true,
+        tag: 'tag:yaml.org,2002:float',
+        test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+        resolve: str => parseFloat(str),
+        stringify: stringifyJSON
+    }
+];
+const jsonError = {
+    default: true,
+    tag: '',
+    test: /^/,
+    resolve(str, onError) {
+        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+        return str;
+    }
+};
+const schema = [map.map, seq.seq].concat(jsonScalars, jsonError);
+
+schema$1.schema = schema;

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/schema/tags.esnext

@@ -0,0 +1,117 @@
+import { __exports as tags } from '../../../../../../../_virtual/tags.esnext';
+export { __exports as default } from '../../../../../../../_virtual/tags.esnext';
+import './common/map.esnext';
+import './common/null.esnext';
+import './common/seq.esnext';
+import './common/string.esnext';
+import './core/bool.esnext';
+import './core/float.esnext';
+import './core/int.esnext';
+import './core/schema.esnext';
+import './json/schema.esnext';
+import './yaml-1.1/binary.esnext';
+import './yaml-1.1/omap.esnext';
+import './yaml-1.1/pairs.esnext';
+import './yaml-1.1/schema.esnext';
+import './yaml-1.1/set.esnext';
+import './yaml-1.1/timestamp.esnext';
+import { __exports as binary$1 } from '../../../../../../../_virtual/binary.esnext';
+import { __exports as omap$1 } from '../../../../../../../_virtual/omap.esnext';
+import { __exports as pairs$1 } from '../../../../../../../_virtual/pairs.esnext';
+import { __exports as set$1 } from '../../../../../../../_virtual/set.esnext';
+import { __exports as timestamp$1 } from '../../../../../../../_virtual/timestamp.esnext';
+import { __exports as map$1 } from '../../../../../../../_virtual/map.esnext';
+import { __exports as _null$1 } from '../../../../../../../_virtual/null.esnext';
+import { __exports as seq$1 } from '../../../../../../../_virtual/seq.esnext';
+import { __exports as string$1 } from '../../../../../../../_virtual/string.esnext';
+import { __exports as bool$1 } from '../../../../../../../_virtual/bool.esnext';
+import { __exports as float$1 } from '../../../../../../../_virtual/float.esnext';
+import { __exports as int$1 } from '../../../../../../../_virtual/int.esnext';
+import { __exports as schema$3 } from '../../../../../../../_virtual/schema2.esnext';
+import { __exports as schema$4 } from '../../../../../../../_virtual/schema3.esnext';
+import { __exports as schema$5 } from '../../../../../../../_virtual/schema4.esnext';
+
+var map = map$1;
+var _null = _null$1;
+var seq = seq$1;
+var string = string$1;
+var bool = bool$1;
+var float = float$1;
+var int = int$1;
+var schema = schema$3;
+var schema$1 = schema$4;
+var binary = binary$1;
+var omap = omap$1;
+var pairs = pairs$1;
+var schema$2 = schema$5;
+var set = set$1;
+var timestamp = timestamp$1;
+
+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,
+    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: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) {
+    let tags = schemas.get(schemaName);
+    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());
+    }
+    return tags.map(tag => {
+        if (typeof tag !== 'string')
+            return tag;
+        const tagObj = tagsByName[tag];
+        if (tagObj)
+            return tagObj;
+        const keys = Object.keys(tagsByName)
+            .map(key => JSON.stringify(key))
+            .join(', ');
+        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
+    });
+}
+
+tags.coreKnownTags = coreKnownTags;
+tags.getTags = getTags;