source: trip-planner-front/node_modules/yaml/dist/Schema-88e323a7.js@ eed0bf8

Last change on this file since eed0bf8 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 14.3 KB
Line 
1'use strict';
2
3var PlainValue = require('./PlainValue-ec8e588e.js');
4var resolveSeq = require('./resolveSeq-d03cb037.js');
5var warnings = require('./warnings-1000a372.js');
6
7function createMap(schema, obj, ctx) {
8 const map = new resolveSeq.YAMLMap(schema);
9
10 if (obj instanceof Map) {
11 for (const [key, value] of obj) map.items.push(schema.createPair(key, value, ctx));
12 } else if (obj && typeof obj === 'object') {
13 for (const key of Object.keys(obj)) map.items.push(schema.createPair(key, obj[key], ctx));
14 }
15
16 if (typeof schema.sortMapEntries === 'function') {
17 map.items.sort(schema.sortMapEntries);
18 }
19
20 return map;
21}
22
23const map = {
24 createNode: createMap,
25 default: true,
26 nodeClass: resolveSeq.YAMLMap,
27 tag: 'tag:yaml.org,2002:map',
28 resolve: resolveSeq.resolveMap
29};
30
31function createSeq(schema, obj, ctx) {
32 const seq = new resolveSeq.YAMLSeq(schema);
33
34 if (obj && obj[Symbol.iterator]) {
35 for (const it of obj) {
36 const v = schema.createNode(it, ctx.wrapScalars, null, ctx);
37 seq.items.push(v);
38 }
39 }
40
41 return seq;
42}
43
44const seq = {
45 createNode: createSeq,
46 default: true,
47 nodeClass: resolveSeq.YAMLSeq,
48 tag: 'tag:yaml.org,2002:seq',
49 resolve: resolveSeq.resolveSeq
50};
51
52const string = {
53 identify: value => typeof value === 'string',
54 default: true,
55 tag: 'tag:yaml.org,2002:str',
56 resolve: resolveSeq.resolveString,
57
58 stringify(item, ctx, onComment, onChompKeep) {
59 ctx = Object.assign({
60 actualString: true
61 }, ctx);
62 return resolveSeq.stringifyString(item, ctx, onComment, onChompKeep);
63 },
64
65 options: resolveSeq.strOptions
66};
67
68const failsafe = [map, seq, string];
69
70/* global BigInt */
71
72const intIdentify$2 = value => typeof value === 'bigint' || Number.isInteger(value);
73
74const intResolve$1 = (src, part, radix) => resolveSeq.intOptions.asBigInt ? BigInt(src) : parseInt(part, radix);
75
76function intStringify$1(node, radix, prefix) {
77 const {
78 value
79 } = node;
80 if (intIdentify$2(value) && value >= 0) return prefix + value.toString(radix);
81 return resolveSeq.stringifyNumber(node);
82}
83
84const nullObj = {
85 identify: value => value == null,
86 createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
87 default: true,
88 tag: 'tag:yaml.org,2002:null',
89 test: /^(?:~|[Nn]ull|NULL)?$/,
90 resolve: () => null,
91 options: resolveSeq.nullOptions,
92 stringify: () => resolveSeq.nullOptions.nullStr
93};
94const boolObj = {
95 identify: value => typeof value === 'boolean',
96 default: true,
97 tag: 'tag:yaml.org,2002:bool',
98 test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
99 resolve: str => str[0] === 't' || str[0] === 'T',
100 options: resolveSeq.boolOptions,
101 stringify: ({
102 value
103 }) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr
104};
105const octObj = {
106 identify: value => intIdentify$2(value) && value >= 0,
107 default: true,
108 tag: 'tag:yaml.org,2002:int',
109 format: 'OCT',
110 test: /^0o([0-7]+)$/,
111 resolve: (str, oct) => intResolve$1(str, oct, 8),
112 options: resolveSeq.intOptions,
113 stringify: node => intStringify$1(node, 8, '0o')
114};
115const intObj = {
116 identify: intIdentify$2,
117 default: true,
118 tag: 'tag:yaml.org,2002:int',
119 test: /^[-+]?[0-9]+$/,
120 resolve: str => intResolve$1(str, str, 10),
121 options: resolveSeq.intOptions,
122 stringify: resolveSeq.stringifyNumber
123};
124const hexObj = {
125 identify: value => intIdentify$2(value) && value >= 0,
126 default: true,
127 tag: 'tag:yaml.org,2002:int',
128 format: 'HEX',
129 test: /^0x([0-9a-fA-F]+)$/,
130 resolve: (str, hex) => intResolve$1(str, hex, 16),
131 options: resolveSeq.intOptions,
132 stringify: node => intStringify$1(node, 16, '0x')
133};
134const nanObj = {
135 identify: value => typeof value === 'number',
136 default: true,
137 tag: 'tag:yaml.org,2002:float',
138 test: /^(?:[-+]?\.inf|(\.nan))$/i,
139 resolve: (str, nan) => nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
140 stringify: resolveSeq.stringifyNumber
141};
142const expObj = {
143 identify: value => typeof value === 'number',
144 default: true,
145 tag: 'tag:yaml.org,2002:float',
146 format: 'EXP',
147 test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
148 resolve: str => parseFloat(str),
149 stringify: ({
150 value
151 }) => Number(value).toExponential()
152};
153const floatObj = {
154 identify: value => typeof value === 'number',
155 default: true,
156 tag: 'tag:yaml.org,2002:float',
157 test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
158
159 resolve(str, frac1, frac2) {
160 const frac = frac1 || frac2;
161 const node = new resolveSeq.Scalar(parseFloat(str));
162 if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
163 return node;
164 },
165
166 stringify: resolveSeq.stringifyNumber
167};
168const core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);
169
170/* global BigInt */
171
172const intIdentify$1 = value => typeof value === 'bigint' || Number.isInteger(value);
173
174const stringifyJSON = ({
175 value
176}) => JSON.stringify(value);
177
178const json = [map, seq, {
179 identify: value => typeof value === 'string',
180 default: true,
181 tag: 'tag:yaml.org,2002:str',
182 resolve: resolveSeq.resolveString,
183 stringify: stringifyJSON
184}, {
185 identify: value => value == null,
186 createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
187 default: true,
188 tag: 'tag:yaml.org,2002:null',
189 test: /^null$/,
190 resolve: () => null,
191 stringify: stringifyJSON
192}, {
193 identify: value => typeof value === 'boolean',
194 default: true,
195 tag: 'tag:yaml.org,2002:bool',
196 test: /^true|false$/,
197 resolve: str => str === 'true',
198 stringify: stringifyJSON
199}, {
200 identify: intIdentify$1,
201 default: true,
202 tag: 'tag:yaml.org,2002:int',
203 test: /^-?(?:0|[1-9][0-9]*)$/,
204 resolve: str => resolveSeq.intOptions.asBigInt ? BigInt(str) : parseInt(str, 10),
205 stringify: ({
206 value
207 }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
208}, {
209 identify: value => typeof value === 'number',
210 default: true,
211 tag: 'tag:yaml.org,2002:float',
212 test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
213 resolve: str => parseFloat(str),
214 stringify: stringifyJSON
215}];
216
217json.scalarFallback = str => {
218 throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(str)}`);
219};
220
221/* global BigInt */
222
223const boolStringify = ({
224 value
225}) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr;
226
227const intIdentify = value => typeof value === 'bigint' || Number.isInteger(value);
228
229function intResolve(sign, src, radix) {
230 let str = src.replace(/_/g, '');
231
232 if (resolveSeq.intOptions.asBigInt) {
233 switch (radix) {
234 case 2:
235 str = `0b${str}`;
236 break;
237
238 case 8:
239 str = `0o${str}`;
240 break;
241
242 case 16:
243 str = `0x${str}`;
244 break;
245 }
246
247 const n = BigInt(str);
248 return sign === '-' ? BigInt(-1) * n : n;
249 }
250
251 const n = parseInt(str, radix);
252 return sign === '-' ? -1 * n : n;
253}
254
255function intStringify(node, radix, prefix) {
256 const {
257 value
258 } = node;
259
260 if (intIdentify(value)) {
261 const str = value.toString(radix);
262 return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
263 }
264
265 return resolveSeq.stringifyNumber(node);
266}
267
268const yaml11 = failsafe.concat([{
269 identify: value => value == null,
270 createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
271 default: true,
272 tag: 'tag:yaml.org,2002:null',
273 test: /^(?:~|[Nn]ull|NULL)?$/,
274 resolve: () => null,
275 options: resolveSeq.nullOptions,
276 stringify: () => resolveSeq.nullOptions.nullStr
277}, {
278 identify: value => typeof value === 'boolean',
279 default: true,
280 tag: 'tag:yaml.org,2002:bool',
281 test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
282 resolve: () => true,
283 options: resolveSeq.boolOptions,
284 stringify: boolStringify
285}, {
286 identify: value => typeof value === 'boolean',
287 default: true,
288 tag: 'tag:yaml.org,2002:bool',
289 test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
290 resolve: () => false,
291 options: resolveSeq.boolOptions,
292 stringify: boolStringify
293}, {
294 identify: intIdentify,
295 default: true,
296 tag: 'tag:yaml.org,2002:int',
297 format: 'BIN',
298 test: /^([-+]?)0b([0-1_]+)$/,
299 resolve: (str, sign, bin) => intResolve(sign, bin, 2),
300 stringify: node => intStringify(node, 2, '0b')
301}, {
302 identify: intIdentify,
303 default: true,
304 tag: 'tag:yaml.org,2002:int',
305 format: 'OCT',
306 test: /^([-+]?)0([0-7_]+)$/,
307 resolve: (str, sign, oct) => intResolve(sign, oct, 8),
308 stringify: node => intStringify(node, 8, '0')
309}, {
310 identify: intIdentify,
311 default: true,
312 tag: 'tag:yaml.org,2002:int',
313 test: /^([-+]?)([0-9][0-9_]*)$/,
314 resolve: (str, sign, abs) => intResolve(sign, abs, 10),
315 stringify: resolveSeq.stringifyNumber
316}, {
317 identify: intIdentify,
318 default: true,
319 tag: 'tag:yaml.org,2002:int',
320 format: 'HEX',
321 test: /^([-+]?)0x([0-9a-fA-F_]+)$/,
322 resolve: (str, sign, hex) => intResolve(sign, hex, 16),
323 stringify: node => intStringify(node, 16, '0x')
324}, {
325 identify: value => typeof value === 'number',
326 default: true,
327 tag: 'tag:yaml.org,2002:float',
328 test: /^(?:[-+]?\.inf|(\.nan))$/i,
329 resolve: (str, nan) => nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
330 stringify: resolveSeq.stringifyNumber
331}, {
332 identify: value => typeof value === 'number',
333 default: true,
334 tag: 'tag:yaml.org,2002:float',
335 format: 'EXP',
336 test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/,
337 resolve: str => parseFloat(str.replace(/_/g, '')),
338 stringify: ({
339 value
340 }) => Number(value).toExponential()
341}, {
342 identify: value => typeof value === 'number',
343 default: true,
344 tag: 'tag:yaml.org,2002:float',
345 test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
346
347 resolve(str, frac) {
348 const node = new resolveSeq.Scalar(parseFloat(str.replace(/_/g, '')));
349
350 if (frac) {
351 const f = frac.replace(/_/g, '');
352 if (f[f.length - 1] === '0') node.minFractionDigits = f.length;
353 }
354
355 return node;
356 },
357
358 stringify: resolveSeq.stringifyNumber
359}], warnings.binary, warnings.omap, warnings.pairs, warnings.set, warnings.intTime, warnings.floatTime, warnings.timestamp);
360
361const schemas = {
362 core,
363 failsafe,
364 json,
365 yaml11
366};
367const tags = {
368 binary: warnings.binary,
369 bool: boolObj,
370 float: floatObj,
371 floatExp: expObj,
372 floatNaN: nanObj,
373 floatTime: warnings.floatTime,
374 int: intObj,
375 intHex: hexObj,
376 intOct: octObj,
377 intTime: warnings.intTime,
378 map,
379 null: nullObj,
380 omap: warnings.omap,
381 pairs: warnings.pairs,
382 seq,
383 set: warnings.set,
384 timestamp: warnings.timestamp
385};
386
387function findTagObject(value, tagName, tags) {
388 if (tagName) {
389 const match = tags.filter(t => t.tag === tagName);
390 const tagObj = match.find(t => !t.format) || match[0];
391 if (!tagObj) throw new Error(`Tag ${tagName} not found`);
392 return tagObj;
393 } // TODO: deprecate/remove class check
394
395
396 return tags.find(t => (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format);
397}
398
399function createNode(value, tagName, ctx) {
400 if (value instanceof resolveSeq.Node) return value;
401 const {
402 defaultPrefix,
403 onTagObj,
404 prevObjects,
405 schema,
406 wrapScalars
407 } = ctx;
408 if (tagName && tagName.startsWith('!!')) tagName = defaultPrefix + tagName.slice(2);
409 let tagObj = findTagObject(value, tagName, schema.tags);
410
411 if (!tagObj) {
412 if (typeof value.toJSON === 'function') value = value.toJSON();
413 if (!value || typeof value !== 'object') return wrapScalars ? new resolveSeq.Scalar(value) : value;
414 tagObj = value instanceof Map ? map : value[Symbol.iterator] ? seq : map;
415 }
416
417 if (onTagObj) {
418 onTagObj(tagObj);
419 delete ctx.onTagObj;
420 } // Detect duplicate references to the same object & use Alias nodes for all
421 // after first. The `obj` wrapper allows for circular references to resolve.
422
423
424 const obj = {
425 value: undefined,
426 node: undefined
427 };
428
429 if (value && typeof value === 'object' && prevObjects) {
430 const prev = prevObjects.get(value);
431
432 if (prev) {
433 const alias = new resolveSeq.Alias(prev); // leaves source dirty; must be cleaned by caller
434
435 ctx.aliasNodes.push(alias); // defined along with prevObjects
436
437 return alias;
438 }
439
440 obj.value = value;
441 prevObjects.set(value, obj);
442 }
443
444 obj.node = tagObj.createNode ? tagObj.createNode(ctx.schema, value, ctx) : wrapScalars ? new resolveSeq.Scalar(value) : value;
445 if (tagName && obj.node instanceof resolveSeq.Node) obj.node.tag = tagName;
446 return obj.node;
447}
448
449function getSchemaTags(schemas, knownTags, customTags, schemaId) {
450 let tags = schemas[schemaId.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
451
452 if (!tags) {
453 const keys = Object.keys(schemas).map(key => JSON.stringify(key)).join(', ');
454 throw new Error(`Unknown schema "${schemaId}"; use one of ${keys}`);
455 }
456
457 if (Array.isArray(customTags)) {
458 for (const tag of customTags) tags = tags.concat(tag);
459 } else if (typeof customTags === 'function') {
460 tags = customTags(tags.slice());
461 }
462
463 for (let i = 0; i < tags.length; ++i) {
464 const tag = tags[i];
465
466 if (typeof tag === 'string') {
467 const tagObj = knownTags[tag];
468
469 if (!tagObj) {
470 const keys = Object.keys(knownTags).map(key => JSON.stringify(key)).join(', ');
471 throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
472 }
473
474 tags[i] = tagObj;
475 }
476 }
477
478 return tags;
479}
480
481const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
482
483class Schema {
484 // TODO: remove in v2
485 // TODO: remove in v2
486 constructor({
487 customTags,
488 merge,
489 schema,
490 sortMapEntries,
491 tags: deprecatedCustomTags
492 }) {
493 this.merge = !!merge;
494 this.name = schema;
495 this.sortMapEntries = sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
496 if (!customTags && deprecatedCustomTags) warnings.warnOptionDeprecation('tags', 'customTags');
497 this.tags = getSchemaTags(schemas, tags, customTags || deprecatedCustomTags, schema);
498 }
499
500 createNode(value, wrapScalars, tagName, ctx) {
501 const baseCtx = {
502 defaultPrefix: Schema.defaultPrefix,
503 schema: this,
504 wrapScalars
505 };
506 const createCtx = ctx ? Object.assign(ctx, baseCtx) : baseCtx;
507 return createNode(value, tagName, createCtx);
508 }
509
510 createPair(key, value, ctx) {
511 if (!ctx) ctx = {
512 wrapScalars: true
513 };
514 const k = this.createNode(key, ctx.wrapScalars, null, ctx);
515 const v = this.createNode(value, ctx.wrapScalars, null, ctx);
516 return new resolveSeq.Pair(k, v);
517 }
518
519}
520
521PlainValue._defineProperty(Schema, "defaultPrefix", PlainValue.defaultTagPrefix);
522
523PlainValue._defineProperty(Schema, "defaultTags", PlainValue.defaultTags);
524
525exports.Schema = Schema;
Note: See TracBrowser for help on using the repository browser.