From 3a04cb197f152f171fba679663a91a9bb61d710e Mon Sep 17 00:00:00 2001 From: Minteck Date: Fri, 21 Jan 2022 14:39:46 +0100 Subject: Add config management --- node_modules/yaml/browser/dist/Schema-e94716c8.js | 682 ++++++++++++++++++++++ 1 file changed, 682 insertions(+) create mode 100644 node_modules/yaml/browser/dist/Schema-e94716c8.js (limited to 'node_modules/yaml/browser/dist/Schema-e94716c8.js') diff --git a/node_modules/yaml/browser/dist/Schema-e94716c8.js b/node_modules/yaml/browser/dist/Schema-e94716c8.js new file mode 100644 index 0000000..f18527d --- /dev/null +++ b/node_modules/yaml/browser/dist/Schema-e94716c8.js @@ -0,0 +1,682 @@ +import { _ as _createForOfIteratorHelper, h as _slicedToArray, a as _typeof, b as _createClass, e as _defineProperty, c as _classCallCheck, d as defaultTagPrefix, n as defaultTags } from './PlainValue-b8036b75.js'; +import { d as YAMLMap, g as resolveMap, Y as YAMLSeq, h as resolveSeq, j as resolveString, c as stringifyString, s as strOptions, S as Scalar, n as nullOptions, a as boolOptions, i as intOptions, k as stringifyNumber, N as Node, A as Alias, P as Pair } from './resolveSeq-492ab440.js'; +import { b as binary, o as omap, p as pairs, s as set, i as intTime, f as floatTime, t as timestamp, a as warnOptionDeprecation } from './warnings-df54cb69.js'; + +function createMap(schema, obj, ctx) { + var map = new YAMLMap(schema); + + if (obj instanceof Map) { + var _iterator = _createForOfIteratorHelper(obj), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var _step$value = _slicedToArray(_step.value, 2), + key = _step$value[0], + value = _step$value[1]; + + map.items.push(schema.createPair(key, value, ctx)); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } else if (obj && _typeof(obj) === 'object') { + for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) { + var _key = _Object$keys[_i]; + map.items.push(schema.createPair(_key, obj[_key], ctx)); + } + } + + if (typeof schema.sortMapEntries === 'function') { + map.items.sort(schema.sortMapEntries); + } + + return map; +} + +var map = { + createNode: createMap, + default: true, + nodeClass: YAMLMap, + tag: 'tag:yaml.org,2002:map', + resolve: resolveMap +}; + +function createSeq(schema, obj, ctx) { + var seq = new YAMLSeq(schema); + + if (obj && obj[Symbol.iterator]) { + var _iterator = _createForOfIteratorHelper(obj), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var it = _step.value; + var v = schema.createNode(it, ctx.wrapScalars, null, ctx); + seq.items.push(v); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } + + return seq; +} + +var seq = { + createNode: createSeq, + default: true, + nodeClass: YAMLSeq, + tag: 'tag:yaml.org,2002:seq', + resolve: resolveSeq +}; + +var string = { + identify: function identify(value) { + return typeof value === 'string'; + }, + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: resolveString, + stringify: function stringify(item, ctx, onComment, onChompKeep) { + ctx = Object.assign({ + actualString: true + }, ctx); + return stringifyString(item, ctx, onComment, onChompKeep); + }, + options: strOptions +}; + +var failsafe = [map, seq, string]; + +/* global BigInt */ + +var intIdentify$2 = function intIdentify(value) { + return typeof value === 'bigint' || Number.isInteger(value); +}; + +var intResolve$1 = function intResolve(src, part, radix) { + return intOptions.asBigInt ? BigInt(src) : parseInt(part, radix); +}; + +function intStringify$1(node, radix, prefix) { + var value = node.value; + if (intIdentify$2(value) && value >= 0) return prefix + value.toString(radix); + return stringifyNumber(node); +} + +var nullObj = { + identify: function identify(value) { + return value == null; + }, + createNode: function createNode(schema, value, ctx) { + return ctx.wrapScalars ? new Scalar(null) : null; + }, + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: function resolve() { + return null; + }, + options: nullOptions, + stringify: function stringify() { + return nullOptions.nullStr; + } +}; +var boolObj = { + identify: function identify(value) { + return typeof value === 'boolean'; + }, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/, + resolve: function resolve(str) { + return str[0] === 't' || str[0] === 'T'; + }, + options: boolOptions, + stringify: function stringify(_ref) { + var value = _ref.value; + return value ? boolOptions.trueStr : boolOptions.falseStr; + } +}; +var octObj = { + identify: function identify(value) { + return intIdentify$2(value) && value >= 0; + }, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^0o([0-7]+)$/, + resolve: function resolve(str, oct) { + return intResolve$1(str, oct, 8); + }, + options: intOptions, + stringify: function stringify(node) { + return intStringify$1(node, 8, '0o'); + } +}; +var intObj = { + identify: intIdentify$2, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9]+$/, + resolve: function resolve(str) { + return intResolve$1(str, str, 10); + }, + options: intOptions, + stringify: stringifyNumber +}; +var hexObj = { + identify: function identify(value) { + return intIdentify$2(value) && value >= 0; + }, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^0x([0-9a-fA-F]+)$/, + resolve: function resolve(str, hex) { + return intResolve$1(str, hex, 16); + }, + options: intOptions, + stringify: function stringify(node) { + return intStringify$1(node, 16, '0x'); + } +}; +var nanObj = { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: function resolve(str, nan) { + return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY; + }, + stringify: stringifyNumber +}; +var expObj = { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/, + resolve: function resolve(str) { + return parseFloat(str); + }, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return Number(value).toExponential(); + } +}; +var floatObj = { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/, + resolve: function resolve(str, frac1, frac2) { + var frac = frac1 || frac2; + var node = new Scalar(parseFloat(str)); + if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length; + return node; + }, + stringify: stringifyNumber +}; +var core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]); + +/* global BigInt */ + +var intIdentify$1 = function intIdentify(value) { + return typeof value === 'bigint' || Number.isInteger(value); +}; + +var stringifyJSON = function stringifyJSON(_ref) { + var value = _ref.value; + return JSON.stringify(value); +}; + +var json = [map, seq, { + identify: function identify(value) { + return typeof value === 'string'; + }, + default: true, + tag: 'tag:yaml.org,2002:str', + resolve: resolveString, + stringify: stringifyJSON +}, { + identify: function identify(value) { + return value == null; + }, + createNode: function createNode(schema, value, ctx) { + return ctx.wrapScalars ? new Scalar(null) : null; + }, + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^null$/, + resolve: function resolve() { + return null; + }, + stringify: stringifyJSON +}, { + identify: function identify(value) { + return typeof value === 'boolean'; + }, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^true|false$/, + resolve: function resolve(str) { + return str === 'true'; + }, + stringify: stringifyJSON +}, { + identify: intIdentify$1, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: function resolve(str) { + return intOptions.asBigInt ? BigInt(str) : parseInt(str, 10); + }, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return intIdentify$1(value) ? value.toString() : JSON.stringify(value); + } +}, { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: function resolve(str) { + return parseFloat(str); + }, + stringify: stringifyJSON +}]; + +json.scalarFallback = function (str) { + throw new SyntaxError("Unresolved plain scalar ".concat(JSON.stringify(str))); +}; + +/* global BigInt */ + +var boolStringify = function boolStringify(_ref) { + var value = _ref.value; + return value ? boolOptions.trueStr : boolOptions.falseStr; +}; + +var intIdentify = function intIdentify(value) { + return typeof value === 'bigint' || Number.isInteger(value); +}; + +function intResolve(sign, src, radix) { + var str = src.replace(/_/g, ''); + + if (intOptions.asBigInt) { + switch (radix) { + case 2: + str = "0b".concat(str); + break; + + case 8: + str = "0o".concat(str); + break; + + case 16: + str = "0x".concat(str); + break; + } + + var _n = BigInt(str); + + return sign === '-' ? BigInt(-1) * _n : _n; + } + + var n = parseInt(str, radix); + return sign === '-' ? -1 * n : n; +} + +function intStringify(node, radix, prefix) { + var value = node.value; + + if (intIdentify(value)) { + var str = value.toString(radix); + return value < 0 ? '-' + prefix + str.substr(1) : prefix + str; + } + + return stringifyNumber(node); +} + +var yaml11 = failsafe.concat([{ + identify: function identify(value) { + return value == null; + }, + createNode: function createNode(schema, value, ctx) { + return ctx.wrapScalars ? new Scalar(null) : null; + }, + default: true, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|[Nn]ull|NULL)?$/, + resolve: function resolve() { + return null; + }, + options: nullOptions, + stringify: function stringify() { + return nullOptions.nullStr; + } +}, { + identify: function identify(value) { + return typeof value === 'boolean'; + }, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/, + resolve: function resolve() { + return true; + }, + options: boolOptions, + stringify: boolStringify +}, { + identify: function identify(value) { + return typeof value === 'boolean'; + }, + default: true, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i, + resolve: function resolve() { + return false; + }, + options: boolOptions, + stringify: boolStringify +}, { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'BIN', + test: /^([-+]?)0b([0-1_]+)$/, + resolve: function resolve(str, sign, bin) { + return intResolve(sign, bin, 2); + }, + stringify: function stringify(node) { + return intStringify(node, 2, '0b'); + } +}, { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'OCT', + test: /^([-+]?)0([0-7_]+)$/, + resolve: function resolve(str, sign, oct) { + return intResolve(sign, oct, 8); + }, + stringify: function stringify(node) { + return intStringify(node, 8, '0'); + } +}, { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + test: /^([-+]?)([0-9][0-9_]*)$/, + resolve: function resolve(str, sign, abs) { + return intResolve(sign, abs, 10); + }, + stringify: stringifyNumber +}, { + identify: intIdentify, + default: true, + tag: 'tag:yaml.org,2002:int', + format: 'HEX', + test: /^([-+]?)0x([0-9a-fA-F_]+)$/, + resolve: function resolve(str, sign, hex) { + return intResolve(sign, hex, 16); + }, + stringify: function stringify(node) { + return intStringify(node, 16, '0x'); + } +}, { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: function resolve(str, nan) { + return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY; + }, + stringify: stringifyNumber +}, { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + format: 'EXP', + test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/, + resolve: function resolve(str) { + return parseFloat(str.replace(/_/g, '')); + }, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return Number(value).toExponential(); + } +}, { + identify: function identify(value) { + return typeof value === 'number'; + }, + default: true, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/, + resolve: function resolve(str, frac) { + var node = new Scalar(parseFloat(str.replace(/_/g, ''))); + + if (frac) { + var f = frac.replace(/_/g, ''); + if (f[f.length - 1] === '0') node.minFractionDigits = f.length; + } + + return node; + }, + stringify: stringifyNumber +}], binary, omap, pairs, set, intTime, floatTime, timestamp); + +var schemas = { + core: core, + failsafe: failsafe, + json: json, + yaml11: yaml11 +}; +var tags = { + binary: binary, + bool: boolObj, + float: floatObj, + floatExp: expObj, + floatNaN: nanObj, + floatTime: floatTime, + int: intObj, + intHex: hexObj, + intOct: octObj, + intTime: intTime, + map: map, + null: nullObj, + omap: omap, + pairs: pairs, + seq: seq, + set: set, + timestamp: timestamp +}; + +function findTagObject(value, tagName, tags) { + if (tagName) { + var match = tags.filter(function (t) { + return t.tag === tagName; + }); + var tagObj = match.find(function (t) { + return !t.format; + }) || match[0]; + if (!tagObj) throw new Error("Tag ".concat(tagName, " not found")); + return tagObj; + } // TODO: deprecate/remove class check + + + return tags.find(function (t) { + return (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format; + }); +} + +function createNode(value, tagName, ctx) { + if (value instanceof Node) return value; + var defaultPrefix = ctx.defaultPrefix, + onTagObj = ctx.onTagObj, + prevObjects = ctx.prevObjects, + schema = ctx.schema, + wrapScalars = ctx.wrapScalars; + if (tagName && tagName.startsWith('!!')) tagName = defaultPrefix + tagName.slice(2); + var tagObj = findTagObject(value, tagName, schema.tags); + + if (!tagObj) { + if (typeof value.toJSON === 'function') value = value.toJSON(); + if (!value || _typeof(value) !== 'object') return wrapScalars ? new Scalar(value) : value; + tagObj = value instanceof Map ? map : value[Symbol.iterator] ? seq : map; + } + + if (onTagObj) { + onTagObj(tagObj); + delete ctx.onTagObj; + } // Detect duplicate references to the same object & use Alias nodes for all + // after first. The `obj` wrapper allows for circular references to resolve. + + + var obj = { + value: undefined, + node: undefined + }; + + if (value && _typeof(value) === 'object' && prevObjects) { + var prev = prevObjects.get(value); + + if (prev) { + var alias = new Alias(prev); // leaves source dirty; must be cleaned by caller + + ctx.aliasNodes.push(alias); // defined along with prevObjects + + return alias; + } + + obj.value = value; + prevObjects.set(value, obj); + } + + obj.node = tagObj.createNode ? tagObj.createNode(ctx.schema, value, ctx) : wrapScalars ? new Scalar(value) : value; + if (tagName && obj.node instanceof Node) obj.node.tag = tagName; + return obj.node; +} + +function getSchemaTags(schemas, knownTags, customTags, schemaId) { + var tags = schemas[schemaId.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11' + + if (!tags) { + var keys = Object.keys(schemas).map(function (key) { + return JSON.stringify(key); + }).join(', '); + throw new Error("Unknown schema \"".concat(schemaId, "\"; use one of ").concat(keys)); + } + + if (Array.isArray(customTags)) { + var _iterator = _createForOfIteratorHelper(customTags), + _step; + + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var tag = _step.value; + tags = tags.concat(tag); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } else if (typeof customTags === 'function') { + tags = customTags(tags.slice()); + } + + for (var i = 0; i < tags.length; ++i) { + var _tag = tags[i]; + + if (typeof _tag === 'string') { + var tagObj = knownTags[_tag]; + + if (!tagObj) { + var _keys = Object.keys(knownTags).map(function (key) { + return JSON.stringify(key); + }).join(', '); + + throw new Error("Unknown custom tag \"".concat(_tag, "\"; use one of ").concat(_keys)); + } + + tags[i] = tagObj; + } + } + + return tags; +} + +var sortMapEntriesByKey = function sortMapEntriesByKey(a, b) { + return a.key < b.key ? -1 : a.key > b.key ? 1 : 0; +}; + +var Schema = /*#__PURE__*/function () { + // TODO: remove in v2 + // TODO: remove in v2 + function Schema(_ref) { + var customTags = _ref.customTags, + merge = _ref.merge, + schema = _ref.schema, + sortMapEntries = _ref.sortMapEntries, + deprecatedCustomTags = _ref.tags; + + _classCallCheck(this, Schema); + + this.merge = !!merge; + this.name = schema; + this.sortMapEntries = sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null; + if (!customTags && deprecatedCustomTags) warnOptionDeprecation('tags', 'customTags'); + this.tags = getSchemaTags(schemas, tags, customTags || deprecatedCustomTags, schema); + } + + _createClass(Schema, [{ + key: "createNode", + value: function createNode$1(value, wrapScalars, tagName, ctx) { + var baseCtx = { + defaultPrefix: Schema.defaultPrefix, + schema: this, + wrapScalars: wrapScalars + }; + var createCtx = ctx ? Object.assign(ctx, baseCtx) : baseCtx; + return createNode(value, tagName, createCtx); + } + }, { + key: "createPair", + value: function createPair(key, value, ctx) { + if (!ctx) ctx = { + wrapScalars: true + }; + var k = this.createNode(key, ctx.wrapScalars, null, ctx); + var v = this.createNode(value, ctx.wrapScalars, null, ctx); + return new Pair(k, v); + } + }]); + + return Schema; +}(); + +_defineProperty(Schema, "defaultPrefix", defaultTagPrefix); + +_defineProperty(Schema, "defaultTags", defaultTags); + +export { Schema as S }; -- cgit