source: imaps-frontend/node_modules/js-yaml/dist/js-yaml.js@ d565449

main
Last change on this file since d565449 was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 111.7 KB
Line 
1
2/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
3(function (global, factory) {
4 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
5 typeof define === 'function' && define.amd ? define(['exports'], factory) :
6 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jsyaml = {}));
7}(this, (function (exports) { 'use strict';
8
9 function isNothing(subject) {
10 return (typeof subject === 'undefined') || (subject === null);
11 }
12
13
14 function isObject(subject) {
15 return (typeof subject === 'object') && (subject !== null);
16 }
17
18
19 function toArray(sequence) {
20 if (Array.isArray(sequence)) return sequence;
21 else if (isNothing(sequence)) return [];
22
23 return [ sequence ];
24 }
25
26
27 function extend(target, source) {
28 var index, length, key, sourceKeys;
29
30 if (source) {
31 sourceKeys = Object.keys(source);
32
33 for (index = 0, length = sourceKeys.length; index < length; index += 1) {
34 key = sourceKeys[index];
35 target[key] = source[key];
36 }
37 }
38
39 return target;
40 }
41
42
43 function repeat(string, count) {
44 var result = '', cycle;
45
46 for (cycle = 0; cycle < count; cycle += 1) {
47 result += string;
48 }
49
50 return result;
51 }
52
53
54 function isNegativeZero(number) {
55 return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
56 }
57
58
59 var isNothing_1 = isNothing;
60 var isObject_1 = isObject;
61 var toArray_1 = toArray;
62 var repeat_1 = repeat;
63 var isNegativeZero_1 = isNegativeZero;
64 var extend_1 = extend;
65
66 var common = {
67 isNothing: isNothing_1,
68 isObject: isObject_1,
69 toArray: toArray_1,
70 repeat: repeat_1,
71 isNegativeZero: isNegativeZero_1,
72 extend: extend_1
73 };
74
75 // YAML error class. http://stackoverflow.com/questions/8458984
76
77
78 function formatError(exception, compact) {
79 var where = '', message = exception.reason || '(unknown reason)';
80
81 if (!exception.mark) return message;
82
83 if (exception.mark.name) {
84 where += 'in "' + exception.mark.name + '" ';
85 }
86
87 where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
88
89 if (!compact && exception.mark.snippet) {
90 where += '\n\n' + exception.mark.snippet;
91 }
92
93 return message + ' ' + where;
94 }
95
96
97 function YAMLException$1(reason, mark) {
98 // Super constructor
99 Error.call(this);
100
101 this.name = 'YAMLException';
102 this.reason = reason;
103 this.mark = mark;
104 this.message = formatError(this, false);
105
106 // Include stack trace in error object
107 if (Error.captureStackTrace) {
108 // Chrome and NodeJS
109 Error.captureStackTrace(this, this.constructor);
110 } else {
111 // FF, IE 10+ and Safari 6+. Fallback for others
112 this.stack = (new Error()).stack || '';
113 }
114 }
115
116
117 // Inherit from Error
118 YAMLException$1.prototype = Object.create(Error.prototype);
119 YAMLException$1.prototype.constructor = YAMLException$1;
120
121
122 YAMLException$1.prototype.toString = function toString(compact) {
123 return this.name + ': ' + formatError(this, compact);
124 };
125
126
127 var exception = YAMLException$1;
128
129 // get snippet for a single line, respecting maxLength
130 function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
131 var head = '';
132 var tail = '';
133 var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
134
135 if (position - lineStart > maxHalfLength) {
136 head = ' ... ';
137 lineStart = position - maxHalfLength + head.length;
138 }
139
140 if (lineEnd - position > maxHalfLength) {
141 tail = ' ...';
142 lineEnd = position + maxHalfLength - tail.length;
143 }
144
145 return {
146 str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
147 pos: position - lineStart + head.length // relative position
148 };
149 }
150
151
152 function padStart(string, max) {
153 return common.repeat(' ', max - string.length) + string;
154 }
155
156
157 function makeSnippet(mark, options) {
158 options = Object.create(options || null);
159
160 if (!mark.buffer) return null;
161
162 if (!options.maxLength) options.maxLength = 79;
163 if (typeof options.indent !== 'number') options.indent = 1;
164 if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
165 if (typeof options.linesAfter !== 'number') options.linesAfter = 2;
166
167 var re = /\r?\n|\r|\0/g;
168 var lineStarts = [ 0 ];
169 var lineEnds = [];
170 var match;
171 var foundLineNo = -1;
172
173 while ((match = re.exec(mark.buffer))) {
174 lineEnds.push(match.index);
175 lineStarts.push(match.index + match[0].length);
176
177 if (mark.position <= match.index && foundLineNo < 0) {
178 foundLineNo = lineStarts.length - 2;
179 }
180 }
181
182 if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
183
184 var result = '', i, line;
185 var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
186 var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
187
188 for (i = 1; i <= options.linesBefore; i++) {
189 if (foundLineNo - i < 0) break;
190 line = getLine(
191 mark.buffer,
192 lineStarts[foundLineNo - i],
193 lineEnds[foundLineNo - i],
194 mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
195 maxLineLength
196 );
197 result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
198 ' | ' + line.str + '\n' + result;
199 }
200
201 line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
202 result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
203 ' | ' + line.str + '\n';
204 result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
205
206 for (i = 1; i <= options.linesAfter; i++) {
207 if (foundLineNo + i >= lineEnds.length) break;
208 line = getLine(
209 mark.buffer,
210 lineStarts[foundLineNo + i],
211 lineEnds[foundLineNo + i],
212 mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
213 maxLineLength
214 );
215 result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
216 ' | ' + line.str + '\n';
217 }
218
219 return result.replace(/\n$/, '');
220 }
221
222
223 var snippet = makeSnippet;
224
225 var TYPE_CONSTRUCTOR_OPTIONS = [
226 'kind',
227 'multi',
228 'resolve',
229 'construct',
230 'instanceOf',
231 'predicate',
232 'represent',
233 'representName',
234 'defaultStyle',
235 'styleAliases'
236 ];
237
238 var YAML_NODE_KINDS = [
239 'scalar',
240 'sequence',
241 'mapping'
242 ];
243
244 function compileStyleAliases(map) {
245 var result = {};
246
247 if (map !== null) {
248 Object.keys(map).forEach(function (style) {
249 map[style].forEach(function (alias) {
250 result[String(alias)] = style;
251 });
252 });
253 }
254
255 return result;
256 }
257
258 function Type$1(tag, options) {
259 options = options || {};
260
261 Object.keys(options).forEach(function (name) {
262 if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
263 throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
264 }
265 });
266
267 // TODO: Add tag format check.
268 this.options = options; // keep original options in case user wants to extend this type later
269 this.tag = tag;
270 this.kind = options['kind'] || null;
271 this.resolve = options['resolve'] || function () { return true; };
272 this.construct = options['construct'] || function (data) { return data; };
273 this.instanceOf = options['instanceOf'] || null;
274 this.predicate = options['predicate'] || null;
275 this.represent = options['represent'] || null;
276 this.representName = options['representName'] || null;
277 this.defaultStyle = options['defaultStyle'] || null;
278 this.multi = options['multi'] || false;
279 this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
280
281 if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
282 throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
283 }
284 }
285
286 var type = Type$1;
287
288 /*eslint-disable max-len*/
289
290
291
292
293
294 function compileList(schema, name) {
295 var result = [];
296
297 schema[name].forEach(function (currentType) {
298 var newIndex = result.length;
299
300 result.forEach(function (previousType, previousIndex) {
301 if (previousType.tag === currentType.tag &&
302 previousType.kind === currentType.kind &&
303 previousType.multi === currentType.multi) {
304
305 newIndex = previousIndex;
306 }
307 });
308
309 result[newIndex] = currentType;
310 });
311
312 return result;
313 }
314
315
316 function compileMap(/* lists... */) {
317 var result = {
318 scalar: {},
319 sequence: {},
320 mapping: {},
321 fallback: {},
322 multi: {
323 scalar: [],
324 sequence: [],
325 mapping: [],
326 fallback: []
327 }
328 }, index, length;
329
330 function collectType(type) {
331 if (type.multi) {
332 result.multi[type.kind].push(type);
333 result.multi['fallback'].push(type);
334 } else {
335 result[type.kind][type.tag] = result['fallback'][type.tag] = type;
336 }
337 }
338
339 for (index = 0, length = arguments.length; index < length; index += 1) {
340 arguments[index].forEach(collectType);
341 }
342 return result;
343 }
344
345
346 function Schema$1(definition) {
347 return this.extend(definition);
348 }
349
350
351 Schema$1.prototype.extend = function extend(definition) {
352 var implicit = [];
353 var explicit = [];
354
355 if (definition instanceof type) {
356 // Schema.extend(type)
357 explicit.push(definition);
358
359 } else if (Array.isArray(definition)) {
360 // Schema.extend([ type1, type2, ... ])
361 explicit = explicit.concat(definition);
362
363 } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
364 // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
365 if (definition.implicit) implicit = implicit.concat(definition.implicit);
366 if (definition.explicit) explicit = explicit.concat(definition.explicit);
367
368 } else {
369 throw new exception('Schema.extend argument should be a Type, [ Type ], ' +
370 'or a schema definition ({ implicit: [...], explicit: [...] })');
371 }
372
373 implicit.forEach(function (type$1) {
374 if (!(type$1 instanceof type)) {
375 throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
376 }
377
378 if (type$1.loadKind && type$1.loadKind !== 'scalar') {
379 throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
380 }
381
382 if (type$1.multi) {
383 throw new exception('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
384 }
385 });
386
387 explicit.forEach(function (type$1) {
388 if (!(type$1 instanceof type)) {
389 throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
390 }
391 });
392
393 var result = Object.create(Schema$1.prototype);
394
395 result.implicit = (this.implicit || []).concat(implicit);
396 result.explicit = (this.explicit || []).concat(explicit);
397
398 result.compiledImplicit = compileList(result, 'implicit');
399 result.compiledExplicit = compileList(result, 'explicit');
400 result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
401
402 return result;
403 };
404
405
406 var schema = Schema$1;
407
408 var str = new type('tag:yaml.org,2002:str', {
409 kind: 'scalar',
410 construct: function (data) { return data !== null ? data : ''; }
411 });
412
413 var seq = new type('tag:yaml.org,2002:seq', {
414 kind: 'sequence',
415 construct: function (data) { return data !== null ? data : []; }
416 });
417
418 var map = new type('tag:yaml.org,2002:map', {
419 kind: 'mapping',
420 construct: function (data) { return data !== null ? data : {}; }
421 });
422
423 var failsafe = new schema({
424 explicit: [
425 str,
426 seq,
427 map
428 ]
429 });
430
431 function resolveYamlNull(data) {
432 if (data === null) return true;
433
434 var max = data.length;
435
436 return (max === 1 && data === '~') ||
437 (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
438 }
439
440 function constructYamlNull() {
441 return null;
442 }
443
444 function isNull(object) {
445 return object === null;
446 }
447
448 var _null = new type('tag:yaml.org,2002:null', {
449 kind: 'scalar',
450 resolve: resolveYamlNull,
451 construct: constructYamlNull,
452 predicate: isNull,
453 represent: {
454 canonical: function () { return '~'; },
455 lowercase: function () { return 'null'; },
456 uppercase: function () { return 'NULL'; },
457 camelcase: function () { return 'Null'; },
458 empty: function () { return ''; }
459 },
460 defaultStyle: 'lowercase'
461 });
462
463 function resolveYamlBoolean(data) {
464 if (data === null) return false;
465
466 var max = data.length;
467
468 return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
469 (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
470 }
471
472 function constructYamlBoolean(data) {
473 return data === 'true' ||
474 data === 'True' ||
475 data === 'TRUE';
476 }
477
478 function isBoolean(object) {
479 return Object.prototype.toString.call(object) === '[object Boolean]';
480 }
481
482 var bool = new type('tag:yaml.org,2002:bool', {
483 kind: 'scalar',
484 resolve: resolveYamlBoolean,
485 construct: constructYamlBoolean,
486 predicate: isBoolean,
487 represent: {
488 lowercase: function (object) { return object ? 'true' : 'false'; },
489 uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
490 camelcase: function (object) { return object ? 'True' : 'False'; }
491 },
492 defaultStyle: 'lowercase'
493 });
494
495 function isHexCode(c) {
496 return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
497 ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
498 ((0x61/* a */ <= c) && (c <= 0x66/* f */));
499 }
500
501 function isOctCode(c) {
502 return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
503 }
504
505 function isDecCode(c) {
506 return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
507 }
508
509 function resolveYamlInteger(data) {
510 if (data === null) return false;
511
512 var max = data.length,
513 index = 0,
514 hasDigits = false,
515 ch;
516
517 if (!max) return false;
518
519 ch = data[index];
520
521 // sign
522 if (ch === '-' || ch === '+') {
523 ch = data[++index];
524 }
525
526 if (ch === '0') {
527 // 0
528 if (index + 1 === max) return true;
529 ch = data[++index];
530
531 // base 2, base 8, base 16
532
533 if (ch === 'b') {
534 // base 2
535 index++;
536
537 for (; index < max; index++) {
538 ch = data[index];
539 if (ch === '_') continue;
540 if (ch !== '0' && ch !== '1') return false;
541 hasDigits = true;
542 }
543 return hasDigits && ch !== '_';
544 }
545
546
547 if (ch === 'x') {
548 // base 16
549 index++;
550
551 for (; index < max; index++) {
552 ch = data[index];
553 if (ch === '_') continue;
554 if (!isHexCode(data.charCodeAt(index))) return false;
555 hasDigits = true;
556 }
557 return hasDigits && ch !== '_';
558 }
559
560
561 if (ch === 'o') {
562 // base 8
563 index++;
564
565 for (; index < max; index++) {
566 ch = data[index];
567 if (ch === '_') continue;
568 if (!isOctCode(data.charCodeAt(index))) return false;
569 hasDigits = true;
570 }
571 return hasDigits && ch !== '_';
572 }
573 }
574
575 // base 10 (except 0)
576
577 // value should not start with `_`;
578 if (ch === '_') return false;
579
580 for (; index < max; index++) {
581 ch = data[index];
582 if (ch === '_') continue;
583 if (!isDecCode(data.charCodeAt(index))) {
584 return false;
585 }
586 hasDigits = true;
587 }
588
589 // Should have digits and should not end with `_`
590 if (!hasDigits || ch === '_') return false;
591
592 return true;
593 }
594
595 function constructYamlInteger(data) {
596 var value = data, sign = 1, ch;
597
598 if (value.indexOf('_') !== -1) {
599 value = value.replace(/_/g, '');
600 }
601
602 ch = value[0];
603
604 if (ch === '-' || ch === '+') {
605 if (ch === '-') sign = -1;
606 value = value.slice(1);
607 ch = value[0];
608 }
609
610 if (value === '0') return 0;
611
612 if (ch === '0') {
613 if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
614 if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
615 if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
616 }
617
618 return sign * parseInt(value, 10);
619 }
620
621 function isInteger(object) {
622 return (Object.prototype.toString.call(object)) === '[object Number]' &&
623 (object % 1 === 0 && !common.isNegativeZero(object));
624 }
625
626 var int = new type('tag:yaml.org,2002:int', {
627 kind: 'scalar',
628 resolve: resolveYamlInteger,
629 construct: constructYamlInteger,
630 predicate: isInteger,
631 represent: {
632 binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
633 octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1); },
634 decimal: function (obj) { return obj.toString(10); },
635 /* eslint-disable max-len */
636 hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); }
637 },
638 defaultStyle: 'decimal',
639 styleAliases: {
640 binary: [ 2, 'bin' ],
641 octal: [ 8, 'oct' ],
642 decimal: [ 10, 'dec' ],
643 hexadecimal: [ 16, 'hex' ]
644 }
645 });
646
647 var YAML_FLOAT_PATTERN = new RegExp(
648 // 2.5e4, 2.5 and integers
649 '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
650 // .2e4, .2
651 // special case, seems not from spec
652 '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
653 // .inf
654 '|[-+]?\\.(?:inf|Inf|INF)' +
655 // .nan
656 '|\\.(?:nan|NaN|NAN))$');
657
658 function resolveYamlFloat(data) {
659 if (data === null) return false;
660
661 if (!YAML_FLOAT_PATTERN.test(data) ||
662 // Quick hack to not allow integers end with `_`
663 // Probably should update regexp & check speed
664 data[data.length - 1] === '_') {
665 return false;
666 }
667
668 return true;
669 }
670
671 function constructYamlFloat(data) {
672 var value, sign;
673
674 value = data.replace(/_/g, '').toLowerCase();
675 sign = value[0] === '-' ? -1 : 1;
676
677 if ('+-'.indexOf(value[0]) >= 0) {
678 value = value.slice(1);
679 }
680
681 if (value === '.inf') {
682 return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
683
684 } else if (value === '.nan') {
685 return NaN;
686 }
687 return sign * parseFloat(value, 10);
688 }
689
690
691 var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
692
693 function representYamlFloat(object, style) {
694 var res;
695
696 if (isNaN(object)) {
697 switch (style) {
698 case 'lowercase': return '.nan';
699 case 'uppercase': return '.NAN';
700 case 'camelcase': return '.NaN';
701 }
702 } else if (Number.POSITIVE_INFINITY === object) {
703 switch (style) {
704 case 'lowercase': return '.inf';
705 case 'uppercase': return '.INF';
706 case 'camelcase': return '.Inf';
707 }
708 } else if (Number.NEGATIVE_INFINITY === object) {
709 switch (style) {
710 case 'lowercase': return '-.inf';
711 case 'uppercase': return '-.INF';
712 case 'camelcase': return '-.Inf';
713 }
714 } else if (common.isNegativeZero(object)) {
715 return '-0.0';
716 }
717
718 res = object.toString(10);
719
720 // JS stringifier can build scientific format without dots: 5e-100,
721 // while YAML requres dot: 5.e-100. Fix it with simple hack
722
723 return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
724 }
725
726 function isFloat(object) {
727 return (Object.prototype.toString.call(object) === '[object Number]') &&
728 (object % 1 !== 0 || common.isNegativeZero(object));
729 }
730
731 var float = new type('tag:yaml.org,2002:float', {
732 kind: 'scalar',
733 resolve: resolveYamlFloat,
734 construct: constructYamlFloat,
735 predicate: isFloat,
736 represent: representYamlFloat,
737 defaultStyle: 'lowercase'
738 });
739
740 var json = failsafe.extend({
741 implicit: [
742 _null,
743 bool,
744 int,
745 float
746 ]
747 });
748
749 var core = json;
750
751 var YAML_DATE_REGEXP = new RegExp(
752 '^([0-9][0-9][0-9][0-9])' + // [1] year
753 '-([0-9][0-9])' + // [2] month
754 '-([0-9][0-9])$'); // [3] day
755
756 var YAML_TIMESTAMP_REGEXP = new RegExp(
757 '^([0-9][0-9][0-9][0-9])' + // [1] year
758 '-([0-9][0-9]?)' + // [2] month
759 '-([0-9][0-9]?)' + // [3] day
760 '(?:[Tt]|[ \\t]+)' + // ...
761 '([0-9][0-9]?)' + // [4] hour
762 ':([0-9][0-9])' + // [5] minute
763 ':([0-9][0-9])' + // [6] second
764 '(?:\\.([0-9]*))?' + // [7] fraction
765 '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
766 '(?::([0-9][0-9]))?))?$'); // [11] tz_minute
767
768 function resolveYamlTimestamp(data) {
769 if (data === null) return false;
770 if (YAML_DATE_REGEXP.exec(data) !== null) return true;
771 if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
772 return false;
773 }
774
775 function constructYamlTimestamp(data) {
776 var match, year, month, day, hour, minute, second, fraction = 0,
777 delta = null, tz_hour, tz_minute, date;
778
779 match = YAML_DATE_REGEXP.exec(data);
780 if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
781
782 if (match === null) throw new Error('Date resolve error');
783
784 // match: [1] year [2] month [3] day
785
786 year = +(match[1]);
787 month = +(match[2]) - 1; // JS month starts with 0
788 day = +(match[3]);
789
790 if (!match[4]) { // no hour
791 return new Date(Date.UTC(year, month, day));
792 }
793
794 // match: [4] hour [5] minute [6] second [7] fraction
795
796 hour = +(match[4]);
797 minute = +(match[5]);
798 second = +(match[6]);
799
800 if (match[7]) {
801 fraction = match[7].slice(0, 3);
802 while (fraction.length < 3) { // milli-seconds
803 fraction += '0';
804 }
805 fraction = +fraction;
806 }
807
808 // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
809
810 if (match[9]) {
811 tz_hour = +(match[10]);
812 tz_minute = +(match[11] || 0);
813 delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
814 if (match[9] === '-') delta = -delta;
815 }
816
817 date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
818
819 if (delta) date.setTime(date.getTime() - delta);
820
821 return date;
822 }
823
824 function representYamlTimestamp(object /*, style*/) {
825 return object.toISOString();
826 }
827
828 var timestamp = new type('tag:yaml.org,2002:timestamp', {
829 kind: 'scalar',
830 resolve: resolveYamlTimestamp,
831 construct: constructYamlTimestamp,
832 instanceOf: Date,
833 represent: representYamlTimestamp
834 });
835
836 function resolveYamlMerge(data) {
837 return data === '<<' || data === null;
838 }
839
840 var merge = new type('tag:yaml.org,2002:merge', {
841 kind: 'scalar',
842 resolve: resolveYamlMerge
843 });
844
845 /*eslint-disable no-bitwise*/
846
847
848
849
850
851 // [ 64, 65, 66 ] -> [ padding, CR, LF ]
852 var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
853
854
855 function resolveYamlBinary(data) {
856 if (data === null) return false;
857
858 var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
859
860 // Convert one by one.
861 for (idx = 0; idx < max; idx++) {
862 code = map.indexOf(data.charAt(idx));
863
864 // Skip CR/LF
865 if (code > 64) continue;
866
867 // Fail on illegal characters
868 if (code < 0) return false;
869
870 bitlen += 6;
871 }
872
873 // If there are any bits left, source was corrupted
874 return (bitlen % 8) === 0;
875 }
876
877 function constructYamlBinary(data) {
878 var idx, tailbits,
879 input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
880 max = input.length,
881 map = BASE64_MAP,
882 bits = 0,
883 result = [];
884
885 // Collect by 6*4 bits (3 bytes)
886
887 for (idx = 0; idx < max; idx++) {
888 if ((idx % 4 === 0) && idx) {
889 result.push((bits >> 16) & 0xFF);
890 result.push((bits >> 8) & 0xFF);
891 result.push(bits & 0xFF);
892 }
893
894 bits = (bits << 6) | map.indexOf(input.charAt(idx));
895 }
896
897 // Dump tail
898
899 tailbits = (max % 4) * 6;
900
901 if (tailbits === 0) {
902 result.push((bits >> 16) & 0xFF);
903 result.push((bits >> 8) & 0xFF);
904 result.push(bits & 0xFF);
905 } else if (tailbits === 18) {
906 result.push((bits >> 10) & 0xFF);
907 result.push((bits >> 2) & 0xFF);
908 } else if (tailbits === 12) {
909 result.push((bits >> 4) & 0xFF);
910 }
911
912 return new Uint8Array(result);
913 }
914
915 function representYamlBinary(object /*, style*/) {
916 var result = '', bits = 0, idx, tail,
917 max = object.length,
918 map = BASE64_MAP;
919
920 // Convert every three bytes to 4 ASCII characters.
921
922 for (idx = 0; idx < max; idx++) {
923 if ((idx % 3 === 0) && idx) {
924 result += map[(bits >> 18) & 0x3F];
925 result += map[(bits >> 12) & 0x3F];
926 result += map[(bits >> 6) & 0x3F];
927 result += map[bits & 0x3F];
928 }
929
930 bits = (bits << 8) + object[idx];
931 }
932
933 // Dump tail
934
935 tail = max % 3;
936
937 if (tail === 0) {
938 result += map[(bits >> 18) & 0x3F];
939 result += map[(bits >> 12) & 0x3F];
940 result += map[(bits >> 6) & 0x3F];
941 result += map[bits & 0x3F];
942 } else if (tail === 2) {
943 result += map[(bits >> 10) & 0x3F];
944 result += map[(bits >> 4) & 0x3F];
945 result += map[(bits << 2) & 0x3F];
946 result += map[64];
947 } else if (tail === 1) {
948 result += map[(bits >> 2) & 0x3F];
949 result += map[(bits << 4) & 0x3F];
950 result += map[64];
951 result += map[64];
952 }
953
954 return result;
955 }
956
957 function isBinary(obj) {
958 return Object.prototype.toString.call(obj) === '[object Uint8Array]';
959 }
960
961 var binary = new type('tag:yaml.org,2002:binary', {
962 kind: 'scalar',
963 resolve: resolveYamlBinary,
964 construct: constructYamlBinary,
965 predicate: isBinary,
966 represent: representYamlBinary
967 });
968
969 var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
970 var _toString$2 = Object.prototype.toString;
971
972 function resolveYamlOmap(data) {
973 if (data === null) return true;
974
975 var objectKeys = [], index, length, pair, pairKey, pairHasKey,
976 object = data;
977
978 for (index = 0, length = object.length; index < length; index += 1) {
979 pair = object[index];
980 pairHasKey = false;
981
982 if (_toString$2.call(pair) !== '[object Object]') return false;
983
984 for (pairKey in pair) {
985 if (_hasOwnProperty$3.call(pair, pairKey)) {
986 if (!pairHasKey) pairHasKey = true;
987 else return false;
988 }
989 }
990
991 if (!pairHasKey) return false;
992
993 if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
994 else return false;
995 }
996
997 return true;
998 }
999
1000 function constructYamlOmap(data) {
1001 return data !== null ? data : [];
1002 }
1003
1004 var omap = new type('tag:yaml.org,2002:omap', {
1005 kind: 'sequence',
1006 resolve: resolveYamlOmap,
1007 construct: constructYamlOmap
1008 });
1009
1010 var _toString$1 = Object.prototype.toString;
1011
1012 function resolveYamlPairs(data) {
1013 if (data === null) return true;
1014
1015 var index, length, pair, keys, result,
1016 object = data;
1017
1018 result = new Array(object.length);
1019
1020 for (index = 0, length = object.length; index < length; index += 1) {
1021 pair = object[index];
1022
1023 if (_toString$1.call(pair) !== '[object Object]') return false;
1024
1025 keys = Object.keys(pair);
1026
1027 if (keys.length !== 1) return false;
1028
1029 result[index] = [ keys[0], pair[keys[0]] ];
1030 }
1031
1032 return true;
1033 }
1034
1035 function constructYamlPairs(data) {
1036 if (data === null) return [];
1037
1038 var index, length, pair, keys, result,
1039 object = data;
1040
1041 result = new Array(object.length);
1042
1043 for (index = 0, length = object.length; index < length; index += 1) {
1044 pair = object[index];
1045
1046 keys = Object.keys(pair);
1047
1048 result[index] = [ keys[0], pair[keys[0]] ];
1049 }
1050
1051 return result;
1052 }
1053
1054 var pairs = new type('tag:yaml.org,2002:pairs', {
1055 kind: 'sequence',
1056 resolve: resolveYamlPairs,
1057 construct: constructYamlPairs
1058 });
1059
1060 var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
1061
1062 function resolveYamlSet(data) {
1063 if (data === null) return true;
1064
1065 var key, object = data;
1066
1067 for (key in object) {
1068 if (_hasOwnProperty$2.call(object, key)) {
1069 if (object[key] !== null) return false;
1070 }
1071 }
1072
1073 return true;
1074 }
1075
1076 function constructYamlSet(data) {
1077 return data !== null ? data : {};
1078 }
1079
1080 var set = new type('tag:yaml.org,2002:set', {
1081 kind: 'mapping',
1082 resolve: resolveYamlSet,
1083 construct: constructYamlSet
1084 });
1085
1086 var _default = core.extend({
1087 implicit: [
1088 timestamp,
1089 merge
1090 ],
1091 explicit: [
1092 binary,
1093 omap,
1094 pairs,
1095 set
1096 ]
1097 });
1098
1099 /*eslint-disable max-len,no-use-before-define*/
1100
1101
1102
1103
1104
1105
1106
1107 var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
1108
1109
1110 var CONTEXT_FLOW_IN = 1;
1111 var CONTEXT_FLOW_OUT = 2;
1112 var CONTEXT_BLOCK_IN = 3;
1113 var CONTEXT_BLOCK_OUT = 4;
1114
1115
1116 var CHOMPING_CLIP = 1;
1117 var CHOMPING_STRIP = 2;
1118 var CHOMPING_KEEP = 3;
1119
1120
1121 var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
1122 var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
1123 var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
1124 var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
1125 var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
1126
1127
1128 function _class(obj) { return Object.prototype.toString.call(obj); }
1129
1130 function is_EOL(c) {
1131 return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
1132 }
1133
1134 function is_WHITE_SPACE(c) {
1135 return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
1136 }
1137
1138 function is_WS_OR_EOL(c) {
1139 return (c === 0x09/* Tab */) ||
1140 (c === 0x20/* Space */) ||
1141 (c === 0x0A/* LF */) ||
1142 (c === 0x0D/* CR */);
1143 }
1144
1145 function is_FLOW_INDICATOR(c) {
1146 return c === 0x2C/* , */ ||
1147 c === 0x5B/* [ */ ||
1148 c === 0x5D/* ] */ ||
1149 c === 0x7B/* { */ ||
1150 c === 0x7D/* } */;
1151 }
1152
1153 function fromHexCode(c) {
1154 var lc;
1155
1156 if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
1157 return c - 0x30;
1158 }
1159
1160 /*eslint-disable no-bitwise*/
1161 lc = c | 0x20;
1162
1163 if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
1164 return lc - 0x61 + 10;
1165 }
1166
1167 return -1;
1168 }
1169
1170 function escapedHexLen(c) {
1171 if (c === 0x78/* x */) { return 2; }
1172 if (c === 0x75/* u */) { return 4; }
1173 if (c === 0x55/* U */) { return 8; }
1174 return 0;
1175 }
1176
1177 function fromDecimalCode(c) {
1178 if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
1179 return c - 0x30;
1180 }
1181
1182 return -1;
1183 }
1184
1185 function simpleEscapeSequence(c) {
1186 /* eslint-disable indent */
1187 return (c === 0x30/* 0 */) ? '\x00' :
1188 (c === 0x61/* a */) ? '\x07' :
1189 (c === 0x62/* b */) ? '\x08' :
1190 (c === 0x74/* t */) ? '\x09' :
1191 (c === 0x09/* Tab */) ? '\x09' :
1192 (c === 0x6E/* n */) ? '\x0A' :
1193 (c === 0x76/* v */) ? '\x0B' :
1194 (c === 0x66/* f */) ? '\x0C' :
1195 (c === 0x72/* r */) ? '\x0D' :
1196 (c === 0x65/* e */) ? '\x1B' :
1197 (c === 0x20/* Space */) ? ' ' :
1198 (c === 0x22/* " */) ? '\x22' :
1199 (c === 0x2F/* / */) ? '/' :
1200 (c === 0x5C/* \ */) ? '\x5C' :
1201 (c === 0x4E/* N */) ? '\x85' :
1202 (c === 0x5F/* _ */) ? '\xA0' :
1203 (c === 0x4C/* L */) ? '\u2028' :
1204 (c === 0x50/* P */) ? '\u2029' : '';
1205 }
1206
1207 function charFromCodepoint(c) {
1208 if (c <= 0xFFFF) {
1209 return String.fromCharCode(c);
1210 }
1211 // Encode UTF-16 surrogate pair
1212 // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
1213 return String.fromCharCode(
1214 ((c - 0x010000) >> 10) + 0xD800,
1215 ((c - 0x010000) & 0x03FF) + 0xDC00
1216 );
1217 }
1218
1219 var simpleEscapeCheck = new Array(256); // integer, for fast access
1220 var simpleEscapeMap = new Array(256);
1221 for (var i = 0; i < 256; i++) {
1222 simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
1223 simpleEscapeMap[i] = simpleEscapeSequence(i);
1224 }
1225
1226
1227 function State$1(input, options) {
1228 this.input = input;
1229
1230 this.filename = options['filename'] || null;
1231 this.schema = options['schema'] || _default;
1232 this.onWarning = options['onWarning'] || null;
1233 // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
1234 // if such documents have no explicit %YAML directive
1235 this.legacy = options['legacy'] || false;
1236
1237 this.json = options['json'] || false;
1238 this.listener = options['listener'] || null;
1239
1240 this.implicitTypes = this.schema.compiledImplicit;
1241 this.typeMap = this.schema.compiledTypeMap;
1242
1243 this.length = input.length;
1244 this.position = 0;
1245 this.line = 0;
1246 this.lineStart = 0;
1247 this.lineIndent = 0;
1248
1249 // position of first leading tab in the current line,
1250 // used to make sure there are no tabs in the indentation
1251 this.firstTabInLine = -1;
1252
1253 this.documents = [];
1254
1255 /*
1256 this.version;
1257 this.checkLineBreaks;
1258 this.tagMap;
1259 this.anchorMap;
1260 this.tag;
1261 this.anchor;
1262 this.kind;
1263 this.result;*/
1264
1265 }
1266
1267
1268 function generateError(state, message) {
1269 var mark = {
1270 name: state.filename,
1271 buffer: state.input.slice(0, -1), // omit trailing \0
1272 position: state.position,
1273 line: state.line,
1274 column: state.position - state.lineStart
1275 };
1276
1277 mark.snippet = snippet(mark);
1278
1279 return new exception(message, mark);
1280 }
1281
1282 function throwError(state, message) {
1283 throw generateError(state, message);
1284 }
1285
1286 function throwWarning(state, message) {
1287 if (state.onWarning) {
1288 state.onWarning.call(null, generateError(state, message));
1289 }
1290 }
1291
1292
1293 var directiveHandlers = {
1294
1295 YAML: function handleYamlDirective(state, name, args) {
1296
1297 var match, major, minor;
1298
1299 if (state.version !== null) {
1300 throwError(state, 'duplication of %YAML directive');
1301 }
1302
1303 if (args.length !== 1) {
1304 throwError(state, 'YAML directive accepts exactly one argument');
1305 }
1306
1307 match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
1308
1309 if (match === null) {
1310 throwError(state, 'ill-formed argument of the YAML directive');
1311 }
1312
1313 major = parseInt(match[1], 10);
1314 minor = parseInt(match[2], 10);
1315
1316 if (major !== 1) {
1317 throwError(state, 'unacceptable YAML version of the document');
1318 }
1319
1320 state.version = args[0];
1321 state.checkLineBreaks = (minor < 2);
1322
1323 if (minor !== 1 && minor !== 2) {
1324 throwWarning(state, 'unsupported YAML version of the document');
1325 }
1326 },
1327
1328 TAG: function handleTagDirective(state, name, args) {
1329
1330 var handle, prefix;
1331
1332 if (args.length !== 2) {
1333 throwError(state, 'TAG directive accepts exactly two arguments');
1334 }
1335
1336 handle = args[0];
1337 prefix = args[1];
1338
1339 if (!PATTERN_TAG_HANDLE.test(handle)) {
1340 throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
1341 }
1342
1343 if (_hasOwnProperty$1.call(state.tagMap, handle)) {
1344 throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
1345 }
1346
1347 if (!PATTERN_TAG_URI.test(prefix)) {
1348 throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
1349 }
1350
1351 try {
1352 prefix = decodeURIComponent(prefix);
1353 } catch (err) {
1354 throwError(state, 'tag prefix is malformed: ' + prefix);
1355 }
1356
1357 state.tagMap[handle] = prefix;
1358 }
1359 };
1360
1361
1362 function captureSegment(state, start, end, checkJson) {
1363 var _position, _length, _character, _result;
1364
1365 if (start < end) {
1366 _result = state.input.slice(start, end);
1367
1368 if (checkJson) {
1369 for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
1370 _character = _result.charCodeAt(_position);
1371 if (!(_character === 0x09 ||
1372 (0x20 <= _character && _character <= 0x10FFFF))) {
1373 throwError(state, 'expected valid JSON character');
1374 }
1375 }
1376 } else if (PATTERN_NON_PRINTABLE.test(_result)) {
1377 throwError(state, 'the stream contains non-printable characters');
1378 }
1379
1380 state.result += _result;
1381 }
1382 }
1383
1384 function mergeMappings(state, destination, source, overridableKeys) {
1385 var sourceKeys, key, index, quantity;
1386
1387 if (!common.isObject(source)) {
1388 throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
1389 }
1390
1391 sourceKeys = Object.keys(source);
1392
1393 for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
1394 key = sourceKeys[index];
1395
1396 if (!_hasOwnProperty$1.call(destination, key)) {
1397 destination[key] = source[key];
1398 overridableKeys[key] = true;
1399 }
1400 }
1401 }
1402
1403 function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
1404 startLine, startLineStart, startPos) {
1405
1406 var index, quantity;
1407
1408 // The output is a plain object here, so keys can only be strings.
1409 // We need to convert keyNode to a string, but doing so can hang the process
1410 // (deeply nested arrays that explode exponentially using aliases).
1411 if (Array.isArray(keyNode)) {
1412 keyNode = Array.prototype.slice.call(keyNode);
1413
1414 for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
1415 if (Array.isArray(keyNode[index])) {
1416 throwError(state, 'nested arrays are not supported inside keys');
1417 }
1418
1419 if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
1420 keyNode[index] = '[object Object]';
1421 }
1422 }
1423 }
1424
1425 // Avoid code execution in load() via toString property
1426 // (still use its own toString for arrays, timestamps,
1427 // and whatever user schema extensions happen to have @@toStringTag)
1428 if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
1429 keyNode = '[object Object]';
1430 }
1431
1432
1433 keyNode = String(keyNode);
1434
1435 if (_result === null) {
1436 _result = {};
1437 }
1438
1439 if (keyTag === 'tag:yaml.org,2002:merge') {
1440 if (Array.isArray(valueNode)) {
1441 for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
1442 mergeMappings(state, _result, valueNode[index], overridableKeys);
1443 }
1444 } else {
1445 mergeMappings(state, _result, valueNode, overridableKeys);
1446 }
1447 } else {
1448 if (!state.json &&
1449 !_hasOwnProperty$1.call(overridableKeys, keyNode) &&
1450 _hasOwnProperty$1.call(_result, keyNode)) {
1451 state.line = startLine || state.line;
1452 state.lineStart = startLineStart || state.lineStart;
1453 state.position = startPos || state.position;
1454 throwError(state, 'duplicated mapping key');
1455 }
1456
1457 // used for this specific key only because Object.defineProperty is slow
1458 if (keyNode === '__proto__') {
1459 Object.defineProperty(_result, keyNode, {
1460 configurable: true,
1461 enumerable: true,
1462 writable: true,
1463 value: valueNode
1464 });
1465 } else {
1466 _result[keyNode] = valueNode;
1467 }
1468 delete overridableKeys[keyNode];
1469 }
1470
1471 return _result;
1472 }
1473
1474 function readLineBreak(state) {
1475 var ch;
1476
1477 ch = state.input.charCodeAt(state.position);
1478
1479 if (ch === 0x0A/* LF */) {
1480 state.position++;
1481 } else if (ch === 0x0D/* CR */) {
1482 state.position++;
1483 if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
1484 state.position++;
1485 }
1486 } else {
1487 throwError(state, 'a line break is expected');
1488 }
1489
1490 state.line += 1;
1491 state.lineStart = state.position;
1492 state.firstTabInLine = -1;
1493 }
1494
1495 function skipSeparationSpace(state, allowComments, checkIndent) {
1496 var lineBreaks = 0,
1497 ch = state.input.charCodeAt(state.position);
1498
1499 while (ch !== 0) {
1500 while (is_WHITE_SPACE(ch)) {
1501 if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
1502 state.firstTabInLine = state.position;
1503 }
1504 ch = state.input.charCodeAt(++state.position);
1505 }
1506
1507 if (allowComments && ch === 0x23/* # */) {
1508 do {
1509 ch = state.input.charCodeAt(++state.position);
1510 } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
1511 }
1512
1513 if (is_EOL(ch)) {
1514 readLineBreak(state);
1515
1516 ch = state.input.charCodeAt(state.position);
1517 lineBreaks++;
1518 state.lineIndent = 0;
1519
1520 while (ch === 0x20/* Space */) {
1521 state.lineIndent++;
1522 ch = state.input.charCodeAt(++state.position);
1523 }
1524 } else {
1525 break;
1526 }
1527 }
1528
1529 if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
1530 throwWarning(state, 'deficient indentation');
1531 }
1532
1533 return lineBreaks;
1534 }
1535
1536 function testDocumentSeparator(state) {
1537 var _position = state.position,
1538 ch;
1539
1540 ch = state.input.charCodeAt(_position);
1541
1542 // Condition state.position === state.lineStart is tested
1543 // in parent on each call, for efficiency. No needs to test here again.
1544 if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
1545 ch === state.input.charCodeAt(_position + 1) &&
1546 ch === state.input.charCodeAt(_position + 2)) {
1547
1548 _position += 3;
1549
1550 ch = state.input.charCodeAt(_position);
1551
1552 if (ch === 0 || is_WS_OR_EOL(ch)) {
1553 return true;
1554 }
1555 }
1556
1557 return false;
1558 }
1559
1560 function writeFoldedLines(state, count) {
1561 if (count === 1) {
1562 state.result += ' ';
1563 } else if (count > 1) {
1564 state.result += common.repeat('\n', count - 1);
1565 }
1566 }
1567
1568
1569 function readPlainScalar(state, nodeIndent, withinFlowCollection) {
1570 var preceding,
1571 following,
1572 captureStart,
1573 captureEnd,
1574 hasPendingContent,
1575 _line,
1576 _lineStart,
1577 _lineIndent,
1578 _kind = state.kind,
1579 _result = state.result,
1580 ch;
1581
1582 ch = state.input.charCodeAt(state.position);
1583
1584 if (is_WS_OR_EOL(ch) ||
1585 is_FLOW_INDICATOR(ch) ||
1586 ch === 0x23/* # */ ||
1587 ch === 0x26/* & */ ||
1588 ch === 0x2A/* * */ ||
1589 ch === 0x21/* ! */ ||
1590 ch === 0x7C/* | */ ||
1591 ch === 0x3E/* > */ ||
1592 ch === 0x27/* ' */ ||
1593 ch === 0x22/* " */ ||
1594 ch === 0x25/* % */ ||
1595 ch === 0x40/* @ */ ||
1596 ch === 0x60/* ` */) {
1597 return false;
1598 }
1599
1600 if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
1601 following = state.input.charCodeAt(state.position + 1);
1602
1603 if (is_WS_OR_EOL(following) ||
1604 withinFlowCollection && is_FLOW_INDICATOR(following)) {
1605 return false;
1606 }
1607 }
1608
1609 state.kind = 'scalar';
1610 state.result = '';
1611 captureStart = captureEnd = state.position;
1612 hasPendingContent = false;
1613
1614 while (ch !== 0) {
1615 if (ch === 0x3A/* : */) {
1616 following = state.input.charCodeAt(state.position + 1);
1617
1618 if (is_WS_OR_EOL(following) ||
1619 withinFlowCollection && is_FLOW_INDICATOR(following)) {
1620 break;
1621 }
1622
1623 } else if (ch === 0x23/* # */) {
1624 preceding = state.input.charCodeAt(state.position - 1);
1625
1626 if (is_WS_OR_EOL(preceding)) {
1627 break;
1628 }
1629
1630 } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
1631 withinFlowCollection && is_FLOW_INDICATOR(ch)) {
1632 break;
1633
1634 } else if (is_EOL(ch)) {
1635 _line = state.line;
1636 _lineStart = state.lineStart;
1637 _lineIndent = state.lineIndent;
1638 skipSeparationSpace(state, false, -1);
1639
1640 if (state.lineIndent >= nodeIndent) {
1641 hasPendingContent = true;
1642 ch = state.input.charCodeAt(state.position);
1643 continue;
1644 } else {
1645 state.position = captureEnd;
1646 state.line = _line;
1647 state.lineStart = _lineStart;
1648 state.lineIndent = _lineIndent;
1649 break;
1650 }
1651 }
1652
1653 if (hasPendingContent) {
1654 captureSegment(state, captureStart, captureEnd, false);
1655 writeFoldedLines(state, state.line - _line);
1656 captureStart = captureEnd = state.position;
1657 hasPendingContent = false;
1658 }
1659
1660 if (!is_WHITE_SPACE(ch)) {
1661 captureEnd = state.position + 1;
1662 }
1663
1664 ch = state.input.charCodeAt(++state.position);
1665 }
1666
1667 captureSegment(state, captureStart, captureEnd, false);
1668
1669 if (state.result) {
1670 return true;
1671 }
1672
1673 state.kind = _kind;
1674 state.result = _result;
1675 return false;
1676 }
1677
1678 function readSingleQuotedScalar(state, nodeIndent) {
1679 var ch,
1680 captureStart, captureEnd;
1681
1682 ch = state.input.charCodeAt(state.position);
1683
1684 if (ch !== 0x27/* ' */) {
1685 return false;
1686 }
1687
1688 state.kind = 'scalar';
1689 state.result = '';
1690 state.position++;
1691 captureStart = captureEnd = state.position;
1692
1693 while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1694 if (ch === 0x27/* ' */) {
1695 captureSegment(state, captureStart, state.position, true);
1696 ch = state.input.charCodeAt(++state.position);
1697
1698 if (ch === 0x27/* ' */) {
1699 captureStart = state.position;
1700 state.position++;
1701 captureEnd = state.position;
1702 } else {
1703 return true;
1704 }
1705
1706 } else if (is_EOL(ch)) {
1707 captureSegment(state, captureStart, captureEnd, true);
1708 writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1709 captureStart = captureEnd = state.position;
1710
1711 } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1712 throwError(state, 'unexpected end of the document within a single quoted scalar');
1713
1714 } else {
1715 state.position++;
1716 captureEnd = state.position;
1717 }
1718 }
1719
1720 throwError(state, 'unexpected end of the stream within a single quoted scalar');
1721 }
1722
1723 function readDoubleQuotedScalar(state, nodeIndent) {
1724 var captureStart,
1725 captureEnd,
1726 hexLength,
1727 hexResult,
1728 tmp,
1729 ch;
1730
1731 ch = state.input.charCodeAt(state.position);
1732
1733 if (ch !== 0x22/* " */) {
1734 return false;
1735 }
1736
1737 state.kind = 'scalar';
1738 state.result = '';
1739 state.position++;
1740 captureStart = captureEnd = state.position;
1741
1742 while ((ch = state.input.charCodeAt(state.position)) !== 0) {
1743 if (ch === 0x22/* " */) {
1744 captureSegment(state, captureStart, state.position, true);
1745 state.position++;
1746 return true;
1747
1748 } else if (ch === 0x5C/* \ */) {
1749 captureSegment(state, captureStart, state.position, true);
1750 ch = state.input.charCodeAt(++state.position);
1751
1752 if (is_EOL(ch)) {
1753 skipSeparationSpace(state, false, nodeIndent);
1754
1755 // TODO: rework to inline fn with no type cast?
1756 } else if (ch < 256 && simpleEscapeCheck[ch]) {
1757 state.result += simpleEscapeMap[ch];
1758 state.position++;
1759
1760 } else if ((tmp = escapedHexLen(ch)) > 0) {
1761 hexLength = tmp;
1762 hexResult = 0;
1763
1764 for (; hexLength > 0; hexLength--) {
1765 ch = state.input.charCodeAt(++state.position);
1766
1767 if ((tmp = fromHexCode(ch)) >= 0) {
1768 hexResult = (hexResult << 4) + tmp;
1769
1770 } else {
1771 throwError(state, 'expected hexadecimal character');
1772 }
1773 }
1774
1775 state.result += charFromCodepoint(hexResult);
1776
1777 state.position++;
1778
1779 } else {
1780 throwError(state, 'unknown escape sequence');
1781 }
1782
1783 captureStart = captureEnd = state.position;
1784
1785 } else if (is_EOL(ch)) {
1786 captureSegment(state, captureStart, captureEnd, true);
1787 writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
1788 captureStart = captureEnd = state.position;
1789
1790 } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
1791 throwError(state, 'unexpected end of the document within a double quoted scalar');
1792
1793 } else {
1794 state.position++;
1795 captureEnd = state.position;
1796 }
1797 }
1798
1799 throwError(state, 'unexpected end of the stream within a double quoted scalar');
1800 }
1801
1802 function readFlowCollection(state, nodeIndent) {
1803 var readNext = true,
1804 _line,
1805 _lineStart,
1806 _pos,
1807 _tag = state.tag,
1808 _result,
1809 _anchor = state.anchor,
1810 following,
1811 terminator,
1812 isPair,
1813 isExplicitPair,
1814 isMapping,
1815 overridableKeys = Object.create(null),
1816 keyNode,
1817 keyTag,
1818 valueNode,
1819 ch;
1820
1821 ch = state.input.charCodeAt(state.position);
1822
1823 if (ch === 0x5B/* [ */) {
1824 terminator = 0x5D;/* ] */
1825 isMapping = false;
1826 _result = [];
1827 } else if (ch === 0x7B/* { */) {
1828 terminator = 0x7D;/* } */
1829 isMapping = true;
1830 _result = {};
1831 } else {
1832 return false;
1833 }
1834
1835 if (state.anchor !== null) {
1836 state.anchorMap[state.anchor] = _result;
1837 }
1838
1839 ch = state.input.charCodeAt(++state.position);
1840
1841 while (ch !== 0) {
1842 skipSeparationSpace(state, true, nodeIndent);
1843
1844 ch = state.input.charCodeAt(state.position);
1845
1846 if (ch === terminator) {
1847 state.position++;
1848 state.tag = _tag;
1849 state.anchor = _anchor;
1850 state.kind = isMapping ? 'mapping' : 'sequence';
1851 state.result = _result;
1852 return true;
1853 } else if (!readNext) {
1854 throwError(state, 'missed comma between flow collection entries');
1855 } else if (ch === 0x2C/* , */) {
1856 // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
1857 throwError(state, "expected the node content, but found ','");
1858 }
1859
1860 keyTag = keyNode = valueNode = null;
1861 isPair = isExplicitPair = false;
1862
1863 if (ch === 0x3F/* ? */) {
1864 following = state.input.charCodeAt(state.position + 1);
1865
1866 if (is_WS_OR_EOL(following)) {
1867 isPair = isExplicitPair = true;
1868 state.position++;
1869 skipSeparationSpace(state, true, nodeIndent);
1870 }
1871 }
1872
1873 _line = state.line; // Save the current line.
1874 _lineStart = state.lineStart;
1875 _pos = state.position;
1876 composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1877 keyTag = state.tag;
1878 keyNode = state.result;
1879 skipSeparationSpace(state, true, nodeIndent);
1880
1881 ch = state.input.charCodeAt(state.position);
1882
1883 if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
1884 isPair = true;
1885 ch = state.input.charCodeAt(++state.position);
1886 skipSeparationSpace(state, true, nodeIndent);
1887 composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
1888 valueNode = state.result;
1889 }
1890
1891 if (isMapping) {
1892 storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
1893 } else if (isPair) {
1894 _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
1895 } else {
1896 _result.push(keyNode);
1897 }
1898
1899 skipSeparationSpace(state, true, nodeIndent);
1900
1901 ch = state.input.charCodeAt(state.position);
1902
1903 if (ch === 0x2C/* , */) {
1904 readNext = true;
1905 ch = state.input.charCodeAt(++state.position);
1906 } else {
1907 readNext = false;
1908 }
1909 }
1910
1911 throwError(state, 'unexpected end of the stream within a flow collection');
1912 }
1913
1914 function readBlockScalar(state, nodeIndent) {
1915 var captureStart,
1916 folding,
1917 chomping = CHOMPING_CLIP,
1918 didReadContent = false,
1919 detectedIndent = false,
1920 textIndent = nodeIndent,
1921 emptyLines = 0,
1922 atMoreIndented = false,
1923 tmp,
1924 ch;
1925
1926 ch = state.input.charCodeAt(state.position);
1927
1928 if (ch === 0x7C/* | */) {
1929 folding = false;
1930 } else if (ch === 0x3E/* > */) {
1931 folding = true;
1932 } else {
1933 return false;
1934 }
1935
1936 state.kind = 'scalar';
1937 state.result = '';
1938
1939 while (ch !== 0) {
1940 ch = state.input.charCodeAt(++state.position);
1941
1942 if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
1943 if (CHOMPING_CLIP === chomping) {
1944 chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
1945 } else {
1946 throwError(state, 'repeat of a chomping mode identifier');
1947 }
1948
1949 } else if ((tmp = fromDecimalCode(ch)) >= 0) {
1950 if (tmp === 0) {
1951 throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
1952 } else if (!detectedIndent) {
1953 textIndent = nodeIndent + tmp - 1;
1954 detectedIndent = true;
1955 } else {
1956 throwError(state, 'repeat of an indentation width identifier');
1957 }
1958
1959 } else {
1960 break;
1961 }
1962 }
1963
1964 if (is_WHITE_SPACE(ch)) {
1965 do { ch = state.input.charCodeAt(++state.position); }
1966 while (is_WHITE_SPACE(ch));
1967
1968 if (ch === 0x23/* # */) {
1969 do { ch = state.input.charCodeAt(++state.position); }
1970 while (!is_EOL(ch) && (ch !== 0));
1971 }
1972 }
1973
1974 while (ch !== 0) {
1975 readLineBreak(state);
1976 state.lineIndent = 0;
1977
1978 ch = state.input.charCodeAt(state.position);
1979
1980 while ((!detectedIndent || state.lineIndent < textIndent) &&
1981 (ch === 0x20/* Space */)) {
1982 state.lineIndent++;
1983 ch = state.input.charCodeAt(++state.position);
1984 }
1985
1986 if (!detectedIndent && state.lineIndent > textIndent) {
1987 textIndent = state.lineIndent;
1988 }
1989
1990 if (is_EOL(ch)) {
1991 emptyLines++;
1992 continue;
1993 }
1994
1995 // End of the scalar.
1996 if (state.lineIndent < textIndent) {
1997
1998 // Perform the chomping.
1999 if (chomping === CHOMPING_KEEP) {
2000 state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2001 } else if (chomping === CHOMPING_CLIP) {
2002 if (didReadContent) { // i.e. only if the scalar is not empty.
2003 state.result += '\n';
2004 }
2005 }
2006
2007 // Break this `while` cycle and go to the funciton's epilogue.
2008 break;
2009 }
2010
2011 // Folded style: use fancy rules to handle line breaks.
2012 if (folding) {
2013
2014 // Lines starting with white space characters (more-indented lines) are not folded.
2015 if (is_WHITE_SPACE(ch)) {
2016 atMoreIndented = true;
2017 // except for the first content line (cf. Example 8.1)
2018 state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2019
2020 // End of more-indented block.
2021 } else if (atMoreIndented) {
2022 atMoreIndented = false;
2023 state.result += common.repeat('\n', emptyLines + 1);
2024
2025 // Just one line break - perceive as the same line.
2026 } else if (emptyLines === 0) {
2027 if (didReadContent) { // i.e. only if we have already read some scalar content.
2028 state.result += ' ';
2029 }
2030
2031 // Several line breaks - perceive as different lines.
2032 } else {
2033 state.result += common.repeat('\n', emptyLines);
2034 }
2035
2036 // Literal style: just add exact number of line breaks between content lines.
2037 } else {
2038 // Keep all line breaks except the header line break.
2039 state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
2040 }
2041
2042 didReadContent = true;
2043 detectedIndent = true;
2044 emptyLines = 0;
2045 captureStart = state.position;
2046
2047 while (!is_EOL(ch) && (ch !== 0)) {
2048 ch = state.input.charCodeAt(++state.position);
2049 }
2050
2051 captureSegment(state, captureStart, state.position, false);
2052 }
2053
2054 return true;
2055 }
2056
2057 function readBlockSequence(state, nodeIndent) {
2058 var _line,
2059 _tag = state.tag,
2060 _anchor = state.anchor,
2061 _result = [],
2062 following,
2063 detected = false,
2064 ch;
2065
2066 // there is a leading tab before this token, so it can't be a block sequence/mapping;
2067 // it can still be flow sequence/mapping or a scalar
2068 if (state.firstTabInLine !== -1) return false;
2069
2070 if (state.anchor !== null) {
2071 state.anchorMap[state.anchor] = _result;
2072 }
2073
2074 ch = state.input.charCodeAt(state.position);
2075
2076 while (ch !== 0) {
2077 if (state.firstTabInLine !== -1) {
2078 state.position = state.firstTabInLine;
2079 throwError(state, 'tab characters must not be used in indentation');
2080 }
2081
2082 if (ch !== 0x2D/* - */) {
2083 break;
2084 }
2085
2086 following = state.input.charCodeAt(state.position + 1);
2087
2088 if (!is_WS_OR_EOL(following)) {
2089 break;
2090 }
2091
2092 detected = true;
2093 state.position++;
2094
2095 if (skipSeparationSpace(state, true, -1)) {
2096 if (state.lineIndent <= nodeIndent) {
2097 _result.push(null);
2098 ch = state.input.charCodeAt(state.position);
2099 continue;
2100 }
2101 }
2102
2103 _line = state.line;
2104 composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
2105 _result.push(state.result);
2106 skipSeparationSpace(state, true, -1);
2107
2108 ch = state.input.charCodeAt(state.position);
2109
2110 if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
2111 throwError(state, 'bad indentation of a sequence entry');
2112 } else if (state.lineIndent < nodeIndent) {
2113 break;
2114 }
2115 }
2116
2117 if (detected) {
2118 state.tag = _tag;
2119 state.anchor = _anchor;
2120 state.kind = 'sequence';
2121 state.result = _result;
2122 return true;
2123 }
2124 return false;
2125 }
2126
2127 function readBlockMapping(state, nodeIndent, flowIndent) {
2128 var following,
2129 allowCompact,
2130 _line,
2131 _keyLine,
2132 _keyLineStart,
2133 _keyPos,
2134 _tag = state.tag,
2135 _anchor = state.anchor,
2136 _result = {},
2137 overridableKeys = Object.create(null),
2138 keyTag = null,
2139 keyNode = null,
2140 valueNode = null,
2141 atExplicitKey = false,
2142 detected = false,
2143 ch;
2144
2145 // there is a leading tab before this token, so it can't be a block sequence/mapping;
2146 // it can still be flow sequence/mapping or a scalar
2147 if (state.firstTabInLine !== -1) return false;
2148
2149 if (state.anchor !== null) {
2150 state.anchorMap[state.anchor] = _result;
2151 }
2152
2153 ch = state.input.charCodeAt(state.position);
2154
2155 while (ch !== 0) {
2156 if (!atExplicitKey && state.firstTabInLine !== -1) {
2157 state.position = state.firstTabInLine;
2158 throwError(state, 'tab characters must not be used in indentation');
2159 }
2160
2161 following = state.input.charCodeAt(state.position + 1);
2162 _line = state.line; // Save the current line.
2163
2164 //
2165 // Explicit notation case. There are two separate blocks:
2166 // first for the key (denoted by "?") and second for the value (denoted by ":")
2167 //
2168 if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
2169
2170 if (ch === 0x3F/* ? */) {
2171 if (atExplicitKey) {
2172 storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2173 keyTag = keyNode = valueNode = null;
2174 }
2175
2176 detected = true;
2177 atExplicitKey = true;
2178 allowCompact = true;
2179
2180 } else if (atExplicitKey) {
2181 // i.e. 0x3A/* : */ === character after the explicit key.
2182 atExplicitKey = false;
2183 allowCompact = true;
2184
2185 } else {
2186 throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
2187 }
2188
2189 state.position += 1;
2190 ch = following;
2191
2192 //
2193 // Implicit notation case. Flow-style node as the key first, then ":", and the value.
2194 //
2195 } else {
2196 _keyLine = state.line;
2197 _keyLineStart = state.lineStart;
2198 _keyPos = state.position;
2199
2200 if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
2201 // Neither implicit nor explicit notation.
2202 // Reading is done. Go to the epilogue.
2203 break;
2204 }
2205
2206 if (state.line === _line) {
2207 ch = state.input.charCodeAt(state.position);
2208
2209 while (is_WHITE_SPACE(ch)) {
2210 ch = state.input.charCodeAt(++state.position);
2211 }
2212
2213 if (ch === 0x3A/* : */) {
2214 ch = state.input.charCodeAt(++state.position);
2215
2216 if (!is_WS_OR_EOL(ch)) {
2217 throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
2218 }
2219
2220 if (atExplicitKey) {
2221 storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2222 keyTag = keyNode = valueNode = null;
2223 }
2224
2225 detected = true;
2226 atExplicitKey = false;
2227 allowCompact = false;
2228 keyTag = state.tag;
2229 keyNode = state.result;
2230
2231 } else if (detected) {
2232 throwError(state, 'can not read an implicit mapping pair; a colon is missed');
2233
2234 } else {
2235 state.tag = _tag;
2236 state.anchor = _anchor;
2237 return true; // Keep the result of `composeNode`.
2238 }
2239
2240 } else if (detected) {
2241 throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
2242
2243 } else {
2244 state.tag = _tag;
2245 state.anchor = _anchor;
2246 return true; // Keep the result of `composeNode`.
2247 }
2248 }
2249
2250 //
2251 // Common reading code for both explicit and implicit notations.
2252 //
2253 if (state.line === _line || state.lineIndent > nodeIndent) {
2254 if (atExplicitKey) {
2255 _keyLine = state.line;
2256 _keyLineStart = state.lineStart;
2257 _keyPos = state.position;
2258 }
2259
2260 if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
2261 if (atExplicitKey) {
2262 keyNode = state.result;
2263 } else {
2264 valueNode = state.result;
2265 }
2266 }
2267
2268 if (!atExplicitKey) {
2269 storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
2270 keyTag = keyNode = valueNode = null;
2271 }
2272
2273 skipSeparationSpace(state, true, -1);
2274 ch = state.input.charCodeAt(state.position);
2275 }
2276
2277 if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
2278 throwError(state, 'bad indentation of a mapping entry');
2279 } else if (state.lineIndent < nodeIndent) {
2280 break;
2281 }
2282 }
2283
2284 //
2285 // Epilogue.
2286 //
2287
2288 // Special case: last mapping's node contains only the key in explicit notation.
2289 if (atExplicitKey) {
2290 storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
2291 }
2292
2293 // Expose the resulting mapping.
2294 if (detected) {
2295 state.tag = _tag;
2296 state.anchor = _anchor;
2297 state.kind = 'mapping';
2298 state.result = _result;
2299 }
2300
2301 return detected;
2302 }
2303
2304 function readTagProperty(state) {
2305 var _position,
2306 isVerbatim = false,
2307 isNamed = false,
2308 tagHandle,
2309 tagName,
2310 ch;
2311
2312 ch = state.input.charCodeAt(state.position);
2313
2314 if (ch !== 0x21/* ! */) return false;
2315
2316 if (state.tag !== null) {
2317 throwError(state, 'duplication of a tag property');
2318 }
2319
2320 ch = state.input.charCodeAt(++state.position);
2321
2322 if (ch === 0x3C/* < */) {
2323 isVerbatim = true;
2324 ch = state.input.charCodeAt(++state.position);
2325
2326 } else if (ch === 0x21/* ! */) {
2327 isNamed = true;
2328 tagHandle = '!!';
2329 ch = state.input.charCodeAt(++state.position);
2330
2331 } else {
2332 tagHandle = '!';
2333 }
2334
2335 _position = state.position;
2336
2337 if (isVerbatim) {
2338 do { ch = state.input.charCodeAt(++state.position); }
2339 while (ch !== 0 && ch !== 0x3E/* > */);
2340
2341 if (state.position < state.length) {
2342 tagName = state.input.slice(_position, state.position);
2343 ch = state.input.charCodeAt(++state.position);
2344 } else {
2345 throwError(state, 'unexpected end of the stream within a verbatim tag');
2346 }
2347 } else {
2348 while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2349
2350 if (ch === 0x21/* ! */) {
2351 if (!isNamed) {
2352 tagHandle = state.input.slice(_position - 1, state.position + 1);
2353
2354 if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
2355 throwError(state, 'named tag handle cannot contain such characters');
2356 }
2357
2358 isNamed = true;
2359 _position = state.position + 1;
2360 } else {
2361 throwError(state, 'tag suffix cannot contain exclamation marks');
2362 }
2363 }
2364
2365 ch = state.input.charCodeAt(++state.position);
2366 }
2367
2368 tagName = state.input.slice(_position, state.position);
2369
2370 if (PATTERN_FLOW_INDICATORS.test(tagName)) {
2371 throwError(state, 'tag suffix cannot contain flow indicator characters');
2372 }
2373 }
2374
2375 if (tagName && !PATTERN_TAG_URI.test(tagName)) {
2376 throwError(state, 'tag name cannot contain such characters: ' + tagName);
2377 }
2378
2379 try {
2380 tagName = decodeURIComponent(tagName);
2381 } catch (err) {
2382 throwError(state, 'tag name is malformed: ' + tagName);
2383 }
2384
2385 if (isVerbatim) {
2386 state.tag = tagName;
2387
2388 } else if (_hasOwnProperty$1.call(state.tagMap, tagHandle)) {
2389 state.tag = state.tagMap[tagHandle] + tagName;
2390
2391 } else if (tagHandle === '!') {
2392 state.tag = '!' + tagName;
2393
2394 } else if (tagHandle === '!!') {
2395 state.tag = 'tag:yaml.org,2002:' + tagName;
2396
2397 } else {
2398 throwError(state, 'undeclared tag handle "' + tagHandle + '"');
2399 }
2400
2401 return true;
2402 }
2403
2404 function readAnchorProperty(state) {
2405 var _position,
2406 ch;
2407
2408 ch = state.input.charCodeAt(state.position);
2409
2410 if (ch !== 0x26/* & */) return false;
2411
2412 if (state.anchor !== null) {
2413 throwError(state, 'duplication of an anchor property');
2414 }
2415
2416 ch = state.input.charCodeAt(++state.position);
2417 _position = state.position;
2418
2419 while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2420 ch = state.input.charCodeAt(++state.position);
2421 }
2422
2423 if (state.position === _position) {
2424 throwError(state, 'name of an anchor node must contain at least one character');
2425 }
2426
2427 state.anchor = state.input.slice(_position, state.position);
2428 return true;
2429 }
2430
2431 function readAlias(state) {
2432 var _position, alias,
2433 ch;
2434
2435 ch = state.input.charCodeAt(state.position);
2436
2437 if (ch !== 0x2A/* * */) return false;
2438
2439 ch = state.input.charCodeAt(++state.position);
2440 _position = state.position;
2441
2442 while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
2443 ch = state.input.charCodeAt(++state.position);
2444 }
2445
2446 if (state.position === _position) {
2447 throwError(state, 'name of an alias node must contain at least one character');
2448 }
2449
2450 alias = state.input.slice(_position, state.position);
2451
2452 if (!_hasOwnProperty$1.call(state.anchorMap, alias)) {
2453 throwError(state, 'unidentified alias "' + alias + '"');
2454 }
2455
2456 state.result = state.anchorMap[alias];
2457 skipSeparationSpace(state, true, -1);
2458 return true;
2459 }
2460
2461 function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
2462 var allowBlockStyles,
2463 allowBlockScalars,
2464 allowBlockCollections,
2465 indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
2466 atNewLine = false,
2467 hasContent = false,
2468 typeIndex,
2469 typeQuantity,
2470 typeList,
2471 type,
2472 flowIndent,
2473 blockIndent;
2474
2475 if (state.listener !== null) {
2476 state.listener('open', state);
2477 }
2478
2479 state.tag = null;
2480 state.anchor = null;
2481 state.kind = null;
2482 state.result = null;
2483
2484 allowBlockStyles = allowBlockScalars = allowBlockCollections =
2485 CONTEXT_BLOCK_OUT === nodeContext ||
2486 CONTEXT_BLOCK_IN === nodeContext;
2487
2488 if (allowToSeek) {
2489 if (skipSeparationSpace(state, true, -1)) {
2490 atNewLine = true;
2491
2492 if (state.lineIndent > parentIndent) {
2493 indentStatus = 1;
2494 } else if (state.lineIndent === parentIndent) {
2495 indentStatus = 0;
2496 } else if (state.lineIndent < parentIndent) {
2497 indentStatus = -1;
2498 }
2499 }
2500 }
2501
2502 if (indentStatus === 1) {
2503 while (readTagProperty(state) || readAnchorProperty(state)) {
2504 if (skipSeparationSpace(state, true, -1)) {
2505 atNewLine = true;
2506 allowBlockCollections = allowBlockStyles;
2507
2508 if (state.lineIndent > parentIndent) {
2509 indentStatus = 1;
2510 } else if (state.lineIndent === parentIndent) {
2511 indentStatus = 0;
2512 } else if (state.lineIndent < parentIndent) {
2513 indentStatus = -1;
2514 }
2515 } else {
2516 allowBlockCollections = false;
2517 }
2518 }
2519 }
2520
2521 if (allowBlockCollections) {
2522 allowBlockCollections = atNewLine || allowCompact;
2523 }
2524
2525 if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
2526 if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
2527 flowIndent = parentIndent;
2528 } else {
2529 flowIndent = parentIndent + 1;
2530 }
2531
2532 blockIndent = state.position - state.lineStart;
2533
2534 if (indentStatus === 1) {
2535 if (allowBlockCollections &&
2536 (readBlockSequence(state, blockIndent) ||
2537 readBlockMapping(state, blockIndent, flowIndent)) ||
2538 readFlowCollection(state, flowIndent)) {
2539 hasContent = true;
2540 } else {
2541 if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
2542 readSingleQuotedScalar(state, flowIndent) ||
2543 readDoubleQuotedScalar(state, flowIndent)) {
2544 hasContent = true;
2545
2546 } else if (readAlias(state)) {
2547 hasContent = true;
2548
2549 if (state.tag !== null || state.anchor !== null) {
2550 throwError(state, 'alias node should not have any properties');
2551 }
2552
2553 } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
2554 hasContent = true;
2555
2556 if (state.tag === null) {
2557 state.tag = '?';
2558 }
2559 }
2560
2561 if (state.anchor !== null) {
2562 state.anchorMap[state.anchor] = state.result;
2563 }
2564 }
2565 } else if (indentStatus === 0) {
2566 // Special case: block sequences are allowed to have same indentation level as the parent.
2567 // http://www.yaml.org/spec/1.2/spec.html#id2799784
2568 hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
2569 }
2570 }
2571
2572 if (state.tag === null) {
2573 if (state.anchor !== null) {
2574 state.anchorMap[state.anchor] = state.result;
2575 }
2576
2577 } else if (state.tag === '?') {
2578 // Implicit resolving is not allowed for non-scalar types, and '?'
2579 // non-specific tag is only automatically assigned to plain scalars.
2580 //
2581 // We only need to check kind conformity in case user explicitly assigns '?'
2582 // tag, for example like this: "!<?> [0]"
2583 //
2584 if (state.result !== null && state.kind !== 'scalar') {
2585 throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
2586 }
2587
2588 for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
2589 type = state.implicitTypes[typeIndex];
2590
2591 if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
2592 state.result = type.construct(state.result);
2593 state.tag = type.tag;
2594 if (state.anchor !== null) {
2595 state.anchorMap[state.anchor] = state.result;
2596 }
2597 break;
2598 }
2599 }
2600 } else if (state.tag !== '!') {
2601 if (_hasOwnProperty$1.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
2602 type = state.typeMap[state.kind || 'fallback'][state.tag];
2603 } else {
2604 // looking for multi type
2605 type = null;
2606 typeList = state.typeMap.multi[state.kind || 'fallback'];
2607
2608 for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
2609 if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
2610 type = typeList[typeIndex];
2611 break;
2612 }
2613 }
2614 }
2615
2616 if (!type) {
2617 throwError(state, 'unknown tag !<' + state.tag + '>');
2618 }
2619
2620 if (state.result !== null && type.kind !== state.kind) {
2621 throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
2622 }
2623
2624 if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
2625 throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
2626 } else {
2627 state.result = type.construct(state.result, state.tag);
2628 if (state.anchor !== null) {
2629 state.anchorMap[state.anchor] = state.result;
2630 }
2631 }
2632 }
2633
2634 if (state.listener !== null) {
2635 state.listener('close', state);
2636 }
2637 return state.tag !== null || state.anchor !== null || hasContent;
2638 }
2639
2640 function readDocument(state) {
2641 var documentStart = state.position,
2642 _position,
2643 directiveName,
2644 directiveArgs,
2645 hasDirectives = false,
2646 ch;
2647
2648 state.version = null;
2649 state.checkLineBreaks = state.legacy;
2650 state.tagMap = Object.create(null);
2651 state.anchorMap = Object.create(null);
2652
2653 while ((ch = state.input.charCodeAt(state.position)) !== 0) {
2654 skipSeparationSpace(state, true, -1);
2655
2656 ch = state.input.charCodeAt(state.position);
2657
2658 if (state.lineIndent > 0 || ch !== 0x25/* % */) {
2659 break;
2660 }
2661
2662 hasDirectives = true;
2663 ch = state.input.charCodeAt(++state.position);
2664 _position = state.position;
2665
2666 while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2667 ch = state.input.charCodeAt(++state.position);
2668 }
2669
2670 directiveName = state.input.slice(_position, state.position);
2671 directiveArgs = [];
2672
2673 if (directiveName.length < 1) {
2674 throwError(state, 'directive name must not be less than one character in length');
2675 }
2676
2677 while (ch !== 0) {
2678 while (is_WHITE_SPACE(ch)) {
2679 ch = state.input.charCodeAt(++state.position);
2680 }
2681
2682 if (ch === 0x23/* # */) {
2683 do { ch = state.input.charCodeAt(++state.position); }
2684 while (ch !== 0 && !is_EOL(ch));
2685 break;
2686 }
2687
2688 if (is_EOL(ch)) break;
2689
2690 _position = state.position;
2691
2692 while (ch !== 0 && !is_WS_OR_EOL(ch)) {
2693 ch = state.input.charCodeAt(++state.position);
2694 }
2695
2696 directiveArgs.push(state.input.slice(_position, state.position));
2697 }
2698
2699 if (ch !== 0) readLineBreak(state);
2700
2701 if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
2702 directiveHandlers[directiveName](state, directiveName, directiveArgs);
2703 } else {
2704 throwWarning(state, 'unknown document directive "' + directiveName + '"');
2705 }
2706 }
2707
2708 skipSeparationSpace(state, true, -1);
2709
2710 if (state.lineIndent === 0 &&
2711 state.input.charCodeAt(state.position) === 0x2D/* - */ &&
2712 state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
2713 state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
2714 state.position += 3;
2715 skipSeparationSpace(state, true, -1);
2716
2717 } else if (hasDirectives) {
2718 throwError(state, 'directives end mark is expected');
2719 }
2720
2721 composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
2722 skipSeparationSpace(state, true, -1);
2723
2724 if (state.checkLineBreaks &&
2725 PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
2726 throwWarning(state, 'non-ASCII line breaks are interpreted as content');
2727 }
2728
2729 state.documents.push(state.result);
2730
2731 if (state.position === state.lineStart && testDocumentSeparator(state)) {
2732
2733 if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
2734 state.position += 3;
2735 skipSeparationSpace(state, true, -1);
2736 }
2737 return;
2738 }
2739
2740 if (state.position < (state.length - 1)) {
2741 throwError(state, 'end of the stream or a document separator is expected');
2742 } else {
2743 return;
2744 }
2745 }
2746
2747
2748 function loadDocuments(input, options) {
2749 input = String(input);
2750 options = options || {};
2751
2752 if (input.length !== 0) {
2753
2754 // Add tailing `\n` if not exists
2755 if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
2756 input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
2757 input += '\n';
2758 }
2759
2760 // Strip BOM
2761 if (input.charCodeAt(0) === 0xFEFF) {
2762 input = input.slice(1);
2763 }
2764 }
2765
2766 var state = new State$1(input, options);
2767
2768 var nullpos = input.indexOf('\0');
2769
2770 if (nullpos !== -1) {
2771 state.position = nullpos;
2772 throwError(state, 'null byte is not allowed in input');
2773 }
2774
2775 // Use 0 as string terminator. That significantly simplifies bounds check.
2776 state.input += '\0';
2777
2778 while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
2779 state.lineIndent += 1;
2780 state.position += 1;
2781 }
2782
2783 while (state.position < (state.length - 1)) {
2784 readDocument(state);
2785 }
2786
2787 return state.documents;
2788 }
2789
2790
2791 function loadAll$1(input, iterator, options) {
2792 if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
2793 options = iterator;
2794 iterator = null;
2795 }
2796
2797 var documents = loadDocuments(input, options);
2798
2799 if (typeof iterator !== 'function') {
2800 return documents;
2801 }
2802
2803 for (var index = 0, length = documents.length; index < length; index += 1) {
2804 iterator(documents[index]);
2805 }
2806 }
2807
2808
2809 function load$1(input, options) {
2810 var documents = loadDocuments(input, options);
2811
2812 if (documents.length === 0) {
2813 /*eslint-disable no-undefined*/
2814 return undefined;
2815 } else if (documents.length === 1) {
2816 return documents[0];
2817 }
2818 throw new exception('expected a single document in the stream, but found more');
2819 }
2820
2821
2822 var loadAll_1 = loadAll$1;
2823 var load_1 = load$1;
2824
2825 var loader = {
2826 loadAll: loadAll_1,
2827 load: load_1
2828 };
2829
2830 /*eslint-disable no-use-before-define*/
2831
2832
2833
2834
2835
2836 var _toString = Object.prototype.toString;
2837 var _hasOwnProperty = Object.prototype.hasOwnProperty;
2838
2839 var CHAR_BOM = 0xFEFF;
2840 var CHAR_TAB = 0x09; /* Tab */
2841 var CHAR_LINE_FEED = 0x0A; /* LF */
2842 var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
2843 var CHAR_SPACE = 0x20; /* Space */
2844 var CHAR_EXCLAMATION = 0x21; /* ! */
2845 var CHAR_DOUBLE_QUOTE = 0x22; /* " */
2846 var CHAR_SHARP = 0x23; /* # */
2847 var CHAR_PERCENT = 0x25; /* % */
2848 var CHAR_AMPERSAND = 0x26; /* & */
2849 var CHAR_SINGLE_QUOTE = 0x27; /* ' */
2850 var CHAR_ASTERISK = 0x2A; /* * */
2851 var CHAR_COMMA = 0x2C; /* , */
2852 var CHAR_MINUS = 0x2D; /* - */
2853 var CHAR_COLON = 0x3A; /* : */
2854 var CHAR_EQUALS = 0x3D; /* = */
2855 var CHAR_GREATER_THAN = 0x3E; /* > */
2856 var CHAR_QUESTION = 0x3F; /* ? */
2857 var CHAR_COMMERCIAL_AT = 0x40; /* @ */
2858 var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
2859 var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
2860 var CHAR_GRAVE_ACCENT = 0x60; /* ` */
2861 var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
2862 var CHAR_VERTICAL_LINE = 0x7C; /* | */
2863 var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
2864
2865 var ESCAPE_SEQUENCES = {};
2866
2867 ESCAPE_SEQUENCES[0x00] = '\\0';
2868 ESCAPE_SEQUENCES[0x07] = '\\a';
2869 ESCAPE_SEQUENCES[0x08] = '\\b';
2870 ESCAPE_SEQUENCES[0x09] = '\\t';
2871 ESCAPE_SEQUENCES[0x0A] = '\\n';
2872 ESCAPE_SEQUENCES[0x0B] = '\\v';
2873 ESCAPE_SEQUENCES[0x0C] = '\\f';
2874 ESCAPE_SEQUENCES[0x0D] = '\\r';
2875 ESCAPE_SEQUENCES[0x1B] = '\\e';
2876 ESCAPE_SEQUENCES[0x22] = '\\"';
2877 ESCAPE_SEQUENCES[0x5C] = '\\\\';
2878 ESCAPE_SEQUENCES[0x85] = '\\N';
2879 ESCAPE_SEQUENCES[0xA0] = '\\_';
2880 ESCAPE_SEQUENCES[0x2028] = '\\L';
2881 ESCAPE_SEQUENCES[0x2029] = '\\P';
2882
2883 var DEPRECATED_BOOLEANS_SYNTAX = [
2884 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
2885 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
2886 ];
2887
2888 var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
2889
2890 function compileStyleMap(schema, map) {
2891 var result, keys, index, length, tag, style, type;
2892
2893 if (map === null) return {};
2894
2895 result = {};
2896 keys = Object.keys(map);
2897
2898 for (index = 0, length = keys.length; index < length; index += 1) {
2899 tag = keys[index];
2900 style = String(map[tag]);
2901
2902 if (tag.slice(0, 2) === '!!') {
2903 tag = 'tag:yaml.org,2002:' + tag.slice(2);
2904 }
2905 type = schema.compiledTypeMap['fallback'][tag];
2906
2907 if (type && _hasOwnProperty.call(type.styleAliases, style)) {
2908 style = type.styleAliases[style];
2909 }
2910
2911 result[tag] = style;
2912 }
2913
2914 return result;
2915 }
2916
2917 function encodeHex(character) {
2918 var string, handle, length;
2919
2920 string = character.toString(16).toUpperCase();
2921
2922 if (character <= 0xFF) {
2923 handle = 'x';
2924 length = 2;
2925 } else if (character <= 0xFFFF) {
2926 handle = 'u';
2927 length = 4;
2928 } else if (character <= 0xFFFFFFFF) {
2929 handle = 'U';
2930 length = 8;
2931 } else {
2932 throw new exception('code point within a string may not be greater than 0xFFFFFFFF');
2933 }
2934
2935 return '\\' + handle + common.repeat('0', length - string.length) + string;
2936 }
2937
2938
2939 var QUOTING_TYPE_SINGLE = 1,
2940 QUOTING_TYPE_DOUBLE = 2;
2941
2942 function State(options) {
2943 this.schema = options['schema'] || _default;
2944 this.indent = Math.max(1, (options['indent'] || 2));
2945 this.noArrayIndent = options['noArrayIndent'] || false;
2946 this.skipInvalid = options['skipInvalid'] || false;
2947 this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
2948 this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
2949 this.sortKeys = options['sortKeys'] || false;
2950 this.lineWidth = options['lineWidth'] || 80;
2951 this.noRefs = options['noRefs'] || false;
2952 this.noCompatMode = options['noCompatMode'] || false;
2953 this.condenseFlow = options['condenseFlow'] || false;
2954 this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
2955 this.forceQuotes = options['forceQuotes'] || false;
2956 this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null;
2957
2958 this.implicitTypes = this.schema.compiledImplicit;
2959 this.explicitTypes = this.schema.compiledExplicit;
2960
2961 this.tag = null;
2962 this.result = '';
2963
2964 this.duplicates = [];
2965 this.usedDuplicates = null;
2966 }
2967
2968 // Indents every line in a string. Empty lines (\n only) are not indented.
2969 function indentString(string, spaces) {
2970 var ind = common.repeat(' ', spaces),
2971 position = 0,
2972 next = -1,
2973 result = '',
2974 line,
2975 length = string.length;
2976
2977 while (position < length) {
2978 next = string.indexOf('\n', position);
2979 if (next === -1) {
2980 line = string.slice(position);
2981 position = length;
2982 } else {
2983 line = string.slice(position, next + 1);
2984 position = next + 1;
2985 }
2986
2987 if (line.length && line !== '\n') result += ind;
2988
2989 result += line;
2990 }
2991
2992 return result;
2993 }
2994
2995 function generateNextLine(state, level) {
2996 return '\n' + common.repeat(' ', state.indent * level);
2997 }
2998
2999 function testImplicitResolving(state, str) {
3000 var index, length, type;
3001
3002 for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
3003 type = state.implicitTypes[index];
3004
3005 if (type.resolve(str)) {
3006 return true;
3007 }
3008 }
3009
3010 return false;
3011 }
3012
3013 // [33] s-white ::= s-space | s-tab
3014 function isWhitespace(c) {
3015 return c === CHAR_SPACE || c === CHAR_TAB;
3016 }
3017
3018 // Returns true if the character can be printed without escaping.
3019 // From YAML 1.2: "any allowed characters known to be non-printable
3020 // should also be escaped. [However,] This isn’t mandatory"
3021 // Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
3022 function isPrintable(c) {
3023 return (0x00020 <= c && c <= 0x00007E)
3024 || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
3025 || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
3026 || (0x10000 <= c && c <= 0x10FFFF);
3027 }
3028
3029 // [34] ns-char ::= nb-char - s-white
3030 // [27] nb-char ::= c-printable - b-char - c-byte-order-mark
3031 // [26] b-char ::= b-line-feed | b-carriage-return
3032 // Including s-white (for some reason, examples doesn't match specs in this aspect)
3033 // ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
3034 function isNsCharOrWhitespace(c) {
3035 return isPrintable(c)
3036 && c !== CHAR_BOM
3037 // - b-char
3038 && c !== CHAR_CARRIAGE_RETURN
3039 && c !== CHAR_LINE_FEED;
3040 }
3041
3042 // [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out
3043 // c = flow-in ⇒ ns-plain-safe-in
3044 // c = block-key ⇒ ns-plain-safe-out
3045 // c = flow-key ⇒ ns-plain-safe-in
3046 // [128] ns-plain-safe-out ::= ns-char
3047 // [129] ns-plain-safe-in ::= ns-char - c-flow-indicator
3048 // [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” )
3049 // | ( /* An ns-char preceding */ “#” )
3050 // | ( “:” /* Followed by an ns-plain-safe(c) */ )
3051 function isPlainSafe(c, prev, inblock) {
3052 var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
3053 var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
3054 return (
3055 // ns-plain-safe
3056 inblock ? // c = flow-in
3057 cIsNsCharOrWhitespace
3058 : cIsNsCharOrWhitespace
3059 // - c-flow-indicator
3060 && c !== CHAR_COMMA
3061 && c !== CHAR_LEFT_SQUARE_BRACKET
3062 && c !== CHAR_RIGHT_SQUARE_BRACKET
3063 && c !== CHAR_LEFT_CURLY_BRACKET
3064 && c !== CHAR_RIGHT_CURLY_BRACKET
3065 )
3066 // ns-plain-char
3067 && c !== CHAR_SHARP // false on '#'
3068 && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
3069 || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
3070 || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
3071 }
3072
3073 // Simplified test for values allowed as the first character in plain style.
3074 function isPlainSafeFirst(c) {
3075 // Uses a subset of ns-char - c-indicator
3076 // where ns-char = nb-char - s-white.
3077 // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
3078 return isPrintable(c) && c !== CHAR_BOM
3079 && !isWhitespace(c) // - s-white
3080 // - (c-indicator ::=
3081 // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
3082 && c !== CHAR_MINUS
3083 && c !== CHAR_QUESTION
3084 && c !== CHAR_COLON
3085 && c !== CHAR_COMMA
3086 && c !== CHAR_LEFT_SQUARE_BRACKET
3087 && c !== CHAR_RIGHT_SQUARE_BRACKET
3088 && c !== CHAR_LEFT_CURLY_BRACKET
3089 && c !== CHAR_RIGHT_CURLY_BRACKET
3090 // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
3091 && c !== CHAR_SHARP
3092 && c !== CHAR_AMPERSAND
3093 && c !== CHAR_ASTERISK
3094 && c !== CHAR_EXCLAMATION
3095 && c !== CHAR_VERTICAL_LINE
3096 && c !== CHAR_EQUALS
3097 && c !== CHAR_GREATER_THAN
3098 && c !== CHAR_SINGLE_QUOTE
3099 && c !== CHAR_DOUBLE_QUOTE
3100 // | “%” | “@” | “`”)
3101 && c !== CHAR_PERCENT
3102 && c !== CHAR_COMMERCIAL_AT
3103 && c !== CHAR_GRAVE_ACCENT;
3104 }
3105
3106 // Simplified test for values allowed as the last character in plain style.
3107 function isPlainSafeLast(c) {
3108 // just not whitespace or colon, it will be checked to be plain character later
3109 return !isWhitespace(c) && c !== CHAR_COLON;
3110 }
3111
3112 // Same as 'string'.codePointAt(pos), but works in older browsers.
3113 function codePointAt(string, pos) {
3114 var first = string.charCodeAt(pos), second;
3115 if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
3116 second = string.charCodeAt(pos + 1);
3117 if (second >= 0xDC00 && second <= 0xDFFF) {
3118 // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
3119 return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
3120 }
3121 }
3122 return first;
3123 }
3124
3125 // Determines whether block indentation indicator is required.
3126 function needIndentIndicator(string) {
3127 var leadingSpaceRe = /^\n* /;
3128 return leadingSpaceRe.test(string);
3129 }
3130
3131 var STYLE_PLAIN = 1,
3132 STYLE_SINGLE = 2,
3133 STYLE_LITERAL = 3,
3134 STYLE_FOLDED = 4,
3135 STYLE_DOUBLE = 5;
3136
3137 // Determines which scalar styles are possible and returns the preferred style.
3138 // lineWidth = -1 => no limit.
3139 // Pre-conditions: str.length > 0.
3140 // Post-conditions:
3141 // STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
3142 // STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
3143 // STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
3144 function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
3145 testAmbiguousType, quotingType, forceQuotes, inblock) {
3146
3147 var i;
3148 var char = 0;
3149 var prevChar = null;
3150 var hasLineBreak = false;
3151 var hasFoldableLine = false; // only checked if shouldTrackWidth
3152 var shouldTrackWidth = lineWidth !== -1;
3153 var previousLineBreak = -1; // count the first line correctly
3154 var plain = isPlainSafeFirst(codePointAt(string, 0))
3155 && isPlainSafeLast(codePointAt(string, string.length - 1));
3156
3157 if (singleLineOnly || forceQuotes) {
3158 // Case: no block styles.
3159 // Check for disallowed characters to rule out plain and single.
3160 for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3161 char = codePointAt(string, i);
3162 if (!isPrintable(char)) {
3163 return STYLE_DOUBLE;
3164 }
3165 plain = plain && isPlainSafe(char, prevChar, inblock);
3166 prevChar = char;
3167 }
3168 } else {
3169 // Case: block styles permitted.
3170 for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3171 char = codePointAt(string, i);
3172 if (char === CHAR_LINE_FEED) {
3173 hasLineBreak = true;
3174 // Check if any line can be folded.
3175 if (shouldTrackWidth) {
3176 hasFoldableLine = hasFoldableLine ||
3177 // Foldable line = too long, and not more-indented.
3178 (i - previousLineBreak - 1 > lineWidth &&
3179 string[previousLineBreak + 1] !== ' ');
3180 previousLineBreak = i;
3181 }
3182 } else if (!isPrintable(char)) {
3183 return STYLE_DOUBLE;
3184 }
3185 plain = plain && isPlainSafe(char, prevChar, inblock);
3186 prevChar = char;
3187 }
3188 // in case the end is missing a \n
3189 hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
3190 (i - previousLineBreak - 1 > lineWidth &&
3191 string[previousLineBreak + 1] !== ' '));
3192 }
3193 // Although every style can represent \n without escaping, prefer block styles
3194 // for multiline, since they're more readable and they don't add empty lines.
3195 // Also prefer folding a super-long line.
3196 if (!hasLineBreak && !hasFoldableLine) {
3197 // Strings interpretable as another type have to be quoted;
3198 // e.g. the string 'true' vs. the boolean true.
3199 if (plain && !forceQuotes && !testAmbiguousType(string)) {
3200 return STYLE_PLAIN;
3201 }
3202 return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
3203 }
3204 // Edge case: block indentation indicator can only have one digit.
3205 if (indentPerLevel > 9 && needIndentIndicator(string)) {
3206 return STYLE_DOUBLE;
3207 }
3208 // At this point we know block styles are valid.
3209 // Prefer literal style unless we want to fold.
3210 if (!forceQuotes) {
3211 return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
3212 }
3213 return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
3214 }
3215
3216 // Note: line breaking/folding is implemented for only the folded style.
3217 // NB. We drop the last trailing newline (if any) of a returned block scalar
3218 // since the dumper adds its own newline. This always works:
3219 // • No ending newline => unaffected; already using strip "-" chomping.
3220 // • Ending newline => removed then restored.
3221 // Importantly, this keeps the "+" chomp indicator from gaining an extra line.
3222 function writeScalar(state, string, level, iskey, inblock) {
3223 state.dump = (function () {
3224 if (string.length === 0) {
3225 return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
3226 }
3227 if (!state.noCompatMode) {
3228 if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
3229 return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
3230 }
3231 }
3232
3233 var indent = state.indent * Math.max(1, level); // no 0-indent scalars
3234 // As indentation gets deeper, let the width decrease monotonically
3235 // to the lower bound min(state.lineWidth, 40).
3236 // Note that this implies
3237 // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
3238 // state.lineWidth > 40 + state.indent: width decreases until the lower bound.
3239 // This behaves better than a constant minimum width which disallows narrower options,
3240 // or an indent threshold which causes the width to suddenly increase.
3241 var lineWidth = state.lineWidth === -1
3242 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
3243
3244 // Without knowing if keys are implicit/explicit, assume implicit for safety.
3245 var singleLineOnly = iskey
3246 // No block styles in flow mode.
3247 || (state.flowLevel > -1 && level >= state.flowLevel);
3248 function testAmbiguity(string) {
3249 return testImplicitResolving(state, string);
3250 }
3251
3252 switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
3253 testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
3254
3255 case STYLE_PLAIN:
3256 return string;
3257 case STYLE_SINGLE:
3258 return "'" + string.replace(/'/g, "''") + "'";
3259 case STYLE_LITERAL:
3260 return '|' + blockHeader(string, state.indent)
3261 + dropEndingNewline(indentString(string, indent));
3262 case STYLE_FOLDED:
3263 return '>' + blockHeader(string, state.indent)
3264 + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
3265 case STYLE_DOUBLE:
3266 return '"' + escapeString(string) + '"';
3267 default:
3268 throw new exception('impossible error: invalid scalar style');
3269 }
3270 }());
3271 }
3272
3273 // Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
3274 function blockHeader(string, indentPerLevel) {
3275 var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
3276
3277 // note the special case: the string '\n' counts as a "trailing" empty line.
3278 var clip = string[string.length - 1] === '\n';
3279 var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
3280 var chomp = keep ? '+' : (clip ? '' : '-');
3281
3282 return indentIndicator + chomp + '\n';
3283 }
3284
3285 // (See the note for writeScalar.)
3286 function dropEndingNewline(string) {
3287 return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
3288 }
3289
3290 // Note: a long line without a suitable break point will exceed the width limit.
3291 // Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
3292 function foldString(string, width) {
3293 // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
3294 // unless they're before or after a more-indented line, or at the very
3295 // beginning or end, in which case $k$ maps to $k$.
3296 // Therefore, parse each chunk as newline(s) followed by a content line.
3297 var lineRe = /(\n+)([^\n]*)/g;
3298
3299 // first line (possibly an empty line)
3300 var result = (function () {
3301 var nextLF = string.indexOf('\n');
3302 nextLF = nextLF !== -1 ? nextLF : string.length;
3303 lineRe.lastIndex = nextLF;
3304 return foldLine(string.slice(0, nextLF), width);
3305 }());
3306 // If we haven't reached the first content line yet, don't add an extra \n.
3307 var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
3308 var moreIndented;
3309
3310 // rest of the lines
3311 var match;
3312 while ((match = lineRe.exec(string))) {
3313 var prefix = match[1], line = match[2];
3314 moreIndented = (line[0] === ' ');
3315 result += prefix
3316 + (!prevMoreIndented && !moreIndented && line !== ''
3317 ? '\n' : '')
3318 + foldLine(line, width);
3319 prevMoreIndented = moreIndented;
3320 }
3321
3322 return result;
3323 }
3324
3325 // Greedy line breaking.
3326 // Picks the longest line under the limit each time,
3327 // otherwise settles for the shortest line over the limit.
3328 // NB. More-indented lines *cannot* be folded, as that would add an extra \n.
3329 function foldLine(line, width) {
3330 if (line === '' || line[0] === ' ') return line;
3331
3332 // Since a more-indented line adds a \n, breaks can't be followed by a space.
3333 var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
3334 var match;
3335 // start is an inclusive index. end, curr, and next are exclusive.
3336 var start = 0, end, curr = 0, next = 0;
3337 var result = '';
3338
3339 // Invariants: 0 <= start <= length-1.
3340 // 0 <= curr <= next <= max(0, length-2). curr - start <= width.
3341 // Inside the loop:
3342 // A match implies length >= 2, so curr and next are <= length-2.
3343 while ((match = breakRe.exec(line))) {
3344 next = match.index;
3345 // maintain invariant: curr - start <= width
3346 if (next - start > width) {
3347 end = (curr > start) ? curr : next; // derive end <= length-2
3348 result += '\n' + line.slice(start, end);
3349 // skip the space that was output as \n
3350 start = end + 1; // derive start <= length-1
3351 }
3352 curr = next;
3353 }
3354
3355 // By the invariants, start <= length-1, so there is something left over.
3356 // It is either the whole string or a part starting from non-whitespace.
3357 result += '\n';
3358 // Insert a break if the remainder is too long and there is a break available.
3359 if (line.length - start > width && curr > start) {
3360 result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
3361 } else {
3362 result += line.slice(start);
3363 }
3364
3365 return result.slice(1); // drop extra \n joiner
3366 }
3367
3368 // Escapes a double-quoted string.
3369 function escapeString(string) {
3370 var result = '';
3371 var char = 0;
3372 var escapeSeq;
3373
3374 for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
3375 char = codePointAt(string, i);
3376 escapeSeq = ESCAPE_SEQUENCES[char];
3377
3378 if (!escapeSeq && isPrintable(char)) {
3379 result += string[i];
3380 if (char >= 0x10000) result += string[i + 1];
3381 } else {
3382 result += escapeSeq || encodeHex(char);
3383 }
3384 }
3385
3386 return result;
3387 }
3388
3389 function writeFlowSequence(state, level, object) {
3390 var _result = '',
3391 _tag = state.tag,
3392 index,
3393 length,
3394 value;
3395
3396 for (index = 0, length = object.length; index < length; index += 1) {
3397 value = object[index];
3398
3399 if (state.replacer) {
3400 value = state.replacer.call(object, String(index), value);
3401 }
3402
3403 // Write only valid elements, put null instead of invalid elements.
3404 if (writeNode(state, level, value, false, false) ||
3405 (typeof value === 'undefined' &&
3406 writeNode(state, level, null, false, false))) {
3407
3408 if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
3409 _result += state.dump;
3410 }
3411 }
3412
3413 state.tag = _tag;
3414 state.dump = '[' + _result + ']';
3415 }
3416
3417 function writeBlockSequence(state, level, object, compact) {
3418 var _result = '',
3419 _tag = state.tag,
3420 index,
3421 length,
3422 value;
3423
3424 for (index = 0, length = object.length; index < length; index += 1) {
3425 value = object[index];
3426
3427 if (state.replacer) {
3428 value = state.replacer.call(object, String(index), value);
3429 }
3430
3431 // Write only valid elements, put null instead of invalid elements.
3432 if (writeNode(state, level + 1, value, true, true, false, true) ||
3433 (typeof value === 'undefined' &&
3434 writeNode(state, level + 1, null, true, true, false, true))) {
3435
3436 if (!compact || _result !== '') {
3437 _result += generateNextLine(state, level);
3438 }
3439
3440 if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3441 _result += '-';
3442 } else {
3443 _result += '- ';
3444 }
3445
3446 _result += state.dump;
3447 }
3448 }
3449
3450 state.tag = _tag;
3451 state.dump = _result || '[]'; // Empty sequence if no valid values.
3452 }
3453
3454 function writeFlowMapping(state, level, object) {
3455 var _result = '',
3456 _tag = state.tag,
3457 objectKeyList = Object.keys(object),
3458 index,
3459 length,
3460 objectKey,
3461 objectValue,
3462 pairBuffer;
3463
3464 for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3465
3466 pairBuffer = '';
3467 if (_result !== '') pairBuffer += ', ';
3468
3469 if (state.condenseFlow) pairBuffer += '"';
3470
3471 objectKey = objectKeyList[index];
3472 objectValue = object[objectKey];
3473
3474 if (state.replacer) {
3475 objectValue = state.replacer.call(object, objectKey, objectValue);
3476 }
3477
3478 if (!writeNode(state, level, objectKey, false, false)) {
3479 continue; // Skip this pair because of invalid key;
3480 }
3481
3482 if (state.dump.length > 1024) pairBuffer += '? ';
3483
3484 pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
3485
3486 if (!writeNode(state, level, objectValue, false, false)) {
3487 continue; // Skip this pair because of invalid value.
3488 }
3489
3490 pairBuffer += state.dump;
3491
3492 // Both key and value are valid.
3493 _result += pairBuffer;
3494 }
3495
3496 state.tag = _tag;
3497 state.dump = '{' + _result + '}';
3498 }
3499
3500 function writeBlockMapping(state, level, object, compact) {
3501 var _result = '',
3502 _tag = state.tag,
3503 objectKeyList = Object.keys(object),
3504 index,
3505 length,
3506 objectKey,
3507 objectValue,
3508 explicitPair,
3509 pairBuffer;
3510
3511 // Allow sorting keys so that the output file is deterministic
3512 if (state.sortKeys === true) {
3513 // Default sorting
3514 objectKeyList.sort();
3515 } else if (typeof state.sortKeys === 'function') {
3516 // Custom sort function
3517 objectKeyList.sort(state.sortKeys);
3518 } else if (state.sortKeys) {
3519 // Something is wrong
3520 throw new exception('sortKeys must be a boolean or a function');
3521 }
3522
3523 for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3524 pairBuffer = '';
3525
3526 if (!compact || _result !== '') {
3527 pairBuffer += generateNextLine(state, level);
3528 }
3529
3530 objectKey = objectKeyList[index];
3531 objectValue = object[objectKey];
3532
3533 if (state.replacer) {
3534 objectValue = state.replacer.call(object, objectKey, objectValue);
3535 }
3536
3537 if (!writeNode(state, level + 1, objectKey, true, true, true)) {
3538 continue; // Skip this pair because of invalid key.
3539 }
3540
3541 explicitPair = (state.tag !== null && state.tag !== '?') ||
3542 (state.dump && state.dump.length > 1024);
3543
3544 if (explicitPair) {
3545 if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3546 pairBuffer += '?';
3547 } else {
3548 pairBuffer += '? ';
3549 }
3550 }
3551
3552 pairBuffer += state.dump;
3553
3554 if (explicitPair) {
3555 pairBuffer += generateNextLine(state, level);
3556 }
3557
3558 if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
3559 continue; // Skip this pair because of invalid value.
3560 }
3561
3562 if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
3563 pairBuffer += ':';
3564 } else {
3565 pairBuffer += ': ';
3566 }
3567
3568 pairBuffer += state.dump;
3569
3570 // Both key and value are valid.
3571 _result += pairBuffer;
3572 }
3573
3574 state.tag = _tag;
3575 state.dump = _result || '{}'; // Empty mapping if no valid pairs.
3576 }
3577
3578 function detectType(state, object, explicit) {
3579 var _result, typeList, index, length, type, style;
3580
3581 typeList = explicit ? state.explicitTypes : state.implicitTypes;
3582
3583 for (index = 0, length = typeList.length; index < length; index += 1) {
3584 type = typeList[index];
3585
3586 if ((type.instanceOf || type.predicate) &&
3587 (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
3588 (!type.predicate || type.predicate(object))) {
3589
3590 if (explicit) {
3591 if (type.multi && type.representName) {
3592 state.tag = type.representName(object);
3593 } else {
3594 state.tag = type.tag;
3595 }
3596 } else {
3597 state.tag = '?';
3598 }
3599
3600 if (type.represent) {
3601 style = state.styleMap[type.tag] || type.defaultStyle;
3602
3603 if (_toString.call(type.represent) === '[object Function]') {
3604 _result = type.represent(object, style);
3605 } else if (_hasOwnProperty.call(type.represent, style)) {
3606 _result = type.represent[style](object, style);
3607 } else {
3608 throw new exception('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
3609 }
3610
3611 state.dump = _result;
3612 }
3613
3614 return true;
3615 }
3616 }
3617
3618 return false;
3619 }
3620
3621 // Serializes `object` and writes it to global `result`.
3622 // Returns true on success, or false on invalid object.
3623 //
3624 function writeNode(state, level, object, block, compact, iskey, isblockseq) {
3625 state.tag = null;
3626 state.dump = object;
3627
3628 if (!detectType(state, object, false)) {
3629 detectType(state, object, true);
3630 }
3631
3632 var type = _toString.call(state.dump);
3633 var inblock = block;
3634 var tagStr;
3635
3636 if (block) {
3637 block = (state.flowLevel < 0 || state.flowLevel > level);
3638 }
3639
3640 var objectOrArray = type === '[object Object]' || type === '[object Array]',
3641 duplicateIndex,
3642 duplicate;
3643
3644 if (objectOrArray) {
3645 duplicateIndex = state.duplicates.indexOf(object);
3646 duplicate = duplicateIndex !== -1;
3647 }
3648
3649 if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
3650 compact = false;
3651 }
3652
3653 if (duplicate && state.usedDuplicates[duplicateIndex]) {
3654 state.dump = '*ref_' + duplicateIndex;
3655 } else {
3656 if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
3657 state.usedDuplicates[duplicateIndex] = true;
3658 }
3659 if (type === '[object Object]') {
3660 if (block && (Object.keys(state.dump).length !== 0)) {
3661 writeBlockMapping(state, level, state.dump, compact);
3662 if (duplicate) {
3663 state.dump = '&ref_' + duplicateIndex + state.dump;
3664 }
3665 } else {
3666 writeFlowMapping(state, level, state.dump);
3667 if (duplicate) {
3668 state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
3669 }
3670 }
3671 } else if (type === '[object Array]') {
3672 if (block && (state.dump.length !== 0)) {
3673 if (state.noArrayIndent && !isblockseq && level > 0) {
3674 writeBlockSequence(state, level - 1, state.dump, compact);
3675 } else {
3676 writeBlockSequence(state, level, state.dump, compact);
3677 }
3678 if (duplicate) {
3679 state.dump = '&ref_' + duplicateIndex + state.dump;
3680 }
3681 } else {
3682 writeFlowSequence(state, level, state.dump);
3683 if (duplicate) {
3684 state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
3685 }
3686 }
3687 } else if (type === '[object String]') {
3688 if (state.tag !== '?') {
3689 writeScalar(state, state.dump, level, iskey, inblock);
3690 }
3691 } else if (type === '[object Undefined]') {
3692 return false;
3693 } else {
3694 if (state.skipInvalid) return false;
3695 throw new exception('unacceptable kind of an object to dump ' + type);
3696 }
3697
3698 if (state.tag !== null && state.tag !== '?') {
3699 // Need to encode all characters except those allowed by the spec:
3700 //
3701 // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
3702 // [36] ns-hex-digit ::= ns-dec-digit
3703 // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
3704 // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
3705 // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
3706 // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
3707 // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
3708 // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
3709 //
3710 // Also need to encode '!' because it has special meaning (end of tag prefix).
3711 //
3712 tagStr = encodeURI(
3713 state.tag[0] === '!' ? state.tag.slice(1) : state.tag
3714 ).replace(/!/g, '%21');
3715
3716 if (state.tag[0] === '!') {
3717 tagStr = '!' + tagStr;
3718 } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
3719 tagStr = '!!' + tagStr.slice(18);
3720 } else {
3721 tagStr = '!<' + tagStr + '>';
3722 }
3723
3724 state.dump = tagStr + ' ' + state.dump;
3725 }
3726 }
3727
3728 return true;
3729 }
3730
3731 function getDuplicateReferences(object, state) {
3732 var objects = [],
3733 duplicatesIndexes = [],
3734 index,
3735 length;
3736
3737 inspectNode(object, objects, duplicatesIndexes);
3738
3739 for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
3740 state.duplicates.push(objects[duplicatesIndexes[index]]);
3741 }
3742 state.usedDuplicates = new Array(length);
3743 }
3744
3745 function inspectNode(object, objects, duplicatesIndexes) {
3746 var objectKeyList,
3747 index,
3748 length;
3749
3750 if (object !== null && typeof object === 'object') {
3751 index = objects.indexOf(object);
3752 if (index !== -1) {
3753 if (duplicatesIndexes.indexOf(index) === -1) {
3754 duplicatesIndexes.push(index);
3755 }
3756 } else {
3757 objects.push(object);
3758
3759 if (Array.isArray(object)) {
3760 for (index = 0, length = object.length; index < length; index += 1) {
3761 inspectNode(object[index], objects, duplicatesIndexes);
3762 }
3763 } else {
3764 objectKeyList = Object.keys(object);
3765
3766 for (index = 0, length = objectKeyList.length; index < length; index += 1) {
3767 inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
3768 }
3769 }
3770 }
3771 }
3772 }
3773
3774 function dump$1(input, options) {
3775 options = options || {};
3776
3777 var state = new State(options);
3778
3779 if (!state.noRefs) getDuplicateReferences(input, state);
3780
3781 var value = input;
3782
3783 if (state.replacer) {
3784 value = state.replacer.call({ '': value }, '', value);
3785 }
3786
3787 if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
3788
3789 return '';
3790 }
3791
3792 var dump_1 = dump$1;
3793
3794 var dumper = {
3795 dump: dump_1
3796 };
3797
3798 function renamed(from, to) {
3799 return function () {
3800 throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
3801 'Use yaml.' + to + ' instead, which is now safe by default.');
3802 };
3803 }
3804
3805
3806 var Type = type;
3807 var Schema = schema;
3808 var FAILSAFE_SCHEMA = failsafe;
3809 var JSON_SCHEMA = json;
3810 var CORE_SCHEMA = core;
3811 var DEFAULT_SCHEMA = _default;
3812 var load = loader.load;
3813 var loadAll = loader.loadAll;
3814 var dump = dumper.dump;
3815 var YAMLException = exception;
3816
3817 // Re-export all types in case user wants to create custom schema
3818 var types = {
3819 binary: binary,
3820 float: float,
3821 map: map,
3822 null: _null,
3823 pairs: pairs,
3824 set: set,
3825 timestamp: timestamp,
3826 bool: bool,
3827 int: int,
3828 merge: merge,
3829 omap: omap,
3830 seq: seq,
3831 str: str
3832 };
3833
3834 // Removed functions from JS-YAML 3.0.x
3835 var safeLoad = renamed('safeLoad', 'load');
3836 var safeLoadAll = renamed('safeLoadAll', 'loadAll');
3837 var safeDump = renamed('safeDump', 'dump');
3838
3839 var jsYaml = {
3840 Type: Type,
3841 Schema: Schema,
3842 FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
3843 JSON_SCHEMA: JSON_SCHEMA,
3844 CORE_SCHEMA: CORE_SCHEMA,
3845 DEFAULT_SCHEMA: DEFAULT_SCHEMA,
3846 load: load,
3847 loadAll: loadAll,
3848 dump: dump,
3849 YAMLException: YAMLException,
3850 types: types,
3851 safeLoad: safeLoad,
3852 safeLoadAll: safeLoadAll,
3853 safeDump: safeDump
3854 };
3855
3856 exports.CORE_SCHEMA = CORE_SCHEMA;
3857 exports.DEFAULT_SCHEMA = DEFAULT_SCHEMA;
3858 exports.FAILSAFE_SCHEMA = FAILSAFE_SCHEMA;
3859 exports.JSON_SCHEMA = JSON_SCHEMA;
3860 exports.Schema = Schema;
3861 exports.Type = Type;
3862 exports.YAMLException = YAMLException;
3863 exports.default = jsYaml;
3864 exports.dump = dump;
3865 exports.load = load;
3866 exports.loadAll = loadAll;
3867 exports.safeDump = safeDump;
3868 exports.safeLoad = safeLoad;
3869 exports.safeLoadAll = safeLoadAll;
3870 exports.types = types;
3871
3872 Object.defineProperty(exports, '__esModule', { value: true });
3873
3874})));
Note: See TracBrowser for help on using the repository browser.