2749 lines
86 KiB
JavaScript
2749 lines
86 KiB
JavaScript
layui.define(["jquery", "element"], function (exports) {
|
|
"use strict";
|
|
|
|
var MOD_NAME = "yaml",
|
|
$ = layui.jquery,
|
|
element = layui.element;
|
|
|
|
var yaml = new (function () {
|
|
this.parse = function (str) {
|
|
return YAML.parse(yamlString);
|
|
};
|
|
this.load = function (path) {
|
|
return YAML.load(path);
|
|
};
|
|
})();
|
|
exports(MOD_NAME, yaml);
|
|
});
|
|
|
|
(function () {
|
|
function r(e, n, t) {
|
|
function o(i, f) {
|
|
if (!n[i]) {
|
|
if (!e[i]) {
|
|
var c = "function" == typeof require && require;
|
|
if (!f && c) return c(i, !0);
|
|
if (u) return u(i, !0);
|
|
var a = new Error("Cannot find module '" + i + "'");
|
|
throw ((a.code = "MODULE_NOT_FOUND"), a);
|
|
}
|
|
var p = (n[i] = {
|
|
exports: {},
|
|
});
|
|
e[i][0].call(
|
|
p.exports,
|
|
function (r) {
|
|
var n = e[i][1][r];
|
|
return o(n || r);
|
|
},
|
|
p,
|
|
p.exports,
|
|
r,
|
|
e,
|
|
n,
|
|
t,
|
|
);
|
|
}
|
|
return n[i].exports;
|
|
}
|
|
for (
|
|
var u = "function" == typeof require && require, i = 0;
|
|
i < t.length;
|
|
i++
|
|
)
|
|
o(t[i]);
|
|
return o;
|
|
}
|
|
return r;
|
|
})()(
|
|
{
|
|
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 = "";
|
|
if (typeof input === "function") {
|
|
return 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) {
|
|
DumpException.__super__.constructor.call(this, message);
|
|
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) {
|
|
ParseException.__super__.constructor.call(this, message);
|
|
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) {
|
|
ParseMore.__super__.constructor.call(this, message);
|
|
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],
|
|
);
|