|
|
@@ -1,1893 +0,0 @@
|
|
|
-(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
|
-var Dumper, Inline, Utils;
|
|
|
-
|
|
|
-Utils = require('./Utils');
|
|
|
-
|
|
|
-Inline = require('./Inline');
|
|
|
-
|
|
|
-Dumper = (function() {
|
|
|
- function Dumper() {}
|
|
|
-
|
|
|
- Dumper.indentation = 4;
|
|
|
-
|
|
|
- Dumper.prototype.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
|
- var i, key, len, output, prefix, value, willBeInlined;
|
|
|
- if (inline == null) {
|
|
|
- inline = 0;
|
|
|
- }
|
|
|
- if (indent == null) {
|
|
|
- indent = 0;
|
|
|
- }
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectEncoder == null) {
|
|
|
- objectEncoder = null;
|
|
|
- }
|
|
|
- output = '';
|
|
|
- prefix = (indent ? Utils.strRepeat(' ', indent) : '');
|
|
|
- if (inline <= 0 || typeof input !== 'object' || input instanceof Date || Utils.isEmpty(input)) {
|
|
|
- output += prefix + Inline.dump(input, exceptionOnInvalidType, objectEncoder);
|
|
|
- } else {
|
|
|
- if (input instanceof Array) {
|
|
|
- for (i = 0, len = input.length; i < len; i++) {
|
|
|
- value = input[i];
|
|
|
- willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
|
|
|
- output += prefix + '-' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (key in input) {
|
|
|
- value = input[key];
|
|
|
- willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
|
|
|
- output += prefix + Inline.dump(key, exceptionOnInvalidType, objectEncoder) + ':' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return output;
|
|
|
- };
|
|
|
-
|
|
|
- return Dumper;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Dumper;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Inline":6,"./Utils":10}],2:[function(require,module,exports){
|
|
|
-var Escaper, Pattern;
|
|
|
-
|
|
|
-Pattern = require('./Pattern');
|
|
|
-
|
|
|
-Escaper = (function() {
|
|
|
- var ch;
|
|
|
-
|
|
|
- function Escaper() {}
|
|
|
-
|
|
|
- Escaper.LIST_ESCAPEES = ['\\', '\\\\', '\\"', '"', "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0a", "\x0b", "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1a", "\x1b", "\x1c", "\x1d", "\x1e", "\x1f", (ch = String.fromCharCode)(0x0085), ch(0x00A0), ch(0x2028), ch(0x2029)];
|
|
|
-
|
|
|
- Escaper.LIST_ESCAPED = ['\\\\', '\\"', '\\"', '\\"', "\\0", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06", "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r", "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19", "\\x1a", "\\e", "\\x1c", "\\x1d", "\\x1e", "\\x1f", "\\N", "\\_", "\\L", "\\P"];
|
|
|
-
|
|
|
- Escaper.MAPPING_ESCAPEES_TO_ESCAPED = (function() {
|
|
|
- var i, j, mapping, ref;
|
|
|
- mapping = {};
|
|
|
- for (i = j = 0, ref = Escaper.LIST_ESCAPEES.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
|
|
|
- mapping[Escaper.LIST_ESCAPEES[i]] = Escaper.LIST_ESCAPED[i];
|
|
|
- }
|
|
|
- return mapping;
|
|
|
- })();
|
|
|
-
|
|
|
- Escaper.PATTERN_CHARACTERS_TO_ESCAPE = new Pattern('[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9');
|
|
|
-
|
|
|
- Escaper.PATTERN_MAPPING_ESCAPEES = new Pattern(Escaper.LIST_ESCAPEES.join('|').split('\\').join('\\\\'));
|
|
|
-
|
|
|
- Escaper.PATTERN_SINGLE_QUOTING = new Pattern('[\\s\'":{}[\\],&*#?]|^[-?|<>=!%@`]');
|
|
|
-
|
|
|
- Escaper.requiresDoubleQuoting = function(value) {
|
|
|
- return this.PATTERN_CHARACTERS_TO_ESCAPE.test(value);
|
|
|
- };
|
|
|
-
|
|
|
- Escaper.escapeWithDoubleQuotes = function(value) {
|
|
|
- var result;
|
|
|
- result = this.PATTERN_MAPPING_ESCAPEES.replace(value, (function(_this) {
|
|
|
- return function(str) {
|
|
|
- return _this.MAPPING_ESCAPEES_TO_ESCAPED[str];
|
|
|
- };
|
|
|
- })(this));
|
|
|
- return '"' + result + '"';
|
|
|
- };
|
|
|
-
|
|
|
- Escaper.requiresSingleQuoting = function(value) {
|
|
|
- return this.PATTERN_SINGLE_QUOTING.test(value);
|
|
|
- };
|
|
|
-
|
|
|
- Escaper.escapeWithSingleQuotes = function(value) {
|
|
|
- return "'" + value.replace(/'/g, "''") + "'";
|
|
|
- };
|
|
|
-
|
|
|
- return Escaper;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Escaper;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Pattern":8}],3:[function(require,module,exports){
|
|
|
-var DumpException,
|
|
|
- extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
|
|
- hasProp = {}.hasOwnProperty;
|
|
|
-
|
|
|
-DumpException = (function(superClass) {
|
|
|
- extend(DumpException, superClass);
|
|
|
-
|
|
|
- function DumpException(message, parsedLine, snippet) {
|
|
|
- this.message = message;
|
|
|
- this.parsedLine = parsedLine;
|
|
|
- this.snippet = snippet;
|
|
|
- }
|
|
|
-
|
|
|
- DumpException.prototype.toString = function() {
|
|
|
- if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
|
- return '<DumpException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
|
- } else {
|
|
|
- return '<DumpException> ' + this.message;
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return DumpException;
|
|
|
-
|
|
|
-})(Error);
|
|
|
-
|
|
|
-module.exports = DumpException;
|
|
|
-
|
|
|
-
|
|
|
-},{}],4:[function(require,module,exports){
|
|
|
-var ParseException,
|
|
|
- extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
|
|
- hasProp = {}.hasOwnProperty;
|
|
|
-
|
|
|
-ParseException = (function(superClass) {
|
|
|
- extend(ParseException, superClass);
|
|
|
-
|
|
|
- function ParseException(message, parsedLine, snippet) {
|
|
|
- this.message = message;
|
|
|
- this.parsedLine = parsedLine;
|
|
|
- this.snippet = snippet;
|
|
|
- }
|
|
|
-
|
|
|
- ParseException.prototype.toString = function() {
|
|
|
- if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
|
- return '<ParseException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
|
- } else {
|
|
|
- return '<ParseException> ' + this.message;
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return ParseException;
|
|
|
-
|
|
|
-})(Error);
|
|
|
-
|
|
|
-module.exports = ParseException;
|
|
|
-
|
|
|
-
|
|
|
-},{}],5:[function(require,module,exports){
|
|
|
-var ParseMore,
|
|
|
- extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
|
|
- hasProp = {}.hasOwnProperty;
|
|
|
-
|
|
|
-ParseMore = (function(superClass) {
|
|
|
- extend(ParseMore, superClass);
|
|
|
-
|
|
|
- function ParseMore(message, parsedLine, snippet) {
|
|
|
- this.message = message;
|
|
|
- this.parsedLine = parsedLine;
|
|
|
- this.snippet = snippet;
|
|
|
- }
|
|
|
-
|
|
|
- ParseMore.prototype.toString = function() {
|
|
|
- if ((this.parsedLine != null) && (this.snippet != null)) {
|
|
|
- return '<ParseMore> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
|
|
|
- } else {
|
|
|
- return '<ParseMore> ' + this.message;
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return ParseMore;
|
|
|
-
|
|
|
-})(Error);
|
|
|
-
|
|
|
-module.exports = ParseMore;
|
|
|
-
|
|
|
-
|
|
|
-},{}],6:[function(require,module,exports){
|
|
|
-var DumpException, Escaper, Inline, ParseException, ParseMore, Pattern, Unescaper, Utils,
|
|
|
- indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
|
|
|
-
|
|
|
-Pattern = require('./Pattern');
|
|
|
-
|
|
|
-Unescaper = require('./Unescaper');
|
|
|
-
|
|
|
-Escaper = require('./Escaper');
|
|
|
-
|
|
|
-Utils = require('./Utils');
|
|
|
-
|
|
|
-ParseException = require('./Exception/ParseException');
|
|
|
-
|
|
|
-ParseMore = require('./Exception/ParseMore');
|
|
|
-
|
|
|
-DumpException = require('./Exception/DumpException');
|
|
|
-
|
|
|
-Inline = (function() {
|
|
|
- function Inline() {}
|
|
|
-
|
|
|
- Inline.REGEX_QUOTED_STRING = '(?:"(?:[^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'(?:[^\']*(?:\'\'[^\']*)*)\')';
|
|
|
-
|
|
|
- Inline.PATTERN_TRAILING_COMMENTS = new Pattern('^\\s*#.*$');
|
|
|
-
|
|
|
- Inline.PATTERN_QUOTED_SCALAR = new Pattern('^' + Inline.REGEX_QUOTED_STRING);
|
|
|
-
|
|
|
- Inline.PATTERN_THOUSAND_NUMERIC_SCALAR = new Pattern('^(-|\\+)?[0-9,]+(\\.[0-9]+)?$');
|
|
|
-
|
|
|
- Inline.PATTERN_SCALAR_BY_DELIMITERS = {};
|
|
|
-
|
|
|
- Inline.settings = {};
|
|
|
-
|
|
|
- Inline.configure = function(exceptionOnInvalidType, objectDecoder) {
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = null;
|
|
|
- }
|
|
|
- if (objectDecoder == null) {
|
|
|
- objectDecoder = null;
|
|
|
- }
|
|
|
- this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
|
|
|
- this.settings.objectDecoder = objectDecoder;
|
|
|
- };
|
|
|
-
|
|
|
- Inline.parse = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
|
- var context, result;
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectDecoder == null) {
|
|
|
- objectDecoder = null;
|
|
|
- }
|
|
|
- this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
|
|
|
- this.settings.objectDecoder = objectDecoder;
|
|
|
- if (value == null) {
|
|
|
- return '';
|
|
|
- }
|
|
|
- value = Utils.trim(value);
|
|
|
- if (0 === value.length) {
|
|
|
- return '';
|
|
|
- }
|
|
|
- context = {
|
|
|
- exceptionOnInvalidType: exceptionOnInvalidType,
|
|
|
- objectDecoder: objectDecoder,
|
|
|
- i: 0
|
|
|
- };
|
|
|
- switch (value.charAt(0)) {
|
|
|
- case '[':
|
|
|
- result = this.parseSequence(value, context);
|
|
|
- ++context.i;
|
|
|
- break;
|
|
|
- case '{':
|
|
|
- result = this.parseMapping(value, context);
|
|
|
- ++context.i;
|
|
|
- break;
|
|
|
- default:
|
|
|
- result = this.parseScalar(value, null, ['"', "'"], context);
|
|
|
- }
|
|
|
- if (this.PATTERN_TRAILING_COMMENTS.replace(value.slice(context.i), '') !== '') {
|
|
|
- throw new ParseException('Unexpected characters near "' + value.slice(context.i) + '".');
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
-
|
|
|
- Inline.dump = function(value, exceptionOnInvalidType, objectEncoder) {
|
|
|
- var ref, result, type;
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectEncoder == null) {
|
|
|
- objectEncoder = null;
|
|
|
- }
|
|
|
- if (value == null) {
|
|
|
- return 'null';
|
|
|
- }
|
|
|
- type = typeof value;
|
|
|
- if (type === 'object') {
|
|
|
- if (value instanceof Date) {
|
|
|
- return value.toISOString();
|
|
|
- } else if (objectEncoder != null) {
|
|
|
- result = objectEncoder(value);
|
|
|
- if (typeof result === 'string' || (result != null)) {
|
|
|
- return result;
|
|
|
- }
|
|
|
- }
|
|
|
- return this.dumpObject(value);
|
|
|
- }
|
|
|
- if (type === 'boolean') {
|
|
|
- return (value ? 'true' : 'false');
|
|
|
- }
|
|
|
- if (Utils.isDigits(value)) {
|
|
|
- return (type === 'string' ? "'" + value + "'" : String(parseInt(value)));
|
|
|
- }
|
|
|
- if (Utils.isNumeric(value)) {
|
|
|
- return (type === 'string' ? "'" + value + "'" : String(parseFloat(value)));
|
|
|
- }
|
|
|
- if (type === 'number') {
|
|
|
- return (value === Infinity ? '.Inf' : (value === -Infinity ? '-.Inf' : (isNaN(value) ? '.NaN' : value)));
|
|
|
- }
|
|
|
- if (Escaper.requiresDoubleQuoting(value)) {
|
|
|
- return Escaper.escapeWithDoubleQuotes(value);
|
|
|
- }
|
|
|
- if (Escaper.requiresSingleQuoting(value)) {
|
|
|
- return Escaper.escapeWithSingleQuotes(value);
|
|
|
- }
|
|
|
- if ('' === value) {
|
|
|
- return '""';
|
|
|
- }
|
|
|
- if (Utils.PATTERN_DATE.test(value)) {
|
|
|
- return "'" + value + "'";
|
|
|
- }
|
|
|
- if ((ref = value.toLowerCase()) === 'null' || ref === '~' || ref === 'true' || ref === 'false') {
|
|
|
- return "'" + value + "'";
|
|
|
- }
|
|
|
- return value;
|
|
|
- };
|
|
|
-
|
|
|
- Inline.dumpObject = function(value, exceptionOnInvalidType, objectSupport) {
|
|
|
- var j, key, len1, output, val;
|
|
|
- if (objectSupport == null) {
|
|
|
- objectSupport = null;
|
|
|
- }
|
|
|
- if (value instanceof Array) {
|
|
|
- output = [];
|
|
|
- for (j = 0, len1 = value.length; j < len1; j++) {
|
|
|
- val = value[j];
|
|
|
- output.push(this.dump(val));
|
|
|
- }
|
|
|
- return '[' + output.join(', ') + ']';
|
|
|
- } else {
|
|
|
- output = [];
|
|
|
- for (key in value) {
|
|
|
- val = value[key];
|
|
|
- output.push(this.dump(key) + ': ' + this.dump(val));
|
|
|
- }
|
|
|
- return '{' + output.join(', ') + '}';
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- Inline.parseScalar = function(scalar, delimiters, stringDelimiters, context, evaluate) {
|
|
|
- var i, joinedDelimiters, match, output, pattern, ref, ref1, strpos, tmp;
|
|
|
- if (delimiters == null) {
|
|
|
- delimiters = null;
|
|
|
- }
|
|
|
- if (stringDelimiters == null) {
|
|
|
- stringDelimiters = ['"', "'"];
|
|
|
- }
|
|
|
- if (context == null) {
|
|
|
- context = null;
|
|
|
- }
|
|
|
- if (evaluate == null) {
|
|
|
- evaluate = true;
|
|
|
- }
|
|
|
- if (context == null) {
|
|
|
- context = {
|
|
|
- exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
|
|
|
- objectDecoder: this.settings.objectDecoder,
|
|
|
- i: 0
|
|
|
- };
|
|
|
- }
|
|
|
- i = context.i;
|
|
|
- if (ref = scalar.charAt(i), indexOf.call(stringDelimiters, ref) >= 0) {
|
|
|
- output = this.parseQuotedScalar(scalar, context);
|
|
|
- i = context.i;
|
|
|
- if (delimiters != null) {
|
|
|
- tmp = Utils.ltrim(scalar.slice(i), ' ');
|
|
|
- if (!(ref1 = tmp.charAt(0), indexOf.call(delimiters, ref1) >= 0)) {
|
|
|
- throw new ParseException('Unexpected characters (' + scalar.slice(i) + ').');
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (!delimiters) {
|
|
|
- output = scalar.slice(i);
|
|
|
- i += output.length;
|
|
|
- strpos = output.indexOf(' #');
|
|
|
- if (strpos !== -1) {
|
|
|
- output = Utils.rtrim(output.slice(0, strpos));
|
|
|
- }
|
|
|
- } else {
|
|
|
- joinedDelimiters = delimiters.join('|');
|
|
|
- pattern = this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters];
|
|
|
- if (pattern == null) {
|
|
|
- pattern = new Pattern('^(.+?)(' + joinedDelimiters + ')');
|
|
|
- this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters] = pattern;
|
|
|
- }
|
|
|
- if (match = pattern.exec(scalar.slice(i))) {
|
|
|
- output = match[1];
|
|
|
- i += output.length;
|
|
|
- } else {
|
|
|
- throw new ParseException('Malformed inline YAML string (' + scalar + ').');
|
|
|
- }
|
|
|
- }
|
|
|
- if (evaluate) {
|
|
|
- output = this.evaluateScalar(output, context);
|
|
|
- }
|
|
|
- }
|
|
|
- context.i = i;
|
|
|
- return output;
|
|
|
- };
|
|
|
-
|
|
|
- Inline.parseQuotedScalar = function(scalar, context) {
|
|
|
- var i, match, output;
|
|
|
- i = context.i;
|
|
|
- if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
|
|
|
- throw new ParseMore('Malformed inline YAML string (' + scalar.slice(i) + ').');
|
|
|
- }
|
|
|
- output = match[0].substr(1, match[0].length - 2);
|
|
|
- if ('"' === scalar.charAt(i)) {
|
|
|
- output = Unescaper.unescapeDoubleQuotedString(output);
|
|
|
- } else {
|
|
|
- output = Unescaper.unescapeSingleQuotedString(output);
|
|
|
- }
|
|
|
- i += match[0].length;
|
|
|
- context.i = i;
|
|
|
- return output;
|
|
|
- };
|
|
|
-
|
|
|
- Inline.parseSequence = function(sequence, context) {
|
|
|
- var e, error, i, isQuoted, len, output, ref, value;
|
|
|
- output = [];
|
|
|
- len = sequence.length;
|
|
|
- i = context.i;
|
|
|
- i += 1;
|
|
|
- while (i < len) {
|
|
|
- context.i = i;
|
|
|
- switch (sequence.charAt(i)) {
|
|
|
- case '[':
|
|
|
- output.push(this.parseSequence(sequence, context));
|
|
|
- i = context.i;
|
|
|
- break;
|
|
|
- case '{':
|
|
|
- output.push(this.parseMapping(sequence, context));
|
|
|
- i = context.i;
|
|
|
- break;
|
|
|
- case ']':
|
|
|
- return output;
|
|
|
- case ',':
|
|
|
- case ' ':
|
|
|
- case "\n":
|
|
|
- break;
|
|
|
- default:
|
|
|
- isQuoted = ((ref = sequence.charAt(i)) === '"' || ref === "'");
|
|
|
- value = this.parseScalar(sequence, [',', ']'], ['"', "'"], context);
|
|
|
- i = context.i;
|
|
|
- if (!isQuoted && typeof value === 'string' && (value.indexOf(': ') !== -1 || value.indexOf(":\n") !== -1)) {
|
|
|
- try {
|
|
|
- value = this.parseMapping('{' + value + '}');
|
|
|
- } catch (error) {
|
|
|
- e = error;
|
|
|
- }
|
|
|
- }
|
|
|
- output.push(value);
|
|
|
- --i;
|
|
|
- }
|
|
|
- ++i;
|
|
|
- }
|
|
|
- throw new ParseMore('Malformed inline YAML string ' + sequence);
|
|
|
- };
|
|
|
-
|
|
|
- Inline.parseMapping = function(mapping, context) {
|
|
|
- var done, i, key, len, output, shouldContinueWhileLoop, value;
|
|
|
- output = {};
|
|
|
- len = mapping.length;
|
|
|
- i = context.i;
|
|
|
- i += 1;
|
|
|
- shouldContinueWhileLoop = false;
|
|
|
- while (i < len) {
|
|
|
- context.i = i;
|
|
|
- switch (mapping.charAt(i)) {
|
|
|
- case ' ':
|
|
|
- case ',':
|
|
|
- case "\n":
|
|
|
- ++i;
|
|
|
- context.i = i;
|
|
|
- shouldContinueWhileLoop = true;
|
|
|
- break;
|
|
|
- case '}':
|
|
|
- return output;
|
|
|
- }
|
|
|
- if (shouldContinueWhileLoop) {
|
|
|
- shouldContinueWhileLoop = false;
|
|
|
- continue;
|
|
|
- }
|
|
|
- key = this.parseScalar(mapping, [':', ' ', "\n"], ['"', "'"], context, false);
|
|
|
- i = context.i;
|
|
|
- done = false;
|
|
|
- while (i < len) {
|
|
|
- context.i = i;
|
|
|
- switch (mapping.charAt(i)) {
|
|
|
- case '[':
|
|
|
- value = this.parseSequence(mapping, context);
|
|
|
- i = context.i;
|
|
|
- if (output[key] === void 0) {
|
|
|
- output[key] = value;
|
|
|
- }
|
|
|
- done = true;
|
|
|
- break;
|
|
|
- case '{':
|
|
|
- value = this.parseMapping(mapping, context);
|
|
|
- i = context.i;
|
|
|
- if (output[key] === void 0) {
|
|
|
- output[key] = value;
|
|
|
- }
|
|
|
- done = true;
|
|
|
- break;
|
|
|
- case ':':
|
|
|
- case ' ':
|
|
|
- case "\n":
|
|
|
- break;
|
|
|
- default:
|
|
|
- value = this.parseScalar(mapping, [',', '}'], ['"', "'"], context);
|
|
|
- i = context.i;
|
|
|
- if (output[key] === void 0) {
|
|
|
- output[key] = value;
|
|
|
- }
|
|
|
- done = true;
|
|
|
- --i;
|
|
|
- }
|
|
|
- ++i;
|
|
|
- if (done) {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- throw new ParseMore('Malformed inline YAML string ' + mapping);
|
|
|
- };
|
|
|
-
|
|
|
- Inline.evaluateScalar = function(scalar, context) {
|
|
|
- var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw, scalarLower, subValue, trimmedScalar;
|
|
|
- scalar = Utils.trim(scalar);
|
|
|
- scalarLower = scalar.toLowerCase();
|
|
|
- switch (scalarLower) {
|
|
|
- case 'null':
|
|
|
- case '':
|
|
|
- case '~':
|
|
|
- return null;
|
|
|
- case 'true':
|
|
|
- return true;
|
|
|
- case 'false':
|
|
|
- return false;
|
|
|
- case '.inf':
|
|
|
- return Infinity;
|
|
|
- case '.nan':
|
|
|
- return NaN;
|
|
|
- case '-.inf':
|
|
|
- return Infinity;
|
|
|
- default:
|
|
|
- firstChar = scalarLower.charAt(0);
|
|
|
- switch (firstChar) {
|
|
|
- case '!':
|
|
|
- firstSpace = scalar.indexOf(' ');
|
|
|
- if (firstSpace === -1) {
|
|
|
- firstWord = scalarLower;
|
|
|
- } else {
|
|
|
- firstWord = scalarLower.slice(0, firstSpace);
|
|
|
- }
|
|
|
- switch (firstWord) {
|
|
|
- case '!':
|
|
|
- if (firstSpace !== -1) {
|
|
|
- return parseInt(this.parseScalar(scalar.slice(2)));
|
|
|
- }
|
|
|
- return null;
|
|
|
- case '!str':
|
|
|
- return Utils.ltrim(scalar.slice(4));
|
|
|
- case '!!str':
|
|
|
- return Utils.ltrim(scalar.slice(5));
|
|
|
- case '!!int':
|
|
|
- return parseInt(this.parseScalar(scalar.slice(5)));
|
|
|
- case '!!bool':
|
|
|
- return Utils.parseBoolean(this.parseScalar(scalar.slice(6)), false);
|
|
|
- case '!!float':
|
|
|
- return parseFloat(this.parseScalar(scalar.slice(7)));
|
|
|
- case '!!timestamp':
|
|
|
- return Utils.stringToDate(Utils.ltrim(scalar.slice(11)));
|
|
|
- default:
|
|
|
- if (context == null) {
|
|
|
- context = {
|
|
|
- exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
|
|
|
- objectDecoder: this.settings.objectDecoder,
|
|
|
- i: 0
|
|
|
- };
|
|
|
- }
|
|
|
- objectDecoder = context.objectDecoder, exceptionOnInvalidType = context.exceptionOnInvalidType;
|
|
|
- if (objectDecoder) {
|
|
|
- trimmedScalar = Utils.rtrim(scalar);
|
|
|
- firstSpace = trimmedScalar.indexOf(' ');
|
|
|
- if (firstSpace === -1) {
|
|
|
- return objectDecoder(trimmedScalar, null);
|
|
|
- } else {
|
|
|
- subValue = Utils.ltrim(trimmedScalar.slice(firstSpace + 1));
|
|
|
- if (!(subValue.length > 0)) {
|
|
|
- subValue = null;
|
|
|
- }
|
|
|
- return objectDecoder(trimmedScalar.slice(0, firstSpace), subValue);
|
|
|
- }
|
|
|
- }
|
|
|
- if (exceptionOnInvalidType) {
|
|
|
- throw new ParseException('Custom object support when parsing a YAML file has been disabled.');
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- break;
|
|
|
- case '0':
|
|
|
- if ('0x' === scalar.slice(0, 2)) {
|
|
|
- return Utils.hexDec(scalar);
|
|
|
- } else if (Utils.isDigits(scalar)) {
|
|
|
- return Utils.octDec(scalar);
|
|
|
- } else if (Utils.isNumeric(scalar)) {
|
|
|
- return parseFloat(scalar);
|
|
|
- } else {
|
|
|
- return scalar;
|
|
|
- }
|
|
|
- break;
|
|
|
- case '+':
|
|
|
- if (Utils.isDigits(scalar)) {
|
|
|
- raw = scalar;
|
|
|
- cast = parseInt(raw);
|
|
|
- if (raw === String(cast)) {
|
|
|
- return cast;
|
|
|
- } else {
|
|
|
- return raw;
|
|
|
- }
|
|
|
- } else if (Utils.isNumeric(scalar)) {
|
|
|
- return parseFloat(scalar);
|
|
|
- } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
|
- return parseFloat(scalar.replace(',', ''));
|
|
|
- }
|
|
|
- return scalar;
|
|
|
- case '-':
|
|
|
- if (Utils.isDigits(scalar.slice(1))) {
|
|
|
- if ('0' === scalar.charAt(1)) {
|
|
|
- return -Utils.octDec(scalar.slice(1));
|
|
|
- } else {
|
|
|
- raw = scalar.slice(1);
|
|
|
- cast = parseInt(raw);
|
|
|
- if (raw === String(cast)) {
|
|
|
- return -cast;
|
|
|
- } else {
|
|
|
- return -raw;
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (Utils.isNumeric(scalar)) {
|
|
|
- return parseFloat(scalar);
|
|
|
- } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
|
- return parseFloat(scalar.replace(',', ''));
|
|
|
- }
|
|
|
- return scalar;
|
|
|
- default:
|
|
|
- if (date = Utils.stringToDate(scalar)) {
|
|
|
- return date;
|
|
|
- } else if (Utils.isNumeric(scalar)) {
|
|
|
- return parseFloat(scalar);
|
|
|
- } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
|
|
|
- return parseFloat(scalar.replace(',', ''));
|
|
|
- }
|
|
|
- return scalar;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return Inline;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Inline;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Escaper":2,"./Exception/DumpException":3,"./Exception/ParseException":4,"./Exception/ParseMore":5,"./Pattern":8,"./Unescaper":9,"./Utils":10}],7:[function(require,module,exports){
|
|
|
-var Inline, ParseException, ParseMore, Parser, Pattern, Utils;
|
|
|
-
|
|
|
-Inline = require('./Inline');
|
|
|
-
|
|
|
-Pattern = require('./Pattern');
|
|
|
-
|
|
|
-Utils = require('./Utils');
|
|
|
-
|
|
|
-ParseException = require('./Exception/ParseException');
|
|
|
-
|
|
|
-ParseMore = require('./Exception/ParseMore');
|
|
|
-
|
|
|
-Parser = (function() {
|
|
|
- Parser.prototype.PATTERN_FOLDED_SCALAR_ALL = new Pattern('^(?:(?<type>![^\\|>]*)\\s+)?(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_FOLDED_SCALAR_END = new Pattern('(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_SEQUENCE_ITEM = new Pattern('^\\-((?<leadspaces>\\s+)(?<value>.+?))?\\s*$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_ANCHOR_VALUE = new Pattern('^&(?<ref>[^ ]+) *(?<value>.*)');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_COMPACT_NOTATION = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\{\\[].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_MAPPING_ITEM = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING + '|[^ \'"\\[\\{].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_DECIMAL = new Pattern('\\d+');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n', 'm');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+', 'm');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_DOCUMENT_MARKER_START = new Pattern('^\\-\\-\\-.*?\n', 'm');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_DOCUMENT_MARKER_END = new Pattern('^\\.\\.\\.\\s*$', 'm');
|
|
|
-
|
|
|
- Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION = {};
|
|
|
-
|
|
|
- Parser.prototype.CONTEXT_NONE = 0;
|
|
|
-
|
|
|
- Parser.prototype.CONTEXT_SEQUENCE = 1;
|
|
|
-
|
|
|
- Parser.prototype.CONTEXT_MAPPING = 2;
|
|
|
-
|
|
|
- function Parser(offset) {
|
|
|
- this.offset = offset != null ? offset : 0;
|
|
|
- this.lines = [];
|
|
|
- this.currentLineNb = -1;
|
|
|
- this.currentLine = '';
|
|
|
- this.refs = {};
|
|
|
- }
|
|
|
-
|
|
|
- Parser.prototype.parse = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
|
- var alias, allowOverwrite, block, c, context, data, e, error, error1, error2, first, i, indent, isRef, j, k, key, l, lastKey, len, len1, len2, len3, lineCount, m, matches, mergeNode, n, name, parsed, parsedItem, parser, ref, ref1, ref2, refName, refValue, val, values;
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectDecoder == null) {
|
|
|
- objectDecoder = null;
|
|
|
- }
|
|
|
- this.currentLineNb = -1;
|
|
|
- this.currentLine = '';
|
|
|
- this.lines = this.cleanup(value).split("\n");
|
|
|
- data = null;
|
|
|
- context = this.CONTEXT_NONE;
|
|
|
- allowOverwrite = false;
|
|
|
- while (this.moveToNextLine()) {
|
|
|
- if (this.isCurrentLineEmpty()) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if ("\t" === this.currentLine[0]) {
|
|
|
- throw new ParseException('A YAML file cannot contain tabs as indentation.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- isRef = mergeNode = false;
|
|
|
- if (values = this.PATTERN_SEQUENCE_ITEM.exec(this.currentLine)) {
|
|
|
- if (this.CONTEXT_MAPPING === context) {
|
|
|
- throw new ParseException('You cannot define a sequence item when in a mapping');
|
|
|
- }
|
|
|
- context = this.CONTEXT_SEQUENCE;
|
|
|
- if (data == null) {
|
|
|
- data = [];
|
|
|
- }
|
|
|
- if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
|
|
|
- isRef = matches.ref;
|
|
|
- values.value = matches.value;
|
|
|
- }
|
|
|
- if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
|
|
|
- if (this.currentLineNb < this.lines.length - 1 && !this.isNextLineUnIndentedCollection()) {
|
|
|
- c = this.getRealCurrentLineNb() + 1;
|
|
|
- parser = new Parser(c);
|
|
|
- parser.refs = this.refs;
|
|
|
- data.push(parser.parse(this.getNextEmbedBlock(null, true), exceptionOnInvalidType, objectDecoder));
|
|
|
- } else {
|
|
|
- data.push(null);
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (((ref = values.leadspaces) != null ? ref.length : void 0) && (matches = this.PATTERN_COMPACT_NOTATION.exec(values.value))) {
|
|
|
- c = this.getRealCurrentLineNb();
|
|
|
- parser = new Parser(c);
|
|
|
- parser.refs = this.refs;
|
|
|
- block = values.value;
|
|
|
- indent = this.getCurrentLineIndentation();
|
|
|
- if (this.isNextLineIndented(false)) {
|
|
|
- block += "\n" + this.getNextEmbedBlock(indent + values.leadspaces.length + 1, true);
|
|
|
- }
|
|
|
- data.push(parser.parse(block, exceptionOnInvalidType, objectDecoder));
|
|
|
- } else {
|
|
|
- data.push(this.parseValue(values.value, exceptionOnInvalidType, objectDecoder));
|
|
|
- }
|
|
|
- }
|
|
|
- } else if ((values = this.PATTERN_MAPPING_ITEM.exec(this.currentLine)) && values.key.indexOf(' #') === -1) {
|
|
|
- if (this.CONTEXT_SEQUENCE === context) {
|
|
|
- throw new ParseException('You cannot define a mapping item when in a sequence');
|
|
|
- }
|
|
|
- context = this.CONTEXT_MAPPING;
|
|
|
- if (data == null) {
|
|
|
- data = {};
|
|
|
- }
|
|
|
- Inline.configure(exceptionOnInvalidType, objectDecoder);
|
|
|
- try {
|
|
|
- key = Inline.parseScalar(values.key);
|
|
|
- } catch (error) {
|
|
|
- e = error;
|
|
|
- e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
|
- e.snippet = this.currentLine;
|
|
|
- throw e;
|
|
|
- }
|
|
|
- if ('<<' === key) {
|
|
|
- mergeNode = true;
|
|
|
- allowOverwrite = true;
|
|
|
- if (((ref1 = values.value) != null ? ref1.indexOf('*') : void 0) === 0) {
|
|
|
- refName = values.value.slice(1);
|
|
|
- if (this.refs[refName] == null) {
|
|
|
- throw new ParseException('Reference "' + refName + '" does not exist.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- refValue = this.refs[refName];
|
|
|
- if (typeof refValue !== 'object') {
|
|
|
- throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- if (refValue instanceof Array) {
|
|
|
- for (i = j = 0, len = refValue.length; j < len; i = ++j) {
|
|
|
- value = refValue[i];
|
|
|
- if (data[name = String(i)] == null) {
|
|
|
- data[name] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (key in refValue) {
|
|
|
- value = refValue[key];
|
|
|
- if (data[key] == null) {
|
|
|
- data[key] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- if ((values.value != null) && values.value !== '') {
|
|
|
- value = values.value;
|
|
|
- } else {
|
|
|
- value = this.getNextEmbedBlock();
|
|
|
- }
|
|
|
- c = this.getRealCurrentLineNb() + 1;
|
|
|
- parser = new Parser(c);
|
|
|
- parser.refs = this.refs;
|
|
|
- parsed = parser.parse(value, exceptionOnInvalidType);
|
|
|
- if (typeof parsed !== 'object') {
|
|
|
- throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- if (parsed instanceof Array) {
|
|
|
- for (l = 0, len1 = parsed.length; l < len1; l++) {
|
|
|
- parsedItem = parsed[l];
|
|
|
- if (typeof parsedItem !== 'object') {
|
|
|
- throw new ParseException('Merge items must be objects.', this.getRealCurrentLineNb() + 1, parsedItem);
|
|
|
- }
|
|
|
- if (parsedItem instanceof Array) {
|
|
|
- for (i = m = 0, len2 = parsedItem.length; m < len2; i = ++m) {
|
|
|
- value = parsedItem[i];
|
|
|
- k = String(i);
|
|
|
- if (!data.hasOwnProperty(k)) {
|
|
|
- data[k] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (key in parsedItem) {
|
|
|
- value = parsedItem[key];
|
|
|
- if (!data.hasOwnProperty(key)) {
|
|
|
- data[key] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (key in parsed) {
|
|
|
- value = parsed[key];
|
|
|
- if (!data.hasOwnProperty(key)) {
|
|
|
- data[key] = value;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
|
|
|
- isRef = matches.ref;
|
|
|
- values.value = matches.value;
|
|
|
- }
|
|
|
- if (mergeNode) {
|
|
|
-
|
|
|
- } else if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf('#') === 0) {
|
|
|
- if (!(this.isNextLineIndented()) && !(this.isNextLineUnIndentedCollection())) {
|
|
|
- if (allowOverwrite || data[key] === void 0) {
|
|
|
- data[key] = null;
|
|
|
- }
|
|
|
- } else {
|
|
|
- c = this.getRealCurrentLineNb() + 1;
|
|
|
- parser = new Parser(c);
|
|
|
- parser.refs = this.refs;
|
|
|
- val = parser.parse(this.getNextEmbedBlock(), exceptionOnInvalidType, objectDecoder);
|
|
|
- if (allowOverwrite || data[key] === void 0) {
|
|
|
- data[key] = val;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- val = this.parseValue(values.value, exceptionOnInvalidType, objectDecoder);
|
|
|
- if (allowOverwrite || data[key] === void 0) {
|
|
|
- data[key] = val;
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- lineCount = this.lines.length;
|
|
|
- if (1 === lineCount || (2 === lineCount && Utils.isEmpty(this.lines[1]))) {
|
|
|
- try {
|
|
|
- value = Inline.parse(this.lines[0], exceptionOnInvalidType, objectDecoder);
|
|
|
- } catch (error1) {
|
|
|
- e = error1;
|
|
|
- e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
|
- e.snippet = this.currentLine;
|
|
|
- throw e;
|
|
|
- }
|
|
|
- if (typeof value === 'object') {
|
|
|
- if (value instanceof Array) {
|
|
|
- first = value[0];
|
|
|
- } else {
|
|
|
- for (key in value) {
|
|
|
- first = value[key];
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (typeof first === 'string' && first.indexOf('*') === 0) {
|
|
|
- data = [];
|
|
|
- for (n = 0, len3 = value.length; n < len3; n++) {
|
|
|
- alias = value[n];
|
|
|
- data.push(this.refs[alias.slice(1)]);
|
|
|
- }
|
|
|
- value = data;
|
|
|
- }
|
|
|
- }
|
|
|
- return value;
|
|
|
- } else if ((ref2 = Utils.ltrim(value).charAt(0)) === '[' || ref2 === '{') {
|
|
|
- try {
|
|
|
- return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
|
- } catch (error2) {
|
|
|
- e = error2;
|
|
|
- e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
|
- e.snippet = this.currentLine;
|
|
|
- throw e;
|
|
|
- }
|
|
|
- }
|
|
|
- throw new ParseException('Unable to parse.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- if (isRef) {
|
|
|
- if (data instanceof Array) {
|
|
|
- this.refs[isRef] = data[data.length - 1];
|
|
|
- } else {
|
|
|
- lastKey = null;
|
|
|
- for (key in data) {
|
|
|
- lastKey = key;
|
|
|
- }
|
|
|
- this.refs[isRef] = data[lastKey];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (Utils.isEmpty(data)) {
|
|
|
- return null;
|
|
|
- } else {
|
|
|
- return data;
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.getRealCurrentLineNb = function() {
|
|
|
- return this.currentLineNb + this.offset;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.getCurrentLineIndentation = function() {
|
|
|
- return this.currentLine.length - Utils.ltrim(this.currentLine, ' ').length;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.getNextEmbedBlock = function(indentation, includeUnindentedCollection) {
|
|
|
- var data, indent, isItUnindentedCollection, newIndent, removeComments, removeCommentsPattern, unindentedEmbedBlock;
|
|
|
- if (indentation == null) {
|
|
|
- indentation = null;
|
|
|
- }
|
|
|
- if (includeUnindentedCollection == null) {
|
|
|
- includeUnindentedCollection = false;
|
|
|
- }
|
|
|
- this.moveToNextLine();
|
|
|
- if (indentation == null) {
|
|
|
- newIndent = this.getCurrentLineIndentation();
|
|
|
- unindentedEmbedBlock = this.isStringUnIndentedCollectionItem(this.currentLine);
|
|
|
- if (!(this.isCurrentLineEmpty()) && 0 === newIndent && !unindentedEmbedBlock) {
|
|
|
- throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- } else {
|
|
|
- newIndent = indentation;
|
|
|
- }
|
|
|
- data = [this.currentLine.slice(newIndent)];
|
|
|
- if (!includeUnindentedCollection) {
|
|
|
- isItUnindentedCollection = this.isStringUnIndentedCollectionItem(this.currentLine);
|
|
|
- }
|
|
|
- removeCommentsPattern = this.PATTERN_FOLDED_SCALAR_END;
|
|
|
- removeComments = !removeCommentsPattern.test(this.currentLine);
|
|
|
- while (this.moveToNextLine()) {
|
|
|
- indent = this.getCurrentLineIndentation();
|
|
|
- if (indent === newIndent) {
|
|
|
- removeComments = !removeCommentsPattern.test(this.currentLine);
|
|
|
- }
|
|
|
- if (removeComments && this.isCurrentLineComment()) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (this.isCurrentLineBlank()) {
|
|
|
- data.push(this.currentLine.slice(newIndent));
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent === newIndent) {
|
|
|
- this.moveToPreviousLine();
|
|
|
- break;
|
|
|
- }
|
|
|
- if (indent >= newIndent) {
|
|
|
- data.push(this.currentLine.slice(newIndent));
|
|
|
- } else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {
|
|
|
-
|
|
|
- } else if (0 === indent) {
|
|
|
- this.moveToPreviousLine();
|
|
|
- break;
|
|
|
- } else {
|
|
|
- throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
|
|
|
- }
|
|
|
- }
|
|
|
- return data.join("\n");
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.moveToNextLine = function() {
|
|
|
- if (this.currentLineNb >= this.lines.length - 1) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- this.currentLine = this.lines[++this.currentLineNb];
|
|
|
- return true;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.moveToPreviousLine = function() {
|
|
|
- this.currentLine = this.lines[--this.currentLineNb];
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.parseValue = function(value, exceptionOnInvalidType, objectDecoder) {
|
|
|
- var e, error, foldedIndent, matches, modifiers, pos, ref, ref1, val;
|
|
|
- if (0 === value.indexOf('*')) {
|
|
|
- pos = value.indexOf('#');
|
|
|
- if (pos !== -1) {
|
|
|
- value = value.substr(1, pos - 2);
|
|
|
- } else {
|
|
|
- value = value.slice(1);
|
|
|
- }
|
|
|
- if (this.refs[value] === void 0) {
|
|
|
- throw new ParseException('Reference "' + value + '" does not exist.', this.currentLine);
|
|
|
- }
|
|
|
- return this.refs[value];
|
|
|
- }
|
|
|
- if (matches = this.PATTERN_FOLDED_SCALAR_ALL.exec(value)) {
|
|
|
- modifiers = (ref = matches.modifiers) != null ? ref : '';
|
|
|
- foldedIndent = Math.abs(parseInt(modifiers));
|
|
|
- if (isNaN(foldedIndent)) {
|
|
|
- foldedIndent = 0;
|
|
|
- }
|
|
|
- val = this.parseFoldedScalar(matches.separator, this.PATTERN_DECIMAL.replace(modifiers, ''), foldedIndent);
|
|
|
- if (matches.type != null) {
|
|
|
- Inline.configure(exceptionOnInvalidType, objectDecoder);
|
|
|
- return Inline.parseScalar(matches.type + ' ' + val);
|
|
|
- } else {
|
|
|
- return val;
|
|
|
- }
|
|
|
- }
|
|
|
- if ((ref1 = value.charAt(0)) === '[' || ref1 === '{' || ref1 === '"' || ref1 === "'") {
|
|
|
- while (true) {
|
|
|
- try {
|
|
|
- return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
|
- } catch (error) {
|
|
|
- e = error;
|
|
|
- if (e instanceof ParseMore && this.moveToNextLine()) {
|
|
|
- value += "\n" + Utils.trim(this.currentLine, ' ');
|
|
|
- } else {
|
|
|
- e.parsedLine = this.getRealCurrentLineNb() + 1;
|
|
|
- e.snippet = this.currentLine;
|
|
|
- throw e;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (this.isNextLineIndented()) {
|
|
|
- value += "\n" + this.getNextEmbedBlock();
|
|
|
- }
|
|
|
- return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.parseFoldedScalar = function(separator, indicator, indentation) {
|
|
|
- var isCurrentLineBlank, j, len, line, matches, newText, notEOF, pattern, ref, text;
|
|
|
- if (indicator == null) {
|
|
|
- indicator = '';
|
|
|
- }
|
|
|
- if (indentation == null) {
|
|
|
- indentation = 0;
|
|
|
- }
|
|
|
- notEOF = this.moveToNextLine();
|
|
|
- if (!notEOF) {
|
|
|
- return '';
|
|
|
- }
|
|
|
- isCurrentLineBlank = this.isCurrentLineBlank();
|
|
|
- text = '';
|
|
|
- while (notEOF && isCurrentLineBlank) {
|
|
|
- if (notEOF = this.moveToNextLine()) {
|
|
|
- text += "\n";
|
|
|
- isCurrentLineBlank = this.isCurrentLineBlank();
|
|
|
- }
|
|
|
- }
|
|
|
- if (0 === indentation) {
|
|
|
- if (matches = this.PATTERN_INDENT_SPACES.exec(this.currentLine)) {
|
|
|
- indentation = matches[0].length;
|
|
|
- }
|
|
|
- }
|
|
|
- if (indentation > 0) {
|
|
|
- pattern = this.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation];
|
|
|
- if (pattern == null) {
|
|
|
- pattern = new Pattern('^ {' + indentation + '}(.*)$');
|
|
|
- Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation] = pattern;
|
|
|
- }
|
|
|
- while (notEOF && (isCurrentLineBlank || (matches = pattern.exec(this.currentLine)))) {
|
|
|
- if (isCurrentLineBlank) {
|
|
|
- text += this.currentLine.slice(indentation);
|
|
|
- } else {
|
|
|
- text += matches[1];
|
|
|
- }
|
|
|
- if (notEOF = this.moveToNextLine()) {
|
|
|
- text += "\n";
|
|
|
- isCurrentLineBlank = this.isCurrentLineBlank();
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (notEOF) {
|
|
|
- text += "\n";
|
|
|
- }
|
|
|
- if (notEOF) {
|
|
|
- this.moveToPreviousLine();
|
|
|
- }
|
|
|
- if ('>' === separator) {
|
|
|
- newText = '';
|
|
|
- ref = text.split("\n");
|
|
|
- for (j = 0, len = ref.length; j < len; j++) {
|
|
|
- line = ref[j];
|
|
|
- if (line.length === 0 || line.charAt(0) === ' ') {
|
|
|
- newText = Utils.rtrim(newText, ' ') + line + "\n";
|
|
|
- } else {
|
|
|
- newText += line + ' ';
|
|
|
- }
|
|
|
- }
|
|
|
- text = newText;
|
|
|
- }
|
|
|
- if ('+' !== indicator) {
|
|
|
- text = Utils.rtrim(text);
|
|
|
- }
|
|
|
- if ('' === indicator) {
|
|
|
- text = this.PATTERN_TRAILING_LINES.replace(text, "\n");
|
|
|
- } else if ('-' === indicator) {
|
|
|
- text = this.PATTERN_TRAILING_LINES.replace(text, '');
|
|
|
- }
|
|
|
- return text;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isNextLineIndented = function(ignoreComments) {
|
|
|
- var EOF, currentIndentation, ret;
|
|
|
- if (ignoreComments == null) {
|
|
|
- ignoreComments = true;
|
|
|
- }
|
|
|
- currentIndentation = this.getCurrentLineIndentation();
|
|
|
- EOF = !this.moveToNextLine();
|
|
|
- if (ignoreComments) {
|
|
|
- while (!EOF && this.isCurrentLineEmpty()) {
|
|
|
- EOF = !this.moveToNextLine();
|
|
|
- }
|
|
|
- } else {
|
|
|
- while (!EOF && this.isCurrentLineBlank()) {
|
|
|
- EOF = !this.moveToNextLine();
|
|
|
- }
|
|
|
- }
|
|
|
- if (EOF) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- ret = false;
|
|
|
- if (this.getCurrentLineIndentation() > currentIndentation) {
|
|
|
- ret = true;
|
|
|
- }
|
|
|
- this.moveToPreviousLine();
|
|
|
- return ret;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isCurrentLineEmpty = function() {
|
|
|
- var trimmedLine;
|
|
|
- trimmedLine = Utils.trim(this.currentLine, ' ');
|
|
|
- return trimmedLine.length === 0 || trimmedLine.charAt(0) === '#';
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isCurrentLineBlank = function() {
|
|
|
- return '' === Utils.trim(this.currentLine, ' ');
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isCurrentLineComment = function() {
|
|
|
- var ltrimmedLine;
|
|
|
- ltrimmedLine = Utils.ltrim(this.currentLine, ' ');
|
|
|
- return ltrimmedLine.charAt(0) === '#';
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.cleanup = function(value) {
|
|
|
- var count, i, indent, j, l, len, len1, line, lines, ref, ref1, ref2, smallestIndent, trimmedValue;
|
|
|
- if (value.indexOf("\r") !== -1) {
|
|
|
- value = value.split("\r\n").join("\n").split("\r").join("\n");
|
|
|
- }
|
|
|
- count = 0;
|
|
|
- ref = this.PATTERN_YAML_HEADER.replaceAll(value, ''), value = ref[0], count = ref[1];
|
|
|
- this.offset += count;
|
|
|
- ref1 = this.PATTERN_LEADING_COMMENTS.replaceAll(value, '', 1), trimmedValue = ref1[0], count = ref1[1];
|
|
|
- if (count === 1) {
|
|
|
- this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
|
|
|
- value = trimmedValue;
|
|
|
- }
|
|
|
- ref2 = this.PATTERN_DOCUMENT_MARKER_START.replaceAll(value, '', 1), trimmedValue = ref2[0], count = ref2[1];
|
|
|
- if (count === 1) {
|
|
|
- this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
|
|
|
- value = trimmedValue;
|
|
|
- value = this.PATTERN_DOCUMENT_MARKER_END.replace(value, '');
|
|
|
- }
|
|
|
- lines = value.split("\n");
|
|
|
- smallestIndent = -1;
|
|
|
- for (j = 0, len = lines.length; j < len; j++) {
|
|
|
- line = lines[j];
|
|
|
- if (Utils.trim(line, ' ').length === 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- indent = line.length - Utils.ltrim(line).length;
|
|
|
- if (smallestIndent === -1 || indent < smallestIndent) {
|
|
|
- smallestIndent = indent;
|
|
|
- }
|
|
|
- }
|
|
|
- if (smallestIndent > 0) {
|
|
|
- for (i = l = 0, len1 = lines.length; l < len1; i = ++l) {
|
|
|
- line = lines[i];
|
|
|
- lines[i] = line.slice(smallestIndent);
|
|
|
- }
|
|
|
- value = lines.join("\n");
|
|
|
- }
|
|
|
- return value;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isNextLineUnIndentedCollection = function(currentIndentation) {
|
|
|
- var notEOF, ret;
|
|
|
- if (currentIndentation == null) {
|
|
|
- currentIndentation = null;
|
|
|
- }
|
|
|
- if (currentIndentation == null) {
|
|
|
- currentIndentation = this.getCurrentLineIndentation();
|
|
|
- }
|
|
|
- notEOF = this.moveToNextLine();
|
|
|
- while (notEOF && this.isCurrentLineEmpty()) {
|
|
|
- notEOF = this.moveToNextLine();
|
|
|
- }
|
|
|
- if (false === notEOF) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- ret = false;
|
|
|
- if (this.getCurrentLineIndentation() === currentIndentation && this.isStringUnIndentedCollectionItem(this.currentLine)) {
|
|
|
- ret = true;
|
|
|
- }
|
|
|
- this.moveToPreviousLine();
|
|
|
- return ret;
|
|
|
- };
|
|
|
-
|
|
|
- Parser.prototype.isStringUnIndentedCollectionItem = function() {
|
|
|
- return this.currentLine === '-' || this.currentLine.slice(0, 2) === '- ';
|
|
|
- };
|
|
|
-
|
|
|
- return Parser;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Parser;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Exception/ParseException":4,"./Exception/ParseMore":5,"./Inline":6,"./Pattern":8,"./Utils":10}],8:[function(require,module,exports){
|
|
|
-var Pattern;
|
|
|
-
|
|
|
-Pattern = (function() {
|
|
|
- Pattern.prototype.regex = null;
|
|
|
-
|
|
|
- Pattern.prototype.rawRegex = null;
|
|
|
-
|
|
|
- Pattern.prototype.cleanedRegex = null;
|
|
|
-
|
|
|
- Pattern.prototype.mapping = null;
|
|
|
-
|
|
|
- function Pattern(rawRegex, modifiers) {
|
|
|
- var _char, capturingBracketNumber, cleanedRegex, i, len, mapping, name, part, subChar;
|
|
|
- if (modifiers == null) {
|
|
|
- modifiers = '';
|
|
|
- }
|
|
|
- cleanedRegex = '';
|
|
|
- len = rawRegex.length;
|
|
|
- mapping = null;
|
|
|
- capturingBracketNumber = 0;
|
|
|
- i = 0;
|
|
|
- while (i < len) {
|
|
|
- _char = rawRegex.charAt(i);
|
|
|
- if (_char === '\\') {
|
|
|
- cleanedRegex += rawRegex.slice(i, +(i + 1) + 1 || 9e9);
|
|
|
- i++;
|
|
|
- } else if (_char === '(') {
|
|
|
- if (i < len - 2) {
|
|
|
- part = rawRegex.slice(i, +(i + 2) + 1 || 9e9);
|
|
|
- if (part === '(?:') {
|
|
|
- i += 2;
|
|
|
- cleanedRegex += part;
|
|
|
- } else if (part === '(?<') {
|
|
|
- capturingBracketNumber++;
|
|
|
- i += 2;
|
|
|
- name = '';
|
|
|
- while (i + 1 < len) {
|
|
|
- subChar = rawRegex.charAt(i + 1);
|
|
|
- if (subChar === '>') {
|
|
|
- cleanedRegex += '(';
|
|
|
- i++;
|
|
|
- if (name.length > 0) {
|
|
|
- if (mapping == null) {
|
|
|
- mapping = {};
|
|
|
- }
|
|
|
- mapping[name] = capturingBracketNumber;
|
|
|
- }
|
|
|
- break;
|
|
|
- } else {
|
|
|
- name += subChar;
|
|
|
- }
|
|
|
- i++;
|
|
|
- }
|
|
|
- } else {
|
|
|
- cleanedRegex += _char;
|
|
|
- capturingBracketNumber++;
|
|
|
- }
|
|
|
- } else {
|
|
|
- cleanedRegex += _char;
|
|
|
- }
|
|
|
- } else {
|
|
|
- cleanedRegex += _char;
|
|
|
- }
|
|
|
- i++;
|
|
|
- }
|
|
|
- this.rawRegex = rawRegex;
|
|
|
- this.cleanedRegex = cleanedRegex;
|
|
|
- this.regex = new RegExp(this.cleanedRegex, 'g' + modifiers.replace('g', ''));
|
|
|
- this.mapping = mapping;
|
|
|
- }
|
|
|
-
|
|
|
- Pattern.prototype.exec = function(str) {
|
|
|
- var index, matches, name, ref;
|
|
|
- this.regex.lastIndex = 0;
|
|
|
- matches = this.regex.exec(str);
|
|
|
- if (matches == null) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (this.mapping != null) {
|
|
|
- ref = this.mapping;
|
|
|
- for (name in ref) {
|
|
|
- index = ref[name];
|
|
|
- matches[name] = matches[index];
|
|
|
- }
|
|
|
- }
|
|
|
- return matches;
|
|
|
- };
|
|
|
-
|
|
|
- Pattern.prototype.test = function(str) {
|
|
|
- this.regex.lastIndex = 0;
|
|
|
- return this.regex.test(str);
|
|
|
- };
|
|
|
-
|
|
|
- Pattern.prototype.replace = function(str, replacement) {
|
|
|
- this.regex.lastIndex = 0;
|
|
|
- return str.replace(this.regex, replacement);
|
|
|
- };
|
|
|
-
|
|
|
- Pattern.prototype.replaceAll = function(str, replacement, limit) {
|
|
|
- var count;
|
|
|
- if (limit == null) {
|
|
|
- limit = 0;
|
|
|
- }
|
|
|
- this.regex.lastIndex = 0;
|
|
|
- count = 0;
|
|
|
- while (this.regex.test(str) && (limit === 0 || count < limit)) {
|
|
|
- this.regex.lastIndex = 0;
|
|
|
- str = str.replace(this.regex, replacement);
|
|
|
- count++;
|
|
|
- }
|
|
|
- return [str, count];
|
|
|
- };
|
|
|
-
|
|
|
- return Pattern;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Pattern;
|
|
|
-
|
|
|
-
|
|
|
-},{}],9:[function(require,module,exports){
|
|
|
-var Pattern, Unescaper, Utils;
|
|
|
-
|
|
|
-Utils = require('./Utils');
|
|
|
-
|
|
|
-Pattern = require('./Pattern');
|
|
|
-
|
|
|
-Unescaper = (function() {
|
|
|
- function Unescaper() {}
|
|
|
-
|
|
|
- Unescaper.PATTERN_ESCAPED_CHARACTER = new Pattern('\\\\([0abt\tnvfre "\\/\\\\N_LP]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})');
|
|
|
-
|
|
|
- Unescaper.unescapeSingleQuotedString = function(value) {
|
|
|
- return value.replace(/\'\'/g, '\'');
|
|
|
- };
|
|
|
-
|
|
|
- Unescaper.unescapeDoubleQuotedString = function(value) {
|
|
|
- if (this._unescapeCallback == null) {
|
|
|
- this._unescapeCallback = (function(_this) {
|
|
|
- return function(str) {
|
|
|
- return _this.unescapeCharacter(str);
|
|
|
- };
|
|
|
- })(this);
|
|
|
- }
|
|
|
- return this.PATTERN_ESCAPED_CHARACTER.replace(value, this._unescapeCallback);
|
|
|
- };
|
|
|
-
|
|
|
- Unescaper.unescapeCharacter = function(value) {
|
|
|
- var ch;
|
|
|
- ch = String.fromCharCode;
|
|
|
- switch (value.charAt(1)) {
|
|
|
- case '0':
|
|
|
- return ch(0);
|
|
|
- case 'a':
|
|
|
- return ch(7);
|
|
|
- case 'b':
|
|
|
- return ch(8);
|
|
|
- case 't':
|
|
|
- return "\t";
|
|
|
- case "\t":
|
|
|
- return "\t";
|
|
|
- case 'n':
|
|
|
- return "\n";
|
|
|
- case 'v':
|
|
|
- return ch(11);
|
|
|
- case 'f':
|
|
|
- return ch(12);
|
|
|
- case 'r':
|
|
|
- return ch(13);
|
|
|
- case 'e':
|
|
|
- return ch(27);
|
|
|
- case ' ':
|
|
|
- return ' ';
|
|
|
- case '"':
|
|
|
- return '"';
|
|
|
- case '/':
|
|
|
- return '/';
|
|
|
- case '\\':
|
|
|
- return '\\';
|
|
|
- case 'N':
|
|
|
- return ch(0x0085);
|
|
|
- case '_':
|
|
|
- return ch(0x00A0);
|
|
|
- case 'L':
|
|
|
- return ch(0x2028);
|
|
|
- case 'P':
|
|
|
- return ch(0x2029);
|
|
|
- case 'x':
|
|
|
- return Utils.utf8chr(Utils.hexDec(value.substr(2, 2)));
|
|
|
- case 'u':
|
|
|
- return Utils.utf8chr(Utils.hexDec(value.substr(2, 4)));
|
|
|
- case 'U':
|
|
|
- return Utils.utf8chr(Utils.hexDec(value.substr(2, 8)));
|
|
|
- default:
|
|
|
- return '';
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return Unescaper;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Unescaper;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Pattern":8,"./Utils":10}],10:[function(require,module,exports){
|
|
|
-var Pattern, Utils,
|
|
|
- hasProp = {}.hasOwnProperty;
|
|
|
-
|
|
|
-Pattern = require('./Pattern');
|
|
|
-
|
|
|
-Utils = (function() {
|
|
|
- function Utils() {}
|
|
|
-
|
|
|
- Utils.REGEX_LEFT_TRIM_BY_CHAR = {};
|
|
|
-
|
|
|
- Utils.REGEX_RIGHT_TRIM_BY_CHAR = {};
|
|
|
-
|
|
|
- Utils.REGEX_SPACES = /\s+/g;
|
|
|
-
|
|
|
- Utils.REGEX_DIGITS = /^\d+$/;
|
|
|
-
|
|
|
- Utils.REGEX_OCTAL = /[^0-7]/gi;
|
|
|
-
|
|
|
- Utils.REGEX_HEXADECIMAL = /[^a-f0-9]/gi;
|
|
|
-
|
|
|
- Utils.PATTERN_DATE = new Pattern('^' + '(?<year>[0-9][0-9][0-9][0-9])' + '-(?<month>[0-9][0-9]?)' + '-(?<day>[0-9][0-9]?)' + '(?:(?:[Tt]|[ \t]+)' + '(?<hour>[0-9][0-9]?)' + ':(?<minute>[0-9][0-9])' + ':(?<second>[0-9][0-9])' + '(?:\.(?<fraction>[0-9]*))?' + '(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)' + '(?::(?<tz_minute>[0-9][0-9]))?))?)?' + '$', 'i');
|
|
|
-
|
|
|
- Utils.LOCAL_TIMEZONE_OFFSET = new Date().getTimezoneOffset() * 60 * 1000;
|
|
|
-
|
|
|
- Utils.trim = function(str, _char) {
|
|
|
- var regexLeft, regexRight;
|
|
|
- if (_char == null) {
|
|
|
- _char = '\\s';
|
|
|
- }
|
|
|
- regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
|
|
|
- if (regexLeft == null) {
|
|
|
- this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
|
|
|
- }
|
|
|
- regexLeft.lastIndex = 0;
|
|
|
- regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
|
|
|
- if (regexRight == null) {
|
|
|
- this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
|
|
|
- }
|
|
|
- regexRight.lastIndex = 0;
|
|
|
- return str.replace(regexLeft, '').replace(regexRight, '');
|
|
|
- };
|
|
|
-
|
|
|
- Utils.ltrim = function(str, _char) {
|
|
|
- var regexLeft;
|
|
|
- if (_char == null) {
|
|
|
- _char = '\\s';
|
|
|
- }
|
|
|
- regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
|
|
|
- if (regexLeft == null) {
|
|
|
- this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
|
|
|
- }
|
|
|
- regexLeft.lastIndex = 0;
|
|
|
- return str.replace(regexLeft, '');
|
|
|
- };
|
|
|
-
|
|
|
- Utils.rtrim = function(str, _char) {
|
|
|
- var regexRight;
|
|
|
- if (_char == null) {
|
|
|
- _char = '\\s';
|
|
|
- }
|
|
|
- regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
|
|
|
- if (regexRight == null) {
|
|
|
- this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
|
|
|
- }
|
|
|
- regexRight.lastIndex = 0;
|
|
|
- return str.replace(regexRight, '');
|
|
|
- };
|
|
|
-
|
|
|
- Utils.isEmpty = function(value) {
|
|
|
- return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0) || this.isEmptyObject(value);
|
|
|
- };
|
|
|
-
|
|
|
- Utils.isEmptyObject = function(value) {
|
|
|
- var k;
|
|
|
- return value instanceof Object && ((function() {
|
|
|
- var results;
|
|
|
- results = [];
|
|
|
- for (k in value) {
|
|
|
- if (!hasProp.call(value, k)) continue;
|
|
|
- results.push(k);
|
|
|
- }
|
|
|
- return results;
|
|
|
- })()).length === 0;
|
|
|
- };
|
|
|
-
|
|
|
- Utils.subStrCount = function(string, subString, start, length) {
|
|
|
- var c, i, j, len, ref, sublen;
|
|
|
- c = 0;
|
|
|
- string = '' + string;
|
|
|
- subString = '' + subString;
|
|
|
- if (start != null) {
|
|
|
- string = string.slice(start);
|
|
|
- }
|
|
|
- if (length != null) {
|
|
|
- string = string.slice(0, length);
|
|
|
- }
|
|
|
- len = string.length;
|
|
|
- sublen = subString.length;
|
|
|
- for (i = j = 0, ref = len; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
|
|
|
- if (subString === string.slice(i, sublen)) {
|
|
|
- c++;
|
|
|
- i += sublen - 1;
|
|
|
- }
|
|
|
- }
|
|
|
- return c;
|
|
|
- };
|
|
|
-
|
|
|
- Utils.isDigits = function(input) {
|
|
|
- this.REGEX_DIGITS.lastIndex = 0;
|
|
|
- return this.REGEX_DIGITS.test(input);
|
|
|
- };
|
|
|
-
|
|
|
- Utils.octDec = function(input) {
|
|
|
- this.REGEX_OCTAL.lastIndex = 0;
|
|
|
- return parseInt((input + '').replace(this.REGEX_OCTAL, ''), 8);
|
|
|
- };
|
|
|
-
|
|
|
- Utils.hexDec = function(input) {
|
|
|
- this.REGEX_HEXADECIMAL.lastIndex = 0;
|
|
|
- input = this.trim(input);
|
|
|
- if ((input + '').slice(0, 2) === '0x') {
|
|
|
- input = (input + '').slice(2);
|
|
|
- }
|
|
|
- return parseInt((input + '').replace(this.REGEX_HEXADECIMAL, ''), 16);
|
|
|
- };
|
|
|
-
|
|
|
- Utils.utf8chr = function(c) {
|
|
|
- var ch;
|
|
|
- ch = String.fromCharCode;
|
|
|
- if (0x80 > (c %= 0x200000)) {
|
|
|
- return ch(c);
|
|
|
- }
|
|
|
- if (0x800 > c) {
|
|
|
- return ch(0xC0 | c >> 6) + ch(0x80 | c & 0x3F);
|
|
|
- }
|
|
|
- if (0x10000 > c) {
|
|
|
- return ch(0xE0 | c >> 12) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
|
|
|
- }
|
|
|
- return ch(0xF0 | c >> 18) + ch(0x80 | c >> 12 & 0x3F) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
|
|
|
- };
|
|
|
-
|
|
|
- Utils.parseBoolean = function(input, strict) {
|
|
|
- var lowerInput;
|
|
|
- if (strict == null) {
|
|
|
- strict = true;
|
|
|
- }
|
|
|
- if (typeof input === 'string') {
|
|
|
- lowerInput = input.toLowerCase();
|
|
|
- if (!strict) {
|
|
|
- if (lowerInput === 'no') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- if (lowerInput === '0') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (lowerInput === 'false') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (lowerInput === '') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- return !!input;
|
|
|
- };
|
|
|
-
|
|
|
- Utils.isNumeric = function(input) {
|
|
|
- this.REGEX_SPACES.lastIndex = 0;
|
|
|
- return typeof input === 'number' || typeof input === 'string' && !isNaN(input) && input.replace(this.REGEX_SPACES, '') !== '';
|
|
|
- };
|
|
|
-
|
|
|
- Utils.stringToDate = function(str) {
|
|
|
- var date, day, fraction, hour, info, minute, month, second, tz_hour, tz_minute, tz_offset, year;
|
|
|
- if (!(str != null ? str.length : void 0)) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- info = this.PATTERN_DATE.exec(str);
|
|
|
- if (!info) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- year = parseInt(info.year, 10);
|
|
|
- month = parseInt(info.month, 10) - 1;
|
|
|
- day = parseInt(info.day, 10);
|
|
|
- if (info.hour == null) {
|
|
|
- date = new Date(Date.UTC(year, month, day));
|
|
|
- return date;
|
|
|
- }
|
|
|
- hour = parseInt(info.hour, 10);
|
|
|
- minute = parseInt(info.minute, 10);
|
|
|
- second = parseInt(info.second, 10);
|
|
|
- if (info.fraction != null) {
|
|
|
- fraction = info.fraction.slice(0, 3);
|
|
|
- while (fraction.length < 3) {
|
|
|
- fraction += '0';
|
|
|
- }
|
|
|
- fraction = parseInt(fraction, 10);
|
|
|
- } else {
|
|
|
- fraction = 0;
|
|
|
- }
|
|
|
- if (info.tz != null) {
|
|
|
- tz_hour = parseInt(info.tz_hour, 10);
|
|
|
- if (info.tz_minute != null) {
|
|
|
- tz_minute = parseInt(info.tz_minute, 10);
|
|
|
- } else {
|
|
|
- tz_minute = 0;
|
|
|
- }
|
|
|
- tz_offset = (tz_hour * 60 + tz_minute) * 60000;
|
|
|
- if ('-' === info.tz_sign) {
|
|
|
- tz_offset *= -1;
|
|
|
- }
|
|
|
- }
|
|
|
- date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
|
|
|
- if (tz_offset) {
|
|
|
- date.setTime(date.getTime() - tz_offset);
|
|
|
- }
|
|
|
- return date;
|
|
|
- };
|
|
|
-
|
|
|
- Utils.strRepeat = function(str, number) {
|
|
|
- var i, res;
|
|
|
- res = '';
|
|
|
- i = 0;
|
|
|
- while (i < number) {
|
|
|
- res += str;
|
|
|
- i++;
|
|
|
- }
|
|
|
- return res;
|
|
|
- };
|
|
|
-
|
|
|
- Utils.getStringFromFile = function(path, callback) {
|
|
|
- var data, fs, j, len1, name, ref, req, xhr;
|
|
|
- if (callback == null) {
|
|
|
- callback = null;
|
|
|
- }
|
|
|
- xhr = null;
|
|
|
- if (typeof window !== "undefined" && window !== null) {
|
|
|
- if (window.XMLHttpRequest) {
|
|
|
- xhr = new XMLHttpRequest();
|
|
|
- } else if (window.ActiveXObject) {
|
|
|
- ref = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"];
|
|
|
- for (j = 0, len1 = ref.length; j < len1; j++) {
|
|
|
- name = ref[j];
|
|
|
- try {
|
|
|
- xhr = new ActiveXObject(name);
|
|
|
- } catch (undefined) {}
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (xhr != null) {
|
|
|
- if (callback != null) {
|
|
|
- xhr.onreadystatechange = function() {
|
|
|
- if (xhr.readyState === 4) {
|
|
|
- if (xhr.status === 200 || xhr.status === 0) {
|
|
|
- return callback(xhr.responseText);
|
|
|
- } else {
|
|
|
- return callback(null);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- xhr.open('GET', path, true);
|
|
|
- return xhr.send(null);
|
|
|
- } else {
|
|
|
- xhr.open('GET', path, false);
|
|
|
- xhr.send(null);
|
|
|
- if (xhr.status === 200 || xhr.status === 0) {
|
|
|
- return xhr.responseText;
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- } else {
|
|
|
- req = require;
|
|
|
- fs = req('fs');
|
|
|
- if (callback != null) {
|
|
|
- return fs.readFile(path, function(err, data) {
|
|
|
- if (err) {
|
|
|
- return callback(null);
|
|
|
- } else {
|
|
|
- return callback(String(data));
|
|
|
- }
|
|
|
- });
|
|
|
- } else {
|
|
|
- data = fs.readFileSync(path);
|
|
|
- if (data != null) {
|
|
|
- return String(data);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- return Utils;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-module.exports = Utils;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Pattern":8}],11:[function(require,module,exports){
|
|
|
-var Dumper, Parser, Utils, Yaml;
|
|
|
-
|
|
|
-Parser = require('./Parser');
|
|
|
-
|
|
|
-Dumper = require('./Dumper');
|
|
|
-
|
|
|
-Utils = require('./Utils');
|
|
|
-
|
|
|
-Yaml = (function() {
|
|
|
- function Yaml() {}
|
|
|
-
|
|
|
- Yaml.parse = function(input, exceptionOnInvalidType, objectDecoder) {
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectDecoder == null) {
|
|
|
- objectDecoder = null;
|
|
|
- }
|
|
|
- return new Parser().parse(input, exceptionOnInvalidType, objectDecoder);
|
|
|
- };
|
|
|
-
|
|
|
- Yaml.parseFile = function(path, callback, exceptionOnInvalidType, objectDecoder) {
|
|
|
- var input;
|
|
|
- if (callback == null) {
|
|
|
- callback = null;
|
|
|
- }
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectDecoder == null) {
|
|
|
- objectDecoder = null;
|
|
|
- }
|
|
|
- if (callback != null) {
|
|
|
- return Utils.getStringFromFile(path, (function(_this) {
|
|
|
- return function(input) {
|
|
|
- var result;
|
|
|
- result = null;
|
|
|
- if (input != null) {
|
|
|
- result = _this.parse(input, exceptionOnInvalidType, objectDecoder);
|
|
|
- }
|
|
|
- callback(result);
|
|
|
- };
|
|
|
- })(this));
|
|
|
- } else {
|
|
|
- input = Utils.getStringFromFile(path);
|
|
|
- if (input != null) {
|
|
|
- return this.parse(input, exceptionOnInvalidType, objectDecoder);
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- Yaml.dump = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
|
- var yaml;
|
|
|
- if (inline == null) {
|
|
|
- inline = 2;
|
|
|
- }
|
|
|
- if (indent == null) {
|
|
|
- indent = 4;
|
|
|
- }
|
|
|
- if (exceptionOnInvalidType == null) {
|
|
|
- exceptionOnInvalidType = false;
|
|
|
- }
|
|
|
- if (objectEncoder == null) {
|
|
|
- objectEncoder = null;
|
|
|
- }
|
|
|
- yaml = new Dumper();
|
|
|
- yaml.indentation = indent;
|
|
|
- return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
|
|
|
- };
|
|
|
-
|
|
|
- Yaml.stringify = function(input, inline, indent, exceptionOnInvalidType, objectEncoder) {
|
|
|
- return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
|
|
|
- };
|
|
|
-
|
|
|
- Yaml.load = function(path, callback, exceptionOnInvalidType, objectDecoder) {
|
|
|
- return this.parseFile(path, callback, exceptionOnInvalidType, objectDecoder);
|
|
|
- };
|
|
|
-
|
|
|
- return Yaml;
|
|
|
-
|
|
|
-})();
|
|
|
-
|
|
|
-if (typeof window !== "undefined" && window !== null) {
|
|
|
- window.YAML = Yaml;
|
|
|
-}
|
|
|
-
|
|
|
-if (typeof window === "undefined" || window === null) {
|
|
|
- this.YAML = Yaml;
|
|
|
-}
|
|
|
-
|
|
|
-module.exports = Yaml;
|
|
|
-
|
|
|
-
|
|
|
-},{"./Dumper":1,"./Parser":7,"./Utils":10}]},{},[11]);
|
