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;
vendor: 9,879 bytes, lines 1558-1907
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);
vendor: 5,197 bytes, lines 2222-2410
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 === no
2553deContext)) { 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})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.