mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/CodeEditor
synced 2024-11-23 23:03:46 +00:00
5833 lines
161 KiB
JavaScript
5833 lines
161 KiB
JavaScript
"no use strict";
|
|
!(function(window) {
|
|
if (typeof window.window != "undefined" && window.document)
|
|
return;
|
|
if (window.require && window.define)
|
|
return;
|
|
|
|
if (!window.console) {
|
|
window.console = function() {
|
|
var msgs = Array.prototype.slice.call(arguments, 0);
|
|
postMessage({type: "log", data: msgs});
|
|
};
|
|
window.console.error =
|
|
window.console.warn =
|
|
window.console.log =
|
|
window.console.trace = window.console;
|
|
}
|
|
window.window = window;
|
|
window.ace = window;
|
|
|
|
window.onerror = function(message, file, line, col, err) {
|
|
postMessage({type: "error", data: {
|
|
message: message,
|
|
data: err && err.data,
|
|
file: file,
|
|
line: line,
|
|
col: col,
|
|
stack: err && err.stack
|
|
}});
|
|
};
|
|
|
|
window.normalizeModule = function(parentId, moduleName) {
|
|
// normalize plugin requires
|
|
if (moduleName.indexOf("!") !== -1) {
|
|
var chunks = moduleName.split("!");
|
|
return window.normalizeModule(parentId, chunks[0]) + "!" + window.normalizeModule(parentId, chunks[1]);
|
|
}
|
|
// normalize relative requires
|
|
if (moduleName.charAt(0) == ".") {
|
|
var base = parentId.split("/").slice(0, -1).join("/");
|
|
moduleName = (base ? base + "/" : "") + moduleName;
|
|
|
|
while (moduleName.indexOf(".") !== -1 && previous != moduleName) {
|
|
var previous = moduleName;
|
|
moduleName = moduleName.replace(/^\.\//, "").replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
|
|
}
|
|
}
|
|
|
|
return moduleName;
|
|
};
|
|
|
|
window.require = function require(parentId, id) {
|
|
if (!id) {
|
|
id = parentId;
|
|
parentId = null;
|
|
}
|
|
if (!id.charAt)
|
|
throw new Error("worker.js require() accepts only (parentId, id) as arguments");
|
|
|
|
id = window.normalizeModule(parentId, id);
|
|
|
|
var module = window.require.modules[id];
|
|
if (module) {
|
|
if (!module.initialized) {
|
|
module.initialized = true;
|
|
module.exports = module.factory().exports;
|
|
}
|
|
return module.exports;
|
|
}
|
|
|
|
if (!window.require.tlns)
|
|
return console.log("unable to load " + id);
|
|
|
|
var path = resolveModuleId(id, window.require.tlns);
|
|
if (path.slice(-3) != ".js") path += ".js";
|
|
|
|
window.require.id = id;
|
|
window.require.modules[id] = {}; // prevent infinite loop on broken modules
|
|
importScripts(path);
|
|
return window.require(parentId, id);
|
|
};
|
|
function resolveModuleId(id, paths) {
|
|
var testPath = id, tail = "";
|
|
while (testPath) {
|
|
var alias = paths[testPath];
|
|
if (typeof alias == "string") {
|
|
return alias + tail;
|
|
} else if (alias) {
|
|
return alias.location.replace(/\/*$/, "/") + (tail || alias.main || alias.name);
|
|
} else if (alias === false) {
|
|
return "";
|
|
}
|
|
var i = testPath.lastIndexOf("/");
|
|
if (i === -1) break;
|
|
tail = testPath.substr(i) + tail;
|
|
testPath = testPath.slice(0, i);
|
|
}
|
|
return id;
|
|
}
|
|
window.require.modules = {};
|
|
window.require.tlns = {};
|
|
|
|
window.define = function(id, deps, factory) {
|
|
if (arguments.length == 2) {
|
|
factory = deps;
|
|
if (typeof id != "string") {
|
|
deps = id;
|
|
id = window.require.id;
|
|
}
|
|
} else if (arguments.length == 1) {
|
|
factory = id;
|
|
deps = [];
|
|
id = window.require.id;
|
|
}
|
|
|
|
if (typeof factory != "function") {
|
|
window.require.modules[id] = {
|
|
exports: factory,
|
|
initialized: true
|
|
};
|
|
return;
|
|
}
|
|
|
|
if (!deps.length)
|
|
// If there is no dependencies, we inject "require", "exports" and
|
|
// "module" as dependencies, to provide CommonJS compatibility.
|
|
deps = ["require", "exports", "module"];
|
|
|
|
var req = function(childId) {
|
|
return window.require(id, childId);
|
|
};
|
|
|
|
window.require.modules[id] = {
|
|
exports: {},
|
|
factory: function() {
|
|
var module = this;
|
|
var returnExports = factory.apply(this, deps.slice(0, factory.length).map(function(dep) {
|
|
switch (dep) {
|
|
// Because "require", "exports" and "module" aren't actual
|
|
// dependencies, we must handle them seperately.
|
|
case "require": return req;
|
|
case "exports": return module.exports;
|
|
case "module": return module;
|
|
// But for all other dependencies, we can just go ahead and
|
|
// require them.
|
|
default: return req(dep);
|
|
}
|
|
}));
|
|
if (returnExports)
|
|
module.exports = returnExports;
|
|
return module;
|
|
}
|
|
};
|
|
};
|
|
window.define.amd = {};
|
|
window.require.tlns = {};
|
|
window.initBaseUrls = function initBaseUrls(topLevelNamespaces) {
|
|
for (var i in topLevelNamespaces)
|
|
this.require.tlns[i] = topLevelNamespaces[i];
|
|
};
|
|
|
|
window.initSender = function initSender() {
|
|
|
|
var EventEmitter = window.require("ace/lib/event_emitter").EventEmitter;
|
|
var oop = window.require("ace/lib/oop");
|
|
|
|
var Sender = function() {};
|
|
|
|
(function() {
|
|
|
|
oop.implement(this, EventEmitter);
|
|
|
|
this.callback = function(data, callbackId) {
|
|
postMessage({
|
|
type: "call",
|
|
id: callbackId,
|
|
data: data
|
|
});
|
|
};
|
|
|
|
this.emit = function(name, data) {
|
|
postMessage({
|
|
type: "event",
|
|
name: name,
|
|
data: data
|
|
});
|
|
};
|
|
|
|
}).call(Sender.prototype);
|
|
|
|
return new Sender();
|
|
};
|
|
|
|
var main = window.main = null;
|
|
var sender = window.sender = null;
|
|
|
|
window.onmessage = function(e) {
|
|
var msg = e.data;
|
|
if (msg.event && sender) {
|
|
sender._signal(msg.event, msg.data);
|
|
}
|
|
else if (msg.command) {
|
|
if (main[msg.command])
|
|
main[msg.command].apply(main, msg.args);
|
|
else if (window[msg.command])
|
|
window[msg.command].apply(window, msg.args);
|
|
else
|
|
throw new Error("Unknown command:" + msg.command);
|
|
}
|
|
else if (msg.init) {
|
|
window.initBaseUrls(msg.tlns);
|
|
sender = window.sender = window.initSender();
|
|
var clazz = this.require(msg.module)[msg.classname];
|
|
main = window.main = new clazz(sender);
|
|
}
|
|
};
|
|
})(this);
|
|
|
|
ace.define("ace/lib/oop",[], function(require, exports, module){"use strict";
|
|
exports.inherits = function (ctor, superCtor) {
|
|
ctor.super_ = superCtor;
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
exports.mixin = function (obj, mixin) {
|
|
for (var key in mixin) {
|
|
obj[key] = mixin[key];
|
|
}
|
|
return obj;
|
|
};
|
|
exports.implement = function (proto, mixin) {
|
|
exports.mixin(proto, mixin);
|
|
};
|
|
|
|
});
|
|
|
|
ace.define("ace/apply_delta",[], function(require, exports, module){"use strict";
|
|
function throwDeltaError(delta, errorText) {
|
|
console.log("Invalid Delta:", delta);
|
|
throw "Invalid Delta: " + errorText;
|
|
}
|
|
function positionInDocument(docLines, position) {
|
|
return position.row >= 0 && position.row < docLines.length &&
|
|
position.column >= 0 && position.column <= docLines[position.row].length;
|
|
}
|
|
function validateDelta(docLines, delta) {
|
|
if (delta.action != "insert" && delta.action != "remove")
|
|
throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");
|
|
if (!(delta.lines instanceof Array))
|
|
throwDeltaError(delta, "delta.lines must be an Array");
|
|
if (!delta.start || !delta.end)
|
|
throwDeltaError(delta, "delta.start/end must be an present");
|
|
var start = delta.start;
|
|
if (!positionInDocument(docLines, delta.start))
|
|
throwDeltaError(delta, "delta.start must be contained in document");
|
|
var end = delta.end;
|
|
if (delta.action == "remove" && !positionInDocument(docLines, end))
|
|
throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");
|
|
var numRangeRows = end.row - start.row;
|
|
var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0));
|
|
if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars)
|
|
throwDeltaError(delta, "delta.range must match delta lines");
|
|
}
|
|
exports.applyDelta = function (docLines, delta, doNotValidate) {
|
|
var row = delta.start.row;
|
|
var startColumn = delta.start.column;
|
|
var line = docLines[row] || "";
|
|
switch (delta.action) {
|
|
case "insert":
|
|
var lines = delta.lines;
|
|
if (lines.length === 1) {
|
|
docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);
|
|
}
|
|
else {
|
|
var args = [row, 1].concat(delta.lines);
|
|
docLines.splice.apply(docLines, args);
|
|
docLines[row] = line.substring(0, startColumn) + docLines[row];
|
|
docLines[row + delta.lines.length - 1] += line.substring(startColumn);
|
|
}
|
|
break;
|
|
case "remove":
|
|
var endColumn = delta.end.column;
|
|
var endRow = delta.end.row;
|
|
if (row === endRow) {
|
|
docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);
|
|
}
|
|
else {
|
|
docLines.splice(row, endRow - row + 1, line.substring(0, startColumn) + docLines[endRow].substring(endColumn));
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
});
|
|
|
|
ace.define("ace/lib/event_emitter",[], function(require, exports, module){"use strict";
|
|
var EventEmitter = {};
|
|
var stopPropagation = function () { this.propagationStopped = true; };
|
|
var preventDefault = function () { this.defaultPrevented = true; };
|
|
EventEmitter._emit =
|
|
EventEmitter._dispatchEvent = function (eventName, e) {
|
|
this._eventRegistry || (this._eventRegistry = {});
|
|
this._defaultHandlers || (this._defaultHandlers = {});
|
|
var listeners = this._eventRegistry[eventName] || [];
|
|
var defaultHandler = this._defaultHandlers[eventName];
|
|
if (!listeners.length && !defaultHandler)
|
|
return;
|
|
if (typeof e != "object" || !e)
|
|
e = {};
|
|
if (!e.type)
|
|
e.type = eventName;
|
|
if (!e.stopPropagation)
|
|
e.stopPropagation = stopPropagation;
|
|
if (!e.preventDefault)
|
|
e.preventDefault = preventDefault;
|
|
listeners = listeners.slice();
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
listeners[i](e, this);
|
|
if (e.propagationStopped)
|
|
break;
|
|
}
|
|
if (defaultHandler && !e.defaultPrevented)
|
|
return defaultHandler(e, this);
|
|
};
|
|
EventEmitter._signal = function (eventName, e) {
|
|
var listeners = (this._eventRegistry || {})[eventName];
|
|
if (!listeners)
|
|
return;
|
|
listeners = listeners.slice();
|
|
for (var i = 0; i < listeners.length; i++)
|
|
listeners[i](e, this);
|
|
};
|
|
EventEmitter.once = function (eventName, callback) {
|
|
var _self = this;
|
|
this.on(eventName, function newCallback() {
|
|
_self.off(eventName, newCallback);
|
|
callback.apply(null, arguments);
|
|
});
|
|
if (!callback) {
|
|
return new Promise(function (resolve) {
|
|
callback = resolve;
|
|
});
|
|
}
|
|
};
|
|
EventEmitter.setDefaultHandler = function (eventName, callback) {
|
|
var handlers = this._defaultHandlers;
|
|
if (!handlers)
|
|
handlers = this._defaultHandlers = { _disabled_: {} };
|
|
if (handlers[eventName]) {
|
|
var old = handlers[eventName];
|
|
var disabled = handlers._disabled_[eventName];
|
|
if (!disabled)
|
|
handlers._disabled_[eventName] = disabled = [];
|
|
disabled.push(old);
|
|
var i = disabled.indexOf(callback);
|
|
if (i != -1)
|
|
disabled.splice(i, 1);
|
|
}
|
|
handlers[eventName] = callback;
|
|
};
|
|
EventEmitter.removeDefaultHandler = function (eventName, callback) {
|
|
var handlers = this._defaultHandlers;
|
|
if (!handlers)
|
|
return;
|
|
var disabled = handlers._disabled_[eventName];
|
|
if (handlers[eventName] == callback) {
|
|
if (disabled)
|
|
this.setDefaultHandler(eventName, disabled.pop());
|
|
}
|
|
else if (disabled) {
|
|
var i = disabled.indexOf(callback);
|
|
if (i != -1)
|
|
disabled.splice(i, 1);
|
|
}
|
|
};
|
|
EventEmitter.on =
|
|
EventEmitter.addEventListener = function (eventName, callback, capturing) {
|
|
this._eventRegistry = this._eventRegistry || {};
|
|
var listeners = this._eventRegistry[eventName];
|
|
if (!listeners)
|
|
listeners = this._eventRegistry[eventName] = [];
|
|
if (listeners.indexOf(callback) == -1)
|
|
listeners[capturing ? "unshift" : "push"](callback);
|
|
return callback;
|
|
};
|
|
EventEmitter.off =
|
|
EventEmitter.removeListener =
|
|
EventEmitter.removeEventListener = function (eventName, callback) {
|
|
this._eventRegistry = this._eventRegistry || {};
|
|
var listeners = this._eventRegistry[eventName];
|
|
if (!listeners)
|
|
return;
|
|
var index = listeners.indexOf(callback);
|
|
if (index !== -1)
|
|
listeners.splice(index, 1);
|
|
};
|
|
EventEmitter.removeAllListeners = function (eventName) {
|
|
if (!eventName)
|
|
this._eventRegistry = this._defaultHandlers = undefined;
|
|
if (this._eventRegistry)
|
|
this._eventRegistry[eventName] = undefined;
|
|
if (this._defaultHandlers)
|
|
this._defaultHandlers[eventName] = undefined;
|
|
};
|
|
exports.EventEmitter = EventEmitter;
|
|
|
|
});
|
|
|
|
ace.define("ace/range",[], function(require, exports, module){"use strict";
|
|
var comparePoints = function (p1, p2) {
|
|
return p1.row - p2.row || p1.column - p2.column;
|
|
};
|
|
var Range = function (startRow, startColumn, endRow, endColumn) {
|
|
this.start = {
|
|
row: startRow,
|
|
column: startColumn
|
|
};
|
|
this.end = {
|
|
row: endRow,
|
|
column: endColumn
|
|
};
|
|
};
|
|
(function () {
|
|
this.isEqual = function (range) {
|
|
return this.start.row === range.start.row &&
|
|
this.end.row === range.end.row &&
|
|
this.start.column === range.start.column &&
|
|
this.end.column === range.end.column;
|
|
};
|
|
this.toString = function () {
|
|
return ("Range: [" + this.start.row + "/" + this.start.column +
|
|
"] -> [" + this.end.row + "/" + this.end.column + "]");
|
|
};
|
|
this.contains = function (row, column) {
|
|
return this.compare(row, column) == 0;
|
|
};
|
|
this.compareRange = function (range) {
|
|
var cmp, end = range.end, start = range.start;
|
|
cmp = this.compare(end.row, end.column);
|
|
if (cmp == 1) {
|
|
cmp = this.compare(start.row, start.column);
|
|
if (cmp == 1) {
|
|
return 2;
|
|
}
|
|
else if (cmp == 0) {
|
|
return 1;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
else if (cmp == -1) {
|
|
return -2;
|
|
}
|
|
else {
|
|
cmp = this.compare(start.row, start.column);
|
|
if (cmp == -1) {
|
|
return -1;
|
|
}
|
|
else if (cmp == 1) {
|
|
return 42;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
};
|
|
this.comparePoint = function (p) {
|
|
return this.compare(p.row, p.column);
|
|
};
|
|
this.containsRange = function (range) {
|
|
return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
|
|
};
|
|
this.intersects = function (range) {
|
|
var cmp = this.compareRange(range);
|
|
return (cmp == -1 || cmp == 0 || cmp == 1);
|
|
};
|
|
this.isEnd = function (row, column) {
|
|
return this.end.row == row && this.end.column == column;
|
|
};
|
|
this.isStart = function (row, column) {
|
|
return this.start.row == row && this.start.column == column;
|
|
};
|
|
this.setStart = function (row, column) {
|
|
if (typeof row == "object") {
|
|
this.start.column = row.column;
|
|
this.start.row = row.row;
|
|
}
|
|
else {
|
|
this.start.row = row;
|
|
this.start.column = column;
|
|
}
|
|
};
|
|
this.setEnd = function (row, column) {
|
|
if (typeof row == "object") {
|
|
this.end.column = row.column;
|
|
this.end.row = row.row;
|
|
}
|
|
else {
|
|
this.end.row = row;
|
|
this.end.column = column;
|
|
}
|
|
};
|
|
this.inside = function (row, column) {
|
|
if (this.compare(row, column) == 0) {
|
|
if (this.isEnd(row, column) || this.isStart(row, column)) {
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
this.insideStart = function (row, column) {
|
|
if (this.compare(row, column) == 0) {
|
|
if (this.isEnd(row, column)) {
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
this.insideEnd = function (row, column) {
|
|
if (this.compare(row, column) == 0) {
|
|
if (this.isStart(row, column)) {
|
|
return false;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
this.compare = function (row, column) {
|
|
if (!this.isMultiLine()) {
|
|
if (row === this.start.row) {
|
|
return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
|
|
}
|
|
}
|
|
if (row < this.start.row)
|
|
return -1;
|
|
if (row > this.end.row)
|
|
return 1;
|
|
if (this.start.row === row)
|
|
return column >= this.start.column ? 0 : -1;
|
|
if (this.end.row === row)
|
|
return column <= this.end.column ? 0 : 1;
|
|
return 0;
|
|
};
|
|
this.compareStart = function (row, column) {
|
|
if (this.start.row == row && this.start.column == column) {
|
|
return -1;
|
|
}
|
|
else {
|
|
return this.compare(row, column);
|
|
}
|
|
};
|
|
this.compareEnd = function (row, column) {
|
|
if (this.end.row == row && this.end.column == column) {
|
|
return 1;
|
|
}
|
|
else {
|
|
return this.compare(row, column);
|
|
}
|
|
};
|
|
this.compareInside = function (row, column) {
|
|
if (this.end.row == row && this.end.column == column) {
|
|
return 1;
|
|
}
|
|
else if (this.start.row == row && this.start.column == column) {
|
|
return -1;
|
|
}
|
|
else {
|
|
return this.compare(row, column);
|
|
}
|
|
};
|
|
this.clipRows = function (firstRow, lastRow) {
|
|
if (this.end.row > lastRow)
|
|
var end = { row: lastRow + 1, column: 0 };
|
|
else if (this.end.row < firstRow)
|
|
var end = { row: firstRow, column: 0 };
|
|
if (this.start.row > lastRow)
|
|
var start = { row: lastRow + 1, column: 0 };
|
|
else if (this.start.row < firstRow)
|
|
var start = { row: firstRow, column: 0 };
|
|
return Range.fromPoints(start || this.start, end || this.end);
|
|
};
|
|
this.extend = function (row, column) {
|
|
var cmp = this.compare(row, column);
|
|
if (cmp == 0)
|
|
return this;
|
|
else if (cmp == -1)
|
|
var start = { row: row, column: column };
|
|
else
|
|
var end = { row: row, column: column };
|
|
return Range.fromPoints(start || this.start, end || this.end);
|
|
};
|
|
this.isEmpty = function () {
|
|
return (this.start.row === this.end.row && this.start.column === this.end.column);
|
|
};
|
|
this.isMultiLine = function () {
|
|
return (this.start.row !== this.end.row);
|
|
};
|
|
this.clone = function () {
|
|
return Range.fromPoints(this.start, this.end);
|
|
};
|
|
this.collapseRows = function () {
|
|
if (this.end.column == 0)
|
|
return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0);
|
|
else
|
|
return new Range(this.start.row, 0, this.end.row, 0);
|
|
};
|
|
this.toScreenRange = function (session) {
|
|
var screenPosStart = session.documentToScreenPosition(this.start);
|
|
var screenPosEnd = session.documentToScreenPosition(this.end);
|
|
return new Range(screenPosStart.row, screenPosStart.column, screenPosEnd.row, screenPosEnd.column);
|
|
};
|
|
this.moveBy = function (row, column) {
|
|
this.start.row += row;
|
|
this.start.column += column;
|
|
this.end.row += row;
|
|
this.end.column += column;
|
|
};
|
|
}).call(Range.prototype);
|
|
Range.fromPoints = function (start, end) {
|
|
return new Range(start.row, start.column, end.row, end.column);
|
|
};
|
|
Range.comparePoints = comparePoints;
|
|
Range.comparePoints = function (p1, p2) {
|
|
return p1.row - p2.row || p1.column - p2.column;
|
|
};
|
|
exports.Range = Range;
|
|
|
|
});
|
|
|
|
ace.define("ace/anchor",[], function(require, exports, module){"use strict";
|
|
var oop = require("./lib/oop");
|
|
var EventEmitter = require("./lib/event_emitter").EventEmitter;
|
|
var Anchor = exports.Anchor = function (doc, row, column) {
|
|
this.$onChange = this.onChange.bind(this);
|
|
this.attach(doc);
|
|
if (typeof column == "undefined")
|
|
this.setPosition(row.row, row.column);
|
|
else
|
|
this.setPosition(row, column);
|
|
};
|
|
(function () {
|
|
oop.implement(this, EventEmitter);
|
|
this.getPosition = function () {
|
|
return this.$clipPositionToDocument(this.row, this.column);
|
|
};
|
|
this.getDocument = function () {
|
|
return this.document;
|
|
};
|
|
this.$insertRight = false;
|
|
this.onChange = function (delta) {
|
|
if (delta.start.row == delta.end.row && delta.start.row != this.row)
|
|
return;
|
|
if (delta.start.row > this.row)
|
|
return;
|
|
var point = $getTransformedPoint(delta, { row: this.row, column: this.column }, this.$insertRight);
|
|
this.setPosition(point.row, point.column, true);
|
|
};
|
|
function $pointsInOrder(point1, point2, equalPointsInOrder) {
|
|
var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;
|
|
return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter);
|
|
}
|
|
function $getTransformedPoint(delta, point, moveIfEqual) {
|
|
var deltaIsInsert = delta.action == "insert";
|
|
var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row);
|
|
var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);
|
|
var deltaStart = delta.start;
|
|
var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.
|
|
if ($pointsInOrder(point, deltaStart, moveIfEqual)) {
|
|
return {
|
|
row: point.row,
|
|
column: point.column
|
|
};
|
|
}
|
|
if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {
|
|
return {
|
|
row: point.row + deltaRowShift,
|
|
column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0)
|
|
};
|
|
}
|
|
return {
|
|
row: deltaStart.row,
|
|
column: deltaStart.column
|
|
};
|
|
}
|
|
this.setPosition = function (row, column, noClip) {
|
|
var pos;
|
|
if (noClip) {
|
|
pos = {
|
|
row: row,
|
|
column: column
|
|
};
|
|
}
|
|
else {
|
|
pos = this.$clipPositionToDocument(row, column);
|
|
}
|
|
if (this.row == pos.row && this.column == pos.column)
|
|
return;
|
|
var old = {
|
|
row: this.row,
|
|
column: this.column
|
|
};
|
|
this.row = pos.row;
|
|
this.column = pos.column;
|
|
this._signal("change", {
|
|
old: old,
|
|
value: pos
|
|
});
|
|
};
|
|
this.detach = function () {
|
|
this.document.off("change", this.$onChange);
|
|
};
|
|
this.attach = function (doc) {
|
|
this.document = doc || this.document;
|
|
this.document.on("change", this.$onChange);
|
|
};
|
|
this.$clipPositionToDocument = function (row, column) {
|
|
var pos = {};
|
|
if (row >= this.document.getLength()) {
|
|
pos.row = Math.max(0, this.document.getLength() - 1);
|
|
pos.column = this.document.getLine(pos.row).length;
|
|
}
|
|
else if (row < 0) {
|
|
pos.row = 0;
|
|
pos.column = 0;
|
|
}
|
|
else {
|
|
pos.row = row;
|
|
pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
|
|
}
|
|
if (column < 0)
|
|
pos.column = 0;
|
|
return pos;
|
|
};
|
|
}).call(Anchor.prototype);
|
|
|
|
});
|
|
|
|
ace.define("ace/document",[], function(require, exports, module){"use strict";
|
|
var oop = require("./lib/oop");
|
|
var applyDelta = require("./apply_delta").applyDelta;
|
|
var EventEmitter = require("./lib/event_emitter").EventEmitter;
|
|
var Range = require("./range").Range;
|
|
var Anchor = require("./anchor").Anchor;
|
|
var Document = function (textOrLines) {
|
|
this.$lines = [""];
|
|
if (textOrLines.length === 0) {
|
|
this.$lines = [""];
|
|
}
|
|
else if (Array.isArray(textOrLines)) {
|
|
this.insertMergedLines({ row: 0, column: 0 }, textOrLines);
|
|
}
|
|
else {
|
|
this.insert({ row: 0, column: 0 }, textOrLines);
|
|
}
|
|
};
|
|
(function () {
|
|
oop.implement(this, EventEmitter);
|
|
this.setValue = function (text) {
|
|
var len = this.getLength() - 1;
|
|
this.remove(new Range(0, 0, len, this.getLine(len).length));
|
|
this.insert({ row: 0, column: 0 }, text || "");
|
|
};
|
|
this.getValue = function () {
|
|
return this.getAllLines().join(this.getNewLineCharacter());
|
|
};
|
|
this.createAnchor = function (row, column) {
|
|
return new Anchor(this, row, column);
|
|
};
|
|
if ("aaa".split(/a/).length === 0) {
|
|
this.$split = function (text) {
|
|
return text.replace(/\r\n|\r/g, "\n").split("\n");
|
|
};
|
|
}
|
|
else {
|
|
this.$split = function (text) {
|
|
return text.split(/\r\n|\r|\n/);
|
|
};
|
|
}
|
|
this.$detectNewLine = function (text) {
|
|
var match = text.match(/^.*?(\r\n|\r|\n)/m);
|
|
this.$autoNewLine = match ? match[1] : "\n";
|
|
this._signal("changeNewLineMode");
|
|
};
|
|
this.getNewLineCharacter = function () {
|
|
switch (this.$newLineMode) {
|
|
case "windows":
|
|
return "\r\n";
|
|
case "unix":
|
|
return "\n";
|
|
default:
|
|
return this.$autoNewLine || "\n";
|
|
}
|
|
};
|
|
this.$autoNewLine = "";
|
|
this.$newLineMode = "auto";
|
|
this.setNewLineMode = function (newLineMode) {
|
|
if (this.$newLineMode === newLineMode)
|
|
return;
|
|
this.$newLineMode = newLineMode;
|
|
this._signal("changeNewLineMode");
|
|
};
|
|
this.getNewLineMode = function () {
|
|
return this.$newLineMode;
|
|
};
|
|
this.isNewLine = function (text) {
|
|
return (text == "\r\n" || text == "\r" || text == "\n");
|
|
};
|
|
this.getLine = function (row) {
|
|
return this.$lines[row] || "";
|
|
};
|
|
this.getLines = function (firstRow, lastRow) {
|
|
return this.$lines.slice(firstRow, lastRow + 1);
|
|
};
|
|
this.getAllLines = function () {
|
|
return this.getLines(0, this.getLength());
|
|
};
|
|
this.getLength = function () {
|
|
return this.$lines.length;
|
|
};
|
|
this.getTextRange = function (range) {
|
|
return this.getLinesForRange(range).join(this.getNewLineCharacter());
|
|
};
|
|
this.getLinesForRange = function (range) {
|
|
var lines;
|
|
if (range.start.row === range.end.row) {
|
|
lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];
|
|
}
|
|
else {
|
|
lines = this.getLines(range.start.row, range.end.row);
|
|
lines[0] = (lines[0] || "").substring(range.start.column);
|
|
var l = lines.length - 1;
|
|
if (range.end.row - range.start.row == l)
|
|
lines[l] = lines[l].substring(0, range.end.column);
|
|
}
|
|
return lines;
|
|
};
|
|
this.insertLines = function (row, lines) {
|
|
console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead.");
|
|
return this.insertFullLines(row, lines);
|
|
};
|
|
this.removeLines = function (firstRow, lastRow) {
|
|
console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead.");
|
|
return this.removeFullLines(firstRow, lastRow);
|
|
};
|
|
this.insertNewLine = function (position) {
|
|
console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");
|
|
return this.insertMergedLines(position, ["", ""]);
|
|
};
|
|
this.insert = function (position, text) {
|
|
if (this.getLength() <= 1)
|
|
this.$detectNewLine(text);
|
|
return this.insertMergedLines(position, this.$split(text));
|
|
};
|
|
this.insertInLine = function (position, text) {
|
|
var start = this.clippedPos(position.row, position.column);
|
|
var end = this.pos(position.row, position.column + text.length);
|
|
this.applyDelta({
|
|
start: start,
|
|
end: end,
|
|
action: "insert",
|
|
lines: [text]
|
|
}, true);
|
|
return this.clonePos(end);
|
|
};
|
|
this.clippedPos = function (row, column) {
|
|
var length = this.getLength();
|
|
if (row === undefined) {
|
|
row = length;
|
|
}
|
|
else if (row < 0) {
|
|
row = 0;
|
|
}
|
|
else if (row >= length) {
|
|
row = length - 1;
|
|
column = undefined;
|
|
}
|
|
var line = this.getLine(row);
|
|
if (column == undefined)
|
|
column = line.length;
|
|
column = Math.min(Math.max(column, 0), line.length);
|
|
return { row: row, column: column };
|
|
};
|
|
this.clonePos = function (pos) {
|
|
return { row: pos.row, column: pos.column };
|
|
};
|
|
this.pos = function (row, column) {
|
|
return { row: row, column: column };
|
|
};
|
|
this.$clipPosition = function (position) {
|
|
var length = this.getLength();
|
|
if (position.row >= length) {
|
|
position.row = Math.max(0, length - 1);
|
|
position.column = this.getLine(length - 1).length;
|
|
}
|
|
else {
|
|
position.row = Math.max(0, position.row);
|
|
position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);
|
|
}
|
|
return position;
|
|
};
|
|
this.insertFullLines = function (row, lines) {
|
|
row = Math.min(Math.max(row, 0), this.getLength());
|
|
var column = 0;
|
|
if (row < this.getLength()) {
|
|
lines = lines.concat([""]);
|
|
column = 0;
|
|
}
|
|
else {
|
|
lines = [""].concat(lines);
|
|
row--;
|
|
column = this.$lines[row].length;
|
|
}
|
|
this.insertMergedLines({ row: row, column: column }, lines);
|
|
};
|
|
this.insertMergedLines = function (position, lines) {
|
|
var start = this.clippedPos(position.row, position.column);
|
|
var end = {
|
|
row: start.row + lines.length - 1,
|
|
column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length
|
|
};
|
|
this.applyDelta({
|
|
start: start,
|
|
end: end,
|
|
action: "insert",
|
|
lines: lines
|
|
});
|
|
return this.clonePos(end);
|
|
};
|
|
this.remove = function (range) {
|
|
var start = this.clippedPos(range.start.row, range.start.column);
|
|
var end = this.clippedPos(range.end.row, range.end.column);
|
|
this.applyDelta({
|
|
start: start,
|
|
end: end,
|
|
action: "remove",
|
|
lines: this.getLinesForRange({ start: start, end: end })
|
|
});
|
|
return this.clonePos(start);
|
|
};
|
|
this.removeInLine = function (row, startColumn, endColumn) {
|
|
var start = this.clippedPos(row, startColumn);
|
|
var end = this.clippedPos(row, endColumn);
|
|
this.applyDelta({
|
|
start: start,
|
|
end: end,
|
|
action: "remove",
|
|
lines: this.getLinesForRange({ start: start, end: end })
|
|
}, true);
|
|
return this.clonePos(start);
|
|
};
|
|
this.removeFullLines = function (firstRow, lastRow) {
|
|
firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);
|
|
lastRow = Math.min(Math.max(0, lastRow), this.getLength() - 1);
|
|
var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;
|
|
var deleteLastNewLine = lastRow < this.getLength() - 1;
|
|
var startRow = (deleteFirstNewLine ? firstRow - 1 : firstRow);
|
|
var startCol = (deleteFirstNewLine ? this.getLine(startRow).length : 0);
|
|
var endRow = (deleteLastNewLine ? lastRow + 1 : lastRow);
|
|
var endCol = (deleteLastNewLine ? 0 : this.getLine(endRow).length);
|
|
var range = new Range(startRow, startCol, endRow, endCol);
|
|
var deletedLines = this.$lines.slice(firstRow, lastRow + 1);
|
|
this.applyDelta({
|
|
start: range.start,
|
|
end: range.end,
|
|
action: "remove",
|
|
lines: this.getLinesForRange(range)
|
|
});
|
|
return deletedLines;
|
|
};
|
|
this.removeNewLine = function (row) {
|
|
if (row < this.getLength() - 1 && row >= 0) {
|
|
this.applyDelta({
|
|
start: this.pos(row, this.getLine(row).length),
|
|
end: this.pos(row + 1, 0),
|
|
action: "remove",
|
|
lines: ["", ""]
|
|
});
|
|
}
|
|
};
|
|
this.replace = function (range, text) {
|
|
if (!(range instanceof Range))
|
|
range = Range.fromPoints(range.start, range.end);
|
|
if (text.length === 0 && range.isEmpty())
|
|
return range.start;
|
|
if (text == this.getTextRange(range))
|
|
return range.end;
|
|
this.remove(range);
|
|
var end;
|
|
if (text) {
|
|
end = this.insert(range.start, text);
|
|
}
|
|
else {
|
|
end = range.start;
|
|
}
|
|
return end;
|
|
};
|
|
this.applyDeltas = function (deltas) {
|
|
for (var i = 0; i < deltas.length; i++) {
|
|
this.applyDelta(deltas[i]);
|
|
}
|
|
};
|
|
this.revertDeltas = function (deltas) {
|
|
for (var i = deltas.length - 1; i >= 0; i--) {
|
|
this.revertDelta(deltas[i]);
|
|
}
|
|
};
|
|
this.applyDelta = function (delta, doNotValidate) {
|
|
var isInsert = delta.action == "insert";
|
|
if (isInsert ? delta.lines.length <= 1 && !delta.lines[0]
|
|
: !Range.comparePoints(delta.start, delta.end)) {
|
|
return;
|
|
}
|
|
if (isInsert && delta.lines.length > 20000) {
|
|
this.$splitAndapplyLargeDelta(delta, 20000);
|
|
}
|
|
else {
|
|
applyDelta(this.$lines, delta, doNotValidate);
|
|
this._signal("change", delta);
|
|
}
|
|
};
|
|
this.$safeApplyDelta = function (delta) {
|
|
var docLength = this.$lines.length;
|
|
if (delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength
|
|
|| delta.action == "insert" && delta.start.row <= docLength) {
|
|
this.applyDelta(delta);
|
|
}
|
|
};
|
|
this.$splitAndapplyLargeDelta = function (delta, MAX) {
|
|
var lines = delta.lines;
|
|
var l = lines.length - MAX + 1;
|
|
var row = delta.start.row;
|
|
var column = delta.start.column;
|
|
for (var from = 0, to = 0; from < l; from = to) {
|
|
to += MAX - 1;
|
|
var chunk = lines.slice(from, to);
|
|
chunk.push("");
|
|
this.applyDelta({
|
|
start: this.pos(row + from, column),
|
|
end: this.pos(row + to, column = 0),
|
|
action: delta.action,
|
|
lines: chunk
|
|
}, true);
|
|
}
|
|
delta.lines = lines.slice(from);
|
|
delta.start.row = row + from;
|
|
delta.start.column = column;
|
|
this.applyDelta(delta, true);
|
|
};
|
|
this.revertDelta = function (delta) {
|
|
this.$safeApplyDelta({
|
|
start: this.clonePos(delta.start),
|
|
end: this.clonePos(delta.end),
|
|
action: (delta.action == "insert" ? "remove" : "insert"),
|
|
lines: delta.lines.slice()
|
|
});
|
|
};
|
|
this.indexToPosition = function (index, startRow) {
|
|
var lines = this.$lines || this.getAllLines();
|
|
var newlineLength = this.getNewLineCharacter().length;
|
|
for (var i = startRow || 0, l = lines.length; i < l; i++) {
|
|
index -= lines[i].length + newlineLength;
|
|
if (index < 0)
|
|
return { row: i, column: index + lines[i].length + newlineLength };
|
|
}
|
|
return { row: l - 1, column: index + lines[l - 1].length + newlineLength };
|
|
};
|
|
this.positionToIndex = function (pos, startRow) {
|
|
var lines = this.$lines || this.getAllLines();
|
|
var newlineLength = this.getNewLineCharacter().length;
|
|
var index = 0;
|
|
var row = Math.min(pos.row, lines.length);
|
|
for (var i = startRow || 0; i < row; ++i)
|
|
index += lines[i].length + newlineLength;
|
|
return index + pos.column;
|
|
};
|
|
}).call(Document.prototype);
|
|
exports.Document = Document;
|
|
|
|
});
|
|
|
|
ace.define("ace/lib/lang",[], function(require, exports, module){"use strict";
|
|
exports.last = function (a) {
|
|
return a[a.length - 1];
|
|
};
|
|
exports.stringReverse = function (string) {
|
|
return string.split("").reverse().join("");
|
|
};
|
|
exports.stringRepeat = function (string, count) {
|
|
var result = '';
|
|
while (count > 0) {
|
|
if (count & 1)
|
|
result += string;
|
|
if (count >>= 1)
|
|
string += string;
|
|
}
|
|
return result;
|
|
};
|
|
var trimBeginRegexp = /^\s\s*/;
|
|
var trimEndRegexp = /\s\s*$/;
|
|
exports.stringTrimLeft = function (string) {
|
|
return string.replace(trimBeginRegexp, '');
|
|
};
|
|
exports.stringTrimRight = function (string) {
|
|
return string.replace(trimEndRegexp, '');
|
|
};
|
|
exports.copyObject = function (obj) {
|
|
var copy = {};
|
|
for (var key in obj) {
|
|
copy[key] = obj[key];
|
|
}
|
|
return copy;
|
|
};
|
|
exports.copyArray = function (array) {
|
|
var copy = [];
|
|
for (var i = 0, l = array.length; i < l; i++) {
|
|
if (array[i] && typeof array[i] == "object")
|
|
copy[i] = this.copyObject(array[i]);
|
|
else
|
|
copy[i] = array[i];
|
|
}
|
|
return copy;
|
|
};
|
|
exports.deepCopy = function deepCopy(obj) {
|
|
if (typeof obj !== "object" || !obj)
|
|
return obj;
|
|
var copy;
|
|
if (Array.isArray(obj)) {
|
|
copy = [];
|
|
for (var key = 0; key < obj.length; key++) {
|
|
copy[key] = deepCopy(obj[key]);
|
|
}
|
|
return copy;
|
|
}
|
|
if (Object.prototype.toString.call(obj) !== "[object Object]")
|
|
return obj;
|
|
copy = {};
|
|
for (var key in obj)
|
|
copy[key] = deepCopy(obj[key]);
|
|
return copy;
|
|
};
|
|
exports.arrayToMap = function (arr) {
|
|
var map = {};
|
|
for (var i = 0; i < arr.length; i++) {
|
|
map[arr[i]] = 1;
|
|
}
|
|
return map;
|
|
};
|
|
exports.createMap = function (props) {
|
|
var map = Object.create(null);
|
|
for (var i in props) {
|
|
map[i] = props[i];
|
|
}
|
|
return map;
|
|
};
|
|
exports.arrayRemove = function (array, value) {
|
|
for (var i = 0; i <= array.length; i++) {
|
|
if (value === array[i]) {
|
|
array.splice(i, 1);
|
|
}
|
|
}
|
|
};
|
|
exports.escapeRegExp = function (str) {
|
|
return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
|
|
};
|
|
exports.escapeHTML = function (str) {
|
|
return ("" + str).replace(/&/g, "&").replace(/"/g, """).replace(/'/g, "'").replace(/</g, "<");
|
|
};
|
|
exports.getMatchOffsets = function (string, regExp) {
|
|
var matches = [];
|
|
string.replace(regExp, function (str) {
|
|
matches.push({
|
|
offset: arguments[arguments.length - 2],
|
|
length: str.length
|
|
});
|
|
});
|
|
return matches;
|
|
};
|
|
exports.deferredCall = function (fcn) {
|
|
var timer = null;
|
|
var callback = function () {
|
|
timer = null;
|
|
fcn();
|
|
};
|
|
var deferred = function (timeout) {
|
|
deferred.cancel();
|
|
timer = setTimeout(callback, timeout || 0);
|
|
return deferred;
|
|
};
|
|
deferred.schedule = deferred;
|
|
deferred.call = function () {
|
|
this.cancel();
|
|
fcn();
|
|
return deferred;
|
|
};
|
|
deferred.cancel = function () {
|
|
clearTimeout(timer);
|
|
timer = null;
|
|
return deferred;
|
|
};
|
|
deferred.isPending = function () {
|
|
return timer;
|
|
};
|
|
return deferred;
|
|
};
|
|
exports.delayedCall = function (fcn, defaultTimeout) {
|
|
var timer = null;
|
|
var callback = function () {
|
|
timer = null;
|
|
fcn();
|
|
};
|
|
var _self = function (timeout) {
|
|
if (timer == null)
|
|
timer = setTimeout(callback, timeout || defaultTimeout);
|
|
};
|
|
_self.delay = function (timeout) {
|
|
timer && clearTimeout(timer);
|
|
timer = setTimeout(callback, timeout || defaultTimeout);
|
|
};
|
|
_self.schedule = _self;
|
|
_self.call = function () {
|
|
this.cancel();
|
|
fcn();
|
|
};
|
|
_self.cancel = function () {
|
|
timer && clearTimeout(timer);
|
|
timer = null;
|
|
};
|
|
_self.isPending = function () {
|
|
return timer;
|
|
};
|
|
return _self;
|
|
};
|
|
|
|
});
|
|
|
|
ace.define("ace/worker/mirror",[], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var Document = require("../document").Document;
|
|
var lang = require("../lib/lang");
|
|
|
|
var Mirror = exports.Mirror = function(sender) {
|
|
this.sender = sender;
|
|
var doc = this.doc = new Document("");
|
|
|
|
var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this));
|
|
|
|
var _self = this;
|
|
sender.on("change", function(e) {
|
|
var data = e.data;
|
|
if (data[0].start) {
|
|
doc.applyDeltas(data);
|
|
} else {
|
|
for (var i = 0; i < data.length; i += 2) {
|
|
var d, err;
|
|
if (Array.isArray(data[i+1])) {
|
|
d = {action: "insert", start: data[i], lines: data[i+1]};
|
|
} else {
|
|
d = {action: "remove", start: data[i], end: data[i+1]};
|
|
}
|
|
|
|
if ((d.action == "insert" ? d.start : d.end).row >= doc.$lines.length) {
|
|
err = new Error("Invalid delta");
|
|
err.data = {
|
|
path: _self.$path,
|
|
linesLength: doc.$lines.length,
|
|
start: d.start,
|
|
end: d.end
|
|
};
|
|
throw err;
|
|
}
|
|
|
|
doc.applyDelta(d, true);
|
|
}
|
|
}
|
|
if (_self.$timeout)
|
|
return deferredUpdate.schedule(_self.$timeout);
|
|
_self.onUpdate();
|
|
});
|
|
};
|
|
|
|
(function() {
|
|
|
|
this.$timeout = 500;
|
|
|
|
this.setTimeout = function(timeout) {
|
|
this.$timeout = timeout;
|
|
};
|
|
|
|
this.setValue = function(value) {
|
|
this.doc.setValue(value);
|
|
this.deferredUpdate.schedule(this.$timeout);
|
|
};
|
|
|
|
this.getValue = function(callbackId) {
|
|
this.sender.callback(this.doc.getValue(), callbackId);
|
|
};
|
|
|
|
this.onUpdate = function() {
|
|
};
|
|
|
|
this.isPending = function() {
|
|
return this.deferredUpdate.isPending();
|
|
};
|
|
|
|
}).call(Mirror.prototype);
|
|
|
|
});
|
|
|
|
ace.define("ace/mode/yaml/yaml-lint",[], function(require, exports, module) {
|
|
var $build_deps$ = {require: require, exports: exports, module: module};
|
|
exports = undefined; module = undefined;
|
|
function define(name, deps, m) {
|
|
if (typeof name == "function") {
|
|
m = name; deps = ["require", "exports", "module"]; name = $build_deps$.module.id
|
|
}
|
|
if (typeof name !== "string") {
|
|
m = deps; deps = name; name = $build_deps$.module.id
|
|
}
|
|
if (!m) {
|
|
m = deps; deps = [];
|
|
}
|
|
var ret = typeof m == "function" ?
|
|
m.apply($build_deps$.module, deps.map(function(n){return $build_deps$[n] || require(n)})) : m
|
|
if (ret != undefined) $build_deps$.module.exports = ret;
|
|
}
|
|
define.amd = true;(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f();}else if(typeof define==="function"&&define.amd){define([],f);}else{var g;if(typeof window!=="undefined"){g=window;}else if(typeof global!=="undefined"){g=global;}else if(typeof self!=="undefined"){g=self;}else{g=this;}g.lint = f();}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=typeof require=="function"&&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=typeof require=="function"&&require,i=0;i<t.length;i++)o(t[i]);return o;}return r;})()({1:[function(require,module,exports){
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
var fs = require('fs');
|
|
var merge = require('lodash.merge');
|
|
var yaml = require('js-yaml');
|
|
|
|
var DEFAULT_LINT_OPTION = {
|
|
schema: 'DEFAULT_SAFE_SCHEMA'
|
|
};
|
|
|
|
function lint(content, opts, cb) {
|
|
|
|
var options = merge({}, DEFAULT_LINT_OPTION, opts);
|
|
try {
|
|
yaml.safeLoad(content, {
|
|
schema: yaml[options.schema]
|
|
});
|
|
cb();
|
|
} catch (e) {
|
|
cb(e);
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
lint: lint
|
|
};
|
|
|
|
},{"fs":1,"js-yaml":3,"lodash.merge":33}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var yaml = require('./lib/js-yaml.js');
|
|
|
|
|
|
module.exports = yaml;
|
|
|
|
},{"./lib/js-yaml.js":4}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var loader = require('./js-yaml/loader');
|
|
var dumper = require('./js-yaml/dumper');
|
|
|
|
|
|
function deprecated(name) {
|
|
return function () {
|
|
throw new Error('Function ' + name + ' is deprecated and cannot be used.');
|
|
};
|
|
}
|
|
|
|
|
|
module.exports.Type = require('./js-yaml/type');
|
|
module.exports.Schema = require('./js-yaml/schema');
|
|
module.exports.FAILSAFE_SCHEMA = require('./js-yaml/schema/failsafe');
|
|
module.exports.JSON_SCHEMA = require('./js-yaml/schema/json');
|
|
module.exports.CORE_SCHEMA = require('./js-yaml/schema/core');
|
|
module.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe');
|
|
module.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full');
|
|
module.exports.load = loader.load;
|
|
module.exports.loadAll = loader.loadAll;
|
|
module.exports.safeLoad = loader.safeLoad;
|
|
module.exports.safeLoadAll = loader.safeLoadAll;
|
|
module.exports.dump = dumper.dump;
|
|
module.exports.safeDump = dumper.safeDump;
|
|
module.exports.YAMLException = require('./js-yaml/exception');
|
|
module.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe');
|
|
module.exports.SAFE_SCHEMA = require('./js-yaml/schema/default_safe');
|
|
module.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full');
|
|
module.exports.scan = deprecated('scan');
|
|
module.exports.parse = deprecated('parse');
|
|
module.exports.compose = deprecated('compose');
|
|
module.exports.addConstructor = deprecated('addConstructor');
|
|
|
|
},{"./js-yaml/dumper":6,"./js-yaml/exception":7,"./js-yaml/loader":8,"./js-yaml/schema":10,"./js-yaml/schema/core":11,"./js-yaml/schema/default_full":12,"./js-yaml/schema/default_safe":13,"./js-yaml/schema/failsafe":14,"./js-yaml/schema/json":15,"./js-yaml/type":16}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
function isNothing(subject) {
|
|
return (typeof subject === 'undefined') || (subject === null);
|
|
}
|
|
|
|
|
|
function isObject(subject) {
|
|
return (typeof subject === 'object') && (subject !== null);
|
|
}
|
|
|
|
|
|
function toArray(sequence) {
|
|
if (Array.isArray(sequence)) return sequence;
|
|
else if (isNothing(sequence)) return [];
|
|
|
|
return [ sequence ];
|
|
}
|
|
|
|
|
|
function extend(target, source) {
|
|
var index, length, key, sourceKeys;
|
|
|
|
if (source) {
|
|
sourceKeys = Object.keys(source);
|
|
|
|
for (index = 0, length = sourceKeys.length; index < length; index += 1) {
|
|
key = sourceKeys[index];
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
|
|
function repeat(string, count) {
|
|
var result = '', cycle;
|
|
|
|
for (cycle = 0; cycle < count; cycle += 1) {
|
|
result += string;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
function isNegativeZero(number) {
|
|
return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
|
|
}
|
|
|
|
|
|
module.exports.isNothing = isNothing;
|
|
module.exports.isObject = isObject;
|
|
module.exports.toArray = toArray;
|
|
module.exports.repeat = repeat;
|
|
module.exports.isNegativeZero = isNegativeZero;
|
|
module.exports.extend = extend;
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var common = require('./common');
|
|
var YAMLException = require('./exception');
|
|
var DEFAULT_FULL_SCHEMA = require('./schema/default_full');
|
|
var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');
|
|
|
|
var _toString = Object.prototype.toString;
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
var CHAR_TAB = 0x09;
|
|
var CHAR_LINE_FEED = 0x0A;
|
|
var CHAR_SPACE = 0x20;
|
|
var CHAR_EXCLAMATION = 0x21;
|
|
var CHAR_DOUBLE_QUOTE = 0x22;
|
|
var CHAR_SHARP = 0x23;
|
|
var CHAR_PERCENT = 0x25;
|
|
var CHAR_AMPERSAND = 0x26;
|
|
var CHAR_SINGLE_QUOTE = 0x27;
|
|
var CHAR_ASTERISK = 0x2A;
|
|
var CHAR_COMMA = 0x2C;
|
|
var CHAR_MINUS = 0x2D;
|
|
var CHAR_COLON = 0x3A;
|
|
var CHAR_GREATER_THAN = 0x3E;
|
|
var CHAR_QUESTION = 0x3F;
|
|
var CHAR_COMMERCIAL_AT = 0x40;
|
|
var CHAR_LEFT_SQUARE_BRACKET = 0x5B;
|
|
var CHAR_RIGHT_SQUARE_BRACKET = 0x5D;
|
|
var CHAR_GRAVE_ACCENT = 0x60;
|
|
var CHAR_LEFT_CURLY_BRACKET = 0x7B;
|
|
var CHAR_VERTICAL_LINE = 0x7C;
|
|
var CHAR_RIGHT_CURLY_BRACKET = 0x7D;
|
|
|
|
var ESCAPE_SEQUENCES = {};
|
|
|
|
ESCAPE_SEQUENCES[0x00] = '\\0';
|
|
ESCAPE_SEQUENCES[0x07] = '\\a';
|
|
ESCAPE_SEQUENCES[0x08] = '\\b';
|
|
ESCAPE_SEQUENCES[0x09] = '\\t';
|
|
ESCAPE_SEQUENCES[0x0A] = '\\n';
|
|
ESCAPE_SEQUENCES[0x0B] = '\\v';
|
|
ESCAPE_SEQUENCES[0x0C] = '\\f';
|
|
ESCAPE_SEQUENCES[0x0D] = '\\r';
|
|
ESCAPE_SEQUENCES[0x1B] = '\\e';
|
|
ESCAPE_SEQUENCES[0x22] = '\\"';
|
|
ESCAPE_SEQUENCES[0x5C] = '\\\\';
|
|
ESCAPE_SEQUENCES[0x85] = '\\N';
|
|
ESCAPE_SEQUENCES[0xA0] = '\\_';
|
|
ESCAPE_SEQUENCES[0x2028] = '\\L';
|
|
ESCAPE_SEQUENCES[0x2029] = '\\P';
|
|
|
|
var DEPRECATED_BOOLEANS_SYNTAX = [
|
|
'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
|
|
'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
|
|
];
|
|
|
|
function compileStyleMap(schema, map) {
|
|
var result, keys, index, length, tag, style, type;
|
|
|
|
if (map === null) return {};
|
|
|
|
result = {};
|
|
keys = Object.keys(map);
|
|
|
|
for (index = 0, length = keys.length; index < length; index += 1) {
|
|
tag = keys[index];
|
|
style = String(map[tag]);
|
|
|
|
if (tag.slice(0, 2) === '!!') {
|
|
tag = 'tag:yaml.org,2002:' + tag.slice(2);
|
|
}
|
|
type = schema.compiledTypeMap['fallback'][tag];
|
|
|
|
if (type && _hasOwnProperty.call(type.styleAliases, style)) {
|
|
style = type.styleAliases[style];
|
|
}
|
|
|
|
result[tag] = style;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function encodeHex(character) {
|
|
var string, handle, length;
|
|
|
|
string = character.toString(16).toUpperCase();
|
|
|
|
if (character <= 0xFF) {
|
|
handle = 'x';
|
|
length = 2;
|
|
} else if (character <= 0xFFFF) {
|
|
handle = 'u';
|
|
length = 4;
|
|
} else if (character <= 0xFFFFFFFF) {
|
|
handle = 'U';
|
|
length = 8;
|
|
} else {
|
|
throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
|
|
}
|
|
|
|
return '\\' + handle + common.repeat('0', length - string.length) + string;
|
|
}
|
|
|
|
function State(options) {
|
|
this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
|
|
this.indent = Math.max(1, (options['indent'] || 2));
|
|
this.noArrayIndent = options['noArrayIndent'] || false;
|
|
this.skipInvalid = options['skipInvalid'] || false;
|
|
this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
|
|
this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
|
|
this.sortKeys = options['sortKeys'] || false;
|
|
this.lineWidth = options['lineWidth'] || 80;
|
|
this.noRefs = options['noRefs'] || false;
|
|
this.noCompatMode = options['noCompatMode'] || false;
|
|
this.condenseFlow = options['condenseFlow'] || false;
|
|
|
|
this.implicitTypes = this.schema.compiledImplicit;
|
|
this.explicitTypes = this.schema.compiledExplicit;
|
|
|
|
this.tag = null;
|
|
this.result = '';
|
|
|
|
this.duplicates = [];
|
|
this.usedDuplicates = null;
|
|
}
|
|
function indentString(string, spaces) {
|
|
var ind = common.repeat(' ', spaces),
|
|
position = 0,
|
|
next = -1,
|
|
result = '',
|
|
line,
|
|
length = string.length;
|
|
|
|
while (position < length) {
|
|
next = string.indexOf('\n', position);
|
|
if (next === -1) {
|
|
line = string.slice(position);
|
|
position = length;
|
|
} else {
|
|
line = string.slice(position, next + 1);
|
|
position = next + 1;
|
|
}
|
|
|
|
if (line.length && line !== '\n') result += ind;
|
|
|
|
result += line;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function generateNextLine(state, level) {
|
|
return '\n' + common.repeat(' ', state.indent * level);
|
|
}
|
|
|
|
function testImplicitResolving(state, str) {
|
|
var index, length, type;
|
|
|
|
for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
|
|
type = state.implicitTypes[index];
|
|
|
|
if (type.resolve(str)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
function isWhitespace(c) {
|
|
return c === CHAR_SPACE || c === CHAR_TAB;
|
|
}
|
|
function isPrintable(c) {
|
|
return (c >= 0x00020 && c <= 0x00007E)
|
|
|| ((c >= 0x000A1 && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
|
|
|| ((c >= 0x0E000 && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)
|
|
|| (c >= 0x10000 && c <= 0x10FFFF);
|
|
}
|
|
function isPlainSafe(c) {
|
|
return isPrintable(c) && c !== 0xFEFF
|
|
&& c !== CHAR_COMMA
|
|
&& c !== CHAR_LEFT_SQUARE_BRACKET
|
|
&& c !== CHAR_RIGHT_SQUARE_BRACKET
|
|
&& c !== CHAR_LEFT_CURLY_BRACKET
|
|
&& c !== CHAR_RIGHT_CURLY_BRACKET
|
|
&& c !== CHAR_COLON
|
|
&& c !== CHAR_SHARP;
|
|
}
|
|
function isPlainSafeFirst(c) {
|
|
return isPrintable(c) && c !== 0xFEFF
|
|
&& !isWhitespace(c) // - s-white
|
|
&& c !== CHAR_MINUS
|
|
&& c !== CHAR_QUESTION
|
|
&& c !== CHAR_COLON
|
|
&& c !== CHAR_COMMA
|
|
&& c !== CHAR_LEFT_SQUARE_BRACKET
|
|
&& c !== CHAR_RIGHT_SQUARE_BRACKET
|
|
&& c !== CHAR_LEFT_CURLY_BRACKET
|
|
&& c !== CHAR_RIGHT_CURLY_BRACKET
|
|
&& c !== CHAR_SHARP
|
|
&& c !== CHAR_AMPERSAND
|
|
&& c !== CHAR_ASTERISK
|
|
&& c !== CHAR_EXCLAMATION
|
|
&& c !== CHAR_VERTICAL_LINE
|
|
&& c !== CHAR_GREATER_THAN
|
|
&& c !== CHAR_SINGLE_QUOTE
|
|
&& c !== CHAR_DOUBLE_QUOTE
|
|
&& c !== CHAR_PERCENT
|
|
&& c !== CHAR_COMMERCIAL_AT
|
|
&& c !== CHAR_GRAVE_ACCENT;
|
|
}
|
|
function needIndentIndicator(string) {
|
|
var leadingSpaceRe = /^\n* /;
|
|
return leadingSpaceRe.test(string);
|
|
}
|
|
|
|
var STYLE_PLAIN = 1,
|
|
STYLE_SINGLE = 2,
|
|
STYLE_LITERAL = 3,
|
|
STYLE_FOLDED = 4,
|
|
STYLE_DOUBLE = 5;
|
|
function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
|
|
var i;
|
|
var char;
|
|
var hasLineBreak = false;
|
|
var hasFoldableLine = false; // only checked if shouldTrackWidth
|
|
var shouldTrackWidth = lineWidth !== -1;
|
|
var previousLineBreak = -1; // count the first line correctly
|
|
var plain = isPlainSafeFirst(string.charCodeAt(0))
|
|
&& !isWhitespace(string.charCodeAt(string.length - 1));
|
|
|
|
if (singleLineOnly) {
|
|
for (i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (!isPrintable(char)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
plain = plain && isPlainSafe(char);
|
|
}
|
|
} else {
|
|
for (i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (char === CHAR_LINE_FEED) {
|
|
hasLineBreak = true;
|
|
if (shouldTrackWidth) {
|
|
hasFoldableLine = hasFoldableLine ||
|
|
(i - previousLineBreak - 1 > lineWidth &&
|
|
string[previousLineBreak + 1] !== ' ');
|
|
previousLineBreak = i;
|
|
}
|
|
} else if (!isPrintable(char)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
plain = plain && isPlainSafe(char);
|
|
}
|
|
hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
|
|
(i - previousLineBreak - 1 > lineWidth &&
|
|
string[previousLineBreak + 1] !== ' '));
|
|
}
|
|
if (!hasLineBreak && !hasFoldableLine) {
|
|
return plain && !testAmbiguousType(string)
|
|
? STYLE_PLAIN : STYLE_SINGLE;
|
|
}
|
|
if (indentPerLevel > 9 && needIndentIndicator(string)) {
|
|
return STYLE_DOUBLE;
|
|
}
|
|
return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
|
|
}
|
|
function writeScalar(state, string, level, iskey) {
|
|
state.dump = (function () {
|
|
if (string.length === 0) {
|
|
return "''";
|
|
}
|
|
if (!state.noCompatMode &&
|
|
DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
|
|
return "'" + string + "'";
|
|
}
|
|
|
|
var indent = state.indent * Math.max(1, level); // no 0-indent scalars
|
|
var lineWidth = state.lineWidth === -1
|
|
? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
|
|
var singleLineOnly = iskey
|
|
|| (state.flowLevel > -1 && level >= state.flowLevel);
|
|
function testAmbiguity(string) {
|
|
return testImplicitResolving(state, string);
|
|
}
|
|
|
|
switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
|
|
case STYLE_PLAIN:
|
|
return string;
|
|
case STYLE_SINGLE:
|
|
return "'" + string.replace(/'/g, "''") + "'";
|
|
case STYLE_LITERAL:
|
|
return '|' + blockHeader(string, state.indent)
|
|
+ dropEndingNewline(indentString(string, indent));
|
|
case STYLE_FOLDED:
|
|
return '>' + blockHeader(string, state.indent)
|
|
+ dropEndingNewline(indentString(foldString(string, lineWidth), indent));
|
|
case STYLE_DOUBLE:
|
|
return '"' + escapeString(string, lineWidth) + '"';
|
|
default:
|
|
throw new YAMLException('impossible error: invalid scalar style');
|
|
}
|
|
}());
|
|
}
|
|
function blockHeader(string, indentPerLevel) {
|
|
var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
|
|
var clip = string[string.length - 1] === '\n';
|
|
var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
|
|
var chomp = keep ? '+' : (clip ? '' : '-');
|
|
|
|
return indentIndicator + chomp + '\n';
|
|
}
|
|
function dropEndingNewline(string) {
|
|
return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
|
|
}
|
|
function foldString(string, width) {
|
|
var lineRe = /(\n+)([^\n]*)/g;
|
|
var result = (function () {
|
|
var nextLF = string.indexOf('\n');
|
|
nextLF = nextLF !== -1 ? nextLF : string.length;
|
|
lineRe.lastIndex = nextLF;
|
|
return foldLine(string.slice(0, nextLF), width);
|
|
}());
|
|
var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
|
|
var moreIndented;
|
|
var match;
|
|
while ((match = lineRe.exec(string))) {
|
|
var prefix = match[1], line = match[2];
|
|
moreIndented = (line[0] === ' ');
|
|
result += prefix
|
|
+ (!prevMoreIndented && !moreIndented && line !== ''
|
|
? '\n' : '')
|
|
+ foldLine(line, width);
|
|
prevMoreIndented = moreIndented;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
function foldLine(line, width) {
|
|
if (line === '' || line[0] === ' ') return line;
|
|
var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
|
|
var match;
|
|
var start = 0, end, curr = 0, next = 0;
|
|
var result = '';
|
|
while ((match = breakRe.exec(line))) {
|
|
next = match.index;
|
|
if (next - start > width) {
|
|
end = (curr > start) ? curr : next; // derive end <= length-2
|
|
result += '\n' + line.slice(start, end);
|
|
start = end + 1; // derive start <= length-1
|
|
}
|
|
curr = next;
|
|
}
|
|
result += '\n';
|
|
if (line.length - start > width && curr > start) {
|
|
result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
|
|
} else {
|
|
result += line.slice(start);
|
|
}
|
|
|
|
return result.slice(1); // drop extra \n joiner
|
|
}
|
|
function escapeString(string) {
|
|
var result = '';
|
|
var char, nextChar;
|
|
var escapeSeq;
|
|
|
|
for (var i = 0; i < string.length; i++) {
|
|
char = string.charCodeAt(i);
|
|
if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {
|
|
nextChar = string.charCodeAt(i + 1);
|
|
if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {
|
|
result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
|
|
i++; continue;
|
|
}
|
|
}
|
|
escapeSeq = ESCAPE_SEQUENCES[char];
|
|
result += !escapeSeq && isPrintable(char)
|
|
? string[i]
|
|
: escapeSeq || encodeHex(char);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function writeFlowSequence(state, level, object) {
|
|
var _result = '',
|
|
_tag = state.tag,
|
|
index,
|
|
length;
|
|
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
if (writeNode(state, level, object[index], false, false)) {
|
|
if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
|
|
_result += state.dump;
|
|
}
|
|
}
|
|
|
|
state.tag = _tag;
|
|
state.dump = '[' + _result + ']';
|
|
}
|
|
|
|
function writeBlockSequence(state, level, object, compact) {
|
|
var _result = '',
|
|
_tag = state.tag,
|
|
index,
|
|
length;
|
|
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
if (writeNode(state, level + 1, object[index], true, true)) {
|
|
if (!compact || index !== 0) {
|
|
_result += generateNextLine(state, level);
|
|
}
|
|
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
_result += '-';
|
|
} else {
|
|
_result += '- ';
|
|
}
|
|
|
|
_result += state.dump;
|
|
}
|
|
}
|
|
|
|
state.tag = _tag;
|
|
state.dump = _result || '[]'; // Empty sequence if no valid values.
|
|
}
|
|
|
|
function writeFlowMapping(state, level, object) {
|
|
var _result = '',
|
|
_tag = state.tag,
|
|
objectKeyList = Object.keys(object),
|
|
index,
|
|
length,
|
|
objectKey,
|
|
objectValue,
|
|
pairBuffer;
|
|
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
pairBuffer = state.condenseFlow ? '"' : '';
|
|
|
|
if (index !== 0) pairBuffer += ', ';
|
|
|
|
objectKey = objectKeyList[index];
|
|
objectValue = object[objectKey];
|
|
|
|
if (!writeNode(state, level, objectKey, false, false)) {
|
|
continue; // Skip this pair because of invalid key;
|
|
}
|
|
|
|
if (state.dump.length > 1024) pairBuffer += '? ';
|
|
|
|
pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
|
|
|
|
if (!writeNode(state, level, objectValue, false, false)) {
|
|
continue; // Skip this pair because of invalid value.
|
|
}
|
|
|
|
pairBuffer += state.dump;
|
|
_result += pairBuffer;
|
|
}
|
|
|
|
state.tag = _tag;
|
|
state.dump = '{' + _result + '}';
|
|
}
|
|
|
|
function writeBlockMapping(state, level, object, compact) {
|
|
var _result = '',
|
|
_tag = state.tag,
|
|
objectKeyList = Object.keys(object),
|
|
index,
|
|
length,
|
|
objectKey,
|
|
objectValue,
|
|
explicitPair,
|
|
pairBuffer;
|
|
if (state.sortKeys === true) {
|
|
objectKeyList.sort();
|
|
} else if (typeof state.sortKeys === 'function') {
|
|
objectKeyList.sort(state.sortKeys);
|
|
} else if (state.sortKeys) {
|
|
throw new YAMLException('sortKeys must be a boolean or a function');
|
|
}
|
|
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
pairBuffer = '';
|
|
|
|
if (!compact || index !== 0) {
|
|
pairBuffer += generateNextLine(state, level);
|
|
}
|
|
|
|
objectKey = objectKeyList[index];
|
|
objectValue = object[objectKey];
|
|
|
|
if (!writeNode(state, level + 1, objectKey, true, true, true)) {
|
|
continue; // Skip this pair because of invalid key.
|
|
}
|
|
|
|
explicitPair = (state.tag !== null && state.tag !== '?') ||
|
|
(state.dump && state.dump.length > 1024);
|
|
|
|
if (explicitPair) {
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
pairBuffer += '?';
|
|
} else {
|
|
pairBuffer += '? ';
|
|
}
|
|
}
|
|
|
|
pairBuffer += state.dump;
|
|
|
|
if (explicitPair) {
|
|
pairBuffer += generateNextLine(state, level);
|
|
}
|
|
|
|
if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
|
|
continue; // Skip this pair because of invalid value.
|
|
}
|
|
|
|
if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
|
|
pairBuffer += ':';
|
|
} else {
|
|
pairBuffer += ': ';
|
|
}
|
|
|
|
pairBuffer += state.dump;
|
|
_result += pairBuffer;
|
|
}
|
|
|
|
state.tag = _tag;
|
|
state.dump = _result || '{}'; // Empty mapping if no valid pairs.
|
|
}
|
|
|
|
function detectType(state, object, explicit) {
|
|
var _result, typeList, index, length, type, style;
|
|
|
|
typeList = explicit ? state.explicitTypes : state.implicitTypes;
|
|
|
|
for (index = 0, length = typeList.length; index < length; index += 1) {
|
|
type = typeList[index];
|
|
|
|
if ((type.instanceOf || type.predicate) &&
|
|
(!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
|
|
(!type.predicate || type.predicate(object))) {
|
|
|
|
state.tag = explicit ? type.tag : '?';
|
|
|
|
if (type.represent) {
|
|
style = state.styleMap[type.tag] || type.defaultStyle;
|
|
|
|
if (_toString.call(type.represent) === '[object Function]') {
|
|
_result = type.represent(object, style);
|
|
} else if (_hasOwnProperty.call(type.represent, style)) {
|
|
_result = type.represent[style](object, style);
|
|
} else {
|
|
throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
|
|
}
|
|
|
|
state.dump = _result;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
function writeNode(state, level, object, block, compact, iskey) {
|
|
state.tag = null;
|
|
state.dump = object;
|
|
|
|
if (!detectType(state, object, false)) {
|
|
detectType(state, object, true);
|
|
}
|
|
|
|
var type = _toString.call(state.dump);
|
|
|
|
if (block) {
|
|
block = (state.flowLevel < 0 || state.flowLevel > level);
|
|
}
|
|
|
|
var objectOrArray = type === '[object Object]' || type === '[object Array]',
|
|
duplicateIndex,
|
|
duplicate;
|
|
|
|
if (objectOrArray) {
|
|
duplicateIndex = state.duplicates.indexOf(object);
|
|
duplicate = duplicateIndex !== -1;
|
|
}
|
|
|
|
if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
|
|
compact = false;
|
|
}
|
|
|
|
if (duplicate && state.usedDuplicates[duplicateIndex]) {
|
|
state.dump = '*ref_' + duplicateIndex;
|
|
} else {
|
|
if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
|
|
state.usedDuplicates[duplicateIndex] = true;
|
|
}
|
|
if (type === '[object Object]') {
|
|
if (block && (Object.keys(state.dump).length !== 0)) {
|
|
writeBlockMapping(state, level, state.dump, compact);
|
|
if (duplicate) {
|
|
state.dump = '&ref_' + duplicateIndex + state.dump;
|
|
}
|
|
} else {
|
|
writeFlowMapping(state, level, state.dump);
|
|
if (duplicate) {
|
|
state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
|
|
}
|
|
}
|
|
} else if (type === '[object Array]') {
|
|
var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
|
|
if (block && (state.dump.length !== 0)) {
|
|
writeBlockSequence(state, arrayLevel, state.dump, compact);
|
|
if (duplicate) {
|
|
state.dump = '&ref_' + duplicateIndex + state.dump;
|
|
}
|
|
} else {
|
|
writeFlowSequence(state, arrayLevel, state.dump);
|
|
if (duplicate) {
|
|
state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
|
|
}
|
|
}
|
|
} else if (type === '[object String]') {
|
|
if (state.tag !== '?') {
|
|
writeScalar(state, state.dump, level, iskey);
|
|
}
|
|
} else {
|
|
if (state.skipInvalid) return false;
|
|
throw new YAMLException('unacceptable kind of an object to dump ' + type);
|
|
}
|
|
|
|
if (state.tag !== null && state.tag !== '?') {
|
|
state.dump = '!<' + state.tag + '> ' + state.dump;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function getDuplicateReferences(object, state) {
|
|
var objects = [],
|
|
duplicatesIndexes = [],
|
|
index,
|
|
length;
|
|
|
|
inspectNode(object, objects, duplicatesIndexes);
|
|
|
|
for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
|
|
state.duplicates.push(objects[duplicatesIndexes[index]]);
|
|
}
|
|
state.usedDuplicates = new Array(length);
|
|
}
|
|
|
|
function inspectNode(object, objects, duplicatesIndexes) {
|
|
var objectKeyList,
|
|
index,
|
|
length;
|
|
|
|
if (object !== null && typeof object === 'object') {
|
|
index = objects.indexOf(object);
|
|
if (index !== -1) {
|
|
if (duplicatesIndexes.indexOf(index) === -1) {
|
|
duplicatesIndexes.push(index);
|
|
}
|
|
} else {
|
|
objects.push(object);
|
|
|
|
if (Array.isArray(object)) {
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
inspectNode(object[index], objects, duplicatesIndexes);
|
|
}
|
|
} else {
|
|
objectKeyList = Object.keys(object);
|
|
|
|
for (index = 0, length = objectKeyList.length; index < length; index += 1) {
|
|
inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function dump(input, options) {
|
|
options = options || {};
|
|
|
|
var state = new State(options);
|
|
|
|
if (!state.noRefs) getDuplicateReferences(input, state);
|
|
|
|
if (writeNode(state, 0, input, true, true)) return state.dump + '\n';
|
|
|
|
return '';
|
|
}
|
|
|
|
function safeDump(input, options) {
|
|
return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
|
|
}
|
|
|
|
module.exports.dump = dump;
|
|
module.exports.safeDump = safeDump;
|
|
|
|
},{"./common":5,"./exception":7,"./schema/default_full":12,"./schema/default_safe":13}],7:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
function YAMLException(reason, mark) {
|
|
Error.call(this);
|
|
|
|
this.name = 'YAMLException';
|
|
this.reason = reason;
|
|
this.mark = mark;
|
|
this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
this.stack = (new Error()).stack || '';
|
|
}
|
|
}
|
|
YAMLException.prototype = Object.create(Error.prototype);
|
|
YAMLException.prototype.constructor = YAMLException;
|
|
|
|
|
|
YAMLException.prototype.toString = function toString(compact) {
|
|
var result = this.name + ': ';
|
|
|
|
result += this.reason || '(unknown reason)';
|
|
|
|
if (!compact && this.mark) {
|
|
result += ' ' + this.mark.toString();
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
|
|
module.exports = YAMLException;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var common = require('./common');
|
|
var YAMLException = require('./exception');
|
|
var Mark = require('./mark');
|
|
var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');
|
|
var DEFAULT_FULL_SCHEMA = require('./schema/default_full');
|
|
|
|
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
|
|
var CONTEXT_FLOW_IN = 1;
|
|
var CONTEXT_FLOW_OUT = 2;
|
|
var CONTEXT_BLOCK_IN = 3;
|
|
var CONTEXT_BLOCK_OUT = 4;
|
|
|
|
|
|
var CHOMPING_CLIP = 1;
|
|
var CHOMPING_STRIP = 2;
|
|
var CHOMPING_KEEP = 3;
|
|
|
|
|
|
var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
|
|
var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
|
|
var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
|
|
var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
|
|
var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
|
|
|
|
|
|
function is_EOL(c) {
|
|
return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
|
|
}
|
|
|
|
function is_WHITE_SPACE(c) {
|
|
return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
|
|
}
|
|
|
|
function is_WS_OR_EOL(c) {
|
|
return (c === 0x09/* Tab */) ||
|
|
(c === 0x20/* Space */) ||
|
|
(c === 0x0A/* LF */) ||
|
|
(c === 0x0D/* CR */);
|
|
}
|
|
|
|
function is_FLOW_INDICATOR(c) {
|
|
return c === 0x2C/* , */ ||
|
|
c === 0x5B/* [ */ ||
|
|
c === 0x5D/* ] */ ||
|
|
c === 0x7B/* { */ ||
|
|
c === 0x7D/* } */;
|
|
}
|
|
|
|
function fromHexCode(c) {
|
|
var lc;
|
|
|
|
if ((c/* 0 */ >= 0x30) && (c <= 0x39/* 9 */)) {
|
|
return c - 0x30;
|
|
}
|
|
lc = c | 0x20;
|
|
|
|
if ((lc/* a */ >= 0x61) && (lc <= 0x66/* f */)) {
|
|
return lc - 0x61 + 10;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
function escapedHexLen(c) {
|
|
if (c === 0x78/* x */) { return 2; }
|
|
if (c === 0x75/* u */) { return 4; }
|
|
if (c === 0x55/* U */) { return 8; }
|
|
return 0;
|
|
}
|
|
|
|
function fromDecimalCode(c) {
|
|
if ((c/* 0 */ >= 0x30) && (c <= 0x39/* 9 */)) {
|
|
return c - 0x30;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
function simpleEscapeSequence(c) {
|
|
return (c === 0x30/* 0 */) ? '\x00' :
|
|
(c === 0x61/* a */) ? '\x07' :
|
|
(c === 0x62/* b */) ? '\x08' :
|
|
(c === 0x74/* t */) ? '\x09' :
|
|
(c === 0x09/* Tab */) ? '\x09' :
|
|
(c === 0x6E/* n */) ? '\x0A' :
|
|
(c === 0x76/* v */) ? '\x0B' :
|
|
(c === 0x66/* f */) ? '\x0C' :
|
|
(c === 0x72/* r */) ? '\x0D' :
|
|
(c === 0x65/* e */) ? '\x1B' :
|
|
(c === 0x20/* Space */) ? ' ' :
|
|
(c === 0x22/* " */) ? '\x22' :
|
|
(c === 0x2F/* / */) ? '/' :
|
|
(c === 0x5C/* \ */) ? '\x5C' :
|
|
(c === 0x4E/* N */) ? '\x85' :
|
|
(c === 0x5F/* _ */) ? '\xA0' :
|
|
(c === 0x4C/* L */) ? '\u2028' :
|
|
(c === 0x50/* P */) ? '\u2029' : '';
|
|
}
|
|
|
|
function charFromCodepoint(c) {
|
|
if (c <= 0xFFFF) {
|
|
return String.fromCharCode(c);
|
|
}
|
|
return String.fromCharCode(
|
|
((c - 0x010000) >> 10) + 0xD800,
|
|
((c - 0x010000) & 0x03FF) + 0xDC00
|
|
);
|
|
}
|
|
|
|
var simpleEscapeCheck = new Array(256); // integer, for fast access
|
|
var simpleEscapeMap = new Array(256);
|
|
for (var i = 0; i < 256; i++) {
|
|
simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
|
|
simpleEscapeMap[i] = simpleEscapeSequence(i);
|
|
}
|
|
|
|
|
|
function State(input, options) {
|
|
this.input = input;
|
|
|
|
this.filename = options['filename'] || null;
|
|
this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
|
|
this.onWarning = options['onWarning'] || null;
|
|
this.legacy = options['legacy'] || false;
|
|
this.json = options['json'] || false;
|
|
this.listener = options['listener'] || null;
|
|
|
|
this.implicitTypes = this.schema.compiledImplicit;
|
|
this.typeMap = this.schema.compiledTypeMap;
|
|
|
|
this.length = input.length;
|
|
this.position = 0;
|
|
this.line = 0;
|
|
this.lineStart = 0;
|
|
this.lineIndent = 0;
|
|
|
|
this.documents = [];
|
|
|
|
}
|
|
|
|
|
|
function generateError(state, message) {
|
|
return new YAMLException(
|
|
message,
|
|
new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
|
|
}
|
|
|
|
function throwError(state, message) {
|
|
throw generateError(state, message);
|
|
}
|
|
|
|
function throwWarning(state, message) {
|
|
if (state.onWarning) {
|
|
state.onWarning.call(null, generateError(state, message));
|
|
}
|
|
}
|
|
|
|
|
|
var directiveHandlers = {
|
|
|
|
YAML: function handleYamlDirective(state, name, args) {
|
|
|
|
var match, major, minor;
|
|
|
|
if (state.version !== null) {
|
|
throwError(state, 'duplication of %YAML directive');
|
|
}
|
|
|
|
if (args.length !== 1) {
|
|
throwError(state, 'YAML directive accepts exactly one argument');
|
|
}
|
|
|
|
match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
|
|
|
|
if (match === null) {
|
|
throwError(state, 'ill-formed argument of the YAML directive');
|
|
}
|
|
|
|
major = parseInt(match[1], 10);
|
|
minor = parseInt(match[2], 10);
|
|
|
|
if (major !== 1) {
|
|
throwError(state, 'unacceptable YAML version of the document');
|
|
}
|
|
|
|
state.version = args[0];
|
|
state.checkLineBreaks = (minor < 2);
|
|
|
|
if (minor !== 1 && minor !== 2) {
|
|
throwWarning(state, 'unsupported YAML version of the document');
|
|
}
|
|
},
|
|
|
|
TAG: function handleTagDirective(state, name, args) {
|
|
|
|
var handle, prefix;
|
|
|
|
if (args.length !== 2) {
|
|
throwError(state, 'TAG directive accepts exactly two arguments');
|
|
}
|
|
|
|
handle = args[0];
|
|
prefix = args[1];
|
|
|
|
if (!PATTERN_TAG_HANDLE.test(handle)) {
|
|
throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
|
|
}
|
|
|
|
if (_hasOwnProperty.call(state.tagMap, handle)) {
|
|
throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
|
|
}
|
|
|
|
if (!PATTERN_TAG_URI.test(prefix)) {
|
|
throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
|
|
}
|
|
|
|
state.tagMap[handle] = prefix;
|
|
}
|
|
};
|
|
|
|
|
|
function captureSegment(state, start, end, checkJson) {
|
|
var _position, _length, _character, _result;
|
|
|
|
if (start < end) {
|
|
_result = state.input.slice(start, end);
|
|
|
|
if (checkJson) {
|
|
for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
|
|
_character = _result.charCodeAt(_position);
|
|
if (!(_character === 0x09 ||
|
|
(_character >= 0x20 && _character <= 0x10FFFF))) {
|
|
throwError(state, 'expected valid JSON character');
|
|
}
|
|
}
|
|
} else if (PATTERN_NON_PRINTABLE.test(_result)) {
|
|
throwError(state, 'the stream contains non-printable characters');
|
|
}
|
|
|
|
state.result += _result;
|
|
}
|
|
}
|
|
|
|
function mergeMappings(state, destination, source, overridableKeys) {
|
|
var sourceKeys, key, index, quantity;
|
|
|
|
if (!common.isObject(source)) {
|
|
throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
|
|
}
|
|
|
|
sourceKeys = Object.keys(source);
|
|
|
|
for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
|
|
key = sourceKeys[index];
|
|
|
|
if (!_hasOwnProperty.call(destination, key)) {
|
|
destination[key] = source[key];
|
|
overridableKeys[key] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
|
|
var index, quantity;
|
|
|
|
keyNode = String(keyNode);
|
|
|
|
if (_result === null) {
|
|
_result = {};
|
|
}
|
|
|
|
if (keyTag === 'tag:yaml.org,2002:merge') {
|
|
if (Array.isArray(valueNode)) {
|
|
for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
|
|
mergeMappings(state, _result, valueNode[index], overridableKeys);
|
|
}
|
|
} else {
|
|
mergeMappings(state, _result, valueNode, overridableKeys);
|
|
}
|
|
} else {
|
|
if (!state.json &&
|
|
!_hasOwnProperty.call(overridableKeys, keyNode) &&
|
|
_hasOwnProperty.call(_result, keyNode)) {
|
|
state.line = startLine || state.line;
|
|
state.position = startPos || state.position;
|
|
throwError(state, 'duplicated mapping key');
|
|
}
|
|
_result[keyNode] = valueNode;
|
|
delete overridableKeys[keyNode];
|
|
}
|
|
|
|
return _result;
|
|
}
|
|
|
|
function readLineBreak(state) {
|
|
var ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch === 0x0A/* LF */) {
|
|
state.position++;
|
|
} else if (ch === 0x0D/* CR */) {
|
|
state.position++;
|
|
if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
|
|
state.position++;
|
|
}
|
|
} else {
|
|
throwError(state, 'a line break is expected');
|
|
}
|
|
|
|
state.line += 1;
|
|
state.lineStart = state.position;
|
|
}
|
|
|
|
function skipSeparationSpace(state, allowComments, checkIndent) {
|
|
var lineBreaks = 0,
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
while (ch !== 0) {
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (allowComments && ch === 0x23/* # */) {
|
|
do {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
|
|
}
|
|
|
|
if (is_EOL(ch)) {
|
|
readLineBreak(state);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
lineBreaks++;
|
|
state.lineIndent = 0;
|
|
|
|
while (ch === 0x20/* Space */) {
|
|
state.lineIndent++;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
|
|
throwWarning(state, 'deficient indentation');
|
|
}
|
|
|
|
return lineBreaks;
|
|
}
|
|
|
|
function testDocumentSeparator(state) {
|
|
var _position = state.position,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(_position);
|
|
if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
|
|
ch === state.input.charCodeAt(_position + 1) &&
|
|
ch === state.input.charCodeAt(_position + 2)) {
|
|
|
|
_position += 3;
|
|
|
|
ch = state.input.charCodeAt(_position);
|
|
|
|
if (ch === 0 || is_WS_OR_EOL(ch)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function writeFoldedLines(state, count) {
|
|
if (count === 1) {
|
|
state.result += ' ';
|
|
} else if (count > 1) {
|
|
state.result += common.repeat('\n', count - 1);
|
|
}
|
|
}
|
|
|
|
|
|
function readPlainScalar(state, nodeIndent, withinFlowCollection) {
|
|
var preceding,
|
|
following,
|
|
captureStart,
|
|
captureEnd,
|
|
hasPendingContent,
|
|
_line,
|
|
_lineStart,
|
|
_lineIndent,
|
|
_kind = state.kind,
|
|
_result = state.result,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (is_WS_OR_EOL(ch) ||
|
|
is_FLOW_INDICATOR(ch) ||
|
|
ch === 0x23/* # */ ||
|
|
ch === 0x26/* & */ ||
|
|
ch === 0x2A/* * */ ||
|
|
ch === 0x21/* ! */ ||
|
|
ch === 0x7C/* | */ ||
|
|
ch === 0x3E/* > */ ||
|
|
ch === 0x27/* ' */ ||
|
|
ch === 0x22/* " */ ||
|
|
ch === 0x25/* % */ ||
|
|
ch === 0x40/* @ */ ||
|
|
ch === 0x60/* ` */) {
|
|
return false;
|
|
}
|
|
|
|
if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
|
|
if (is_WS_OR_EOL(following) ||
|
|
withinFlowCollection && is_FLOW_INDICATOR(following)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
state.kind = 'scalar';
|
|
state.result = '';
|
|
captureStart = captureEnd = state.position;
|
|
hasPendingContent = false;
|
|
|
|
while (ch !== 0) {
|
|
if (ch === 0x3A/* : */) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
|
|
if (is_WS_OR_EOL(following) ||
|
|
withinFlowCollection && is_FLOW_INDICATOR(following)) {
|
|
break;
|
|
}
|
|
|
|
} else if (ch === 0x23/* # */) {
|
|
preceding = state.input.charCodeAt(state.position - 1);
|
|
|
|
if (is_WS_OR_EOL(preceding)) {
|
|
break;
|
|
}
|
|
|
|
} else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
|
|
withinFlowCollection && is_FLOW_INDICATOR(ch)) {
|
|
break;
|
|
|
|
} else if (is_EOL(ch)) {
|
|
_line = state.line;
|
|
_lineStart = state.lineStart;
|
|
_lineIndent = state.lineIndent;
|
|
skipSeparationSpace(state, false, -1);
|
|
|
|
if (state.lineIndent >= nodeIndent) {
|
|
hasPendingContent = true;
|
|
ch = state.input.charCodeAt(state.position);
|
|
continue;
|
|
} else {
|
|
state.position = captureEnd;
|
|
state.line = _line;
|
|
state.lineStart = _lineStart;
|
|
state.lineIndent = _lineIndent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hasPendingContent) {
|
|
captureSegment(state, captureStart, captureEnd, false);
|
|
writeFoldedLines(state, state.line - _line);
|
|
captureStart = captureEnd = state.position;
|
|
hasPendingContent = false;
|
|
}
|
|
|
|
if (!is_WHITE_SPACE(ch)) {
|
|
captureEnd = state.position + 1;
|
|
}
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
captureSegment(state, captureStart, captureEnd, false);
|
|
|
|
if (state.result) {
|
|
return true;
|
|
}
|
|
|
|
state.kind = _kind;
|
|
state.result = _result;
|
|
return false;
|
|
}
|
|
|
|
function readSingleQuotedScalar(state, nodeIndent) {
|
|
var ch,
|
|
captureStart, captureEnd;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch !== 0x27/* ' */) {
|
|
return false;
|
|
}
|
|
|
|
state.kind = 'scalar';
|
|
state.result = '';
|
|
state.position++;
|
|
captureStart = captureEnd = state.position;
|
|
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
if (ch === 0x27/* ' */) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if (ch === 0x27/* ' */) {
|
|
captureStart = state.position;
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
} else {
|
|
return true;
|
|
}
|
|
|
|
} else if (is_EOL(ch)) {
|
|
captureSegment(state, captureStart, captureEnd, true);
|
|
writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
|
|
captureStart = captureEnd = state.position;
|
|
|
|
} else if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
throwError(state, 'unexpected end of the document within a single quoted scalar');
|
|
|
|
} else {
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
}
|
|
}
|
|
|
|
throwError(state, 'unexpected end of the stream within a single quoted scalar');
|
|
}
|
|
|
|
function readDoubleQuotedScalar(state, nodeIndent) {
|
|
var captureStart,
|
|
captureEnd,
|
|
hexLength,
|
|
hexResult,
|
|
tmp,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch !== 0x22/* " */) {
|
|
return false;
|
|
}
|
|
|
|
state.kind = 'scalar';
|
|
state.result = '';
|
|
state.position++;
|
|
captureStart = captureEnd = state.position;
|
|
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
if (ch === 0x22/* " */) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
state.position++;
|
|
return true;
|
|
|
|
} else if (ch === 0x5C/* \ */) {
|
|
captureSegment(state, captureStart, state.position, true);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if (is_EOL(ch)) {
|
|
skipSeparationSpace(state, false, nodeIndent);
|
|
} else if (ch < 256 && simpleEscapeCheck[ch]) {
|
|
state.result += simpleEscapeMap[ch];
|
|
state.position++;
|
|
|
|
} else if ((tmp = escapedHexLen(ch)) > 0) {
|
|
hexLength = tmp;
|
|
hexResult = 0;
|
|
|
|
for (; hexLength > 0; hexLength--) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if ((tmp = fromHexCode(ch)) >= 0) {
|
|
hexResult = (hexResult << 4) + tmp;
|
|
|
|
} else {
|
|
throwError(state, 'expected hexadecimal character');
|
|
}
|
|
}
|
|
|
|
state.result += charFromCodepoint(hexResult);
|
|
|
|
state.position++;
|
|
|
|
} else {
|
|
throwError(state, 'unknown escape sequence');
|
|
}
|
|
|
|
captureStart = captureEnd = state.position;
|
|
|
|
} else if (is_EOL(ch)) {
|
|
captureSegment(state, captureStart, captureEnd, true);
|
|
writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
|
|
captureStart = captureEnd = state.position;
|
|
|
|
} else if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
throwError(state, 'unexpected end of the document within a double quoted scalar');
|
|
|
|
} else {
|
|
state.position++;
|
|
captureEnd = state.position;
|
|
}
|
|
}
|
|
|
|
throwError(state, 'unexpected end of the stream within a double quoted scalar');
|
|
}
|
|
|
|
function readFlowCollection(state, nodeIndent) {
|
|
var readNext = true,
|
|
_line,
|
|
_tag = state.tag,
|
|
_result,
|
|
_anchor = state.anchor,
|
|
following,
|
|
terminator,
|
|
isPair,
|
|
isExplicitPair,
|
|
isMapping,
|
|
overridableKeys = {},
|
|
keyNode,
|
|
keyTag,
|
|
valueNode,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch === 0x5B/* [ */) {
|
|
terminator = 0x5D;
|
|
isMapping = false;
|
|
_result = [];
|
|
} else if (ch === 0x7B/* { */) {
|
|
terminator = 0x7D;
|
|
isMapping = true;
|
|
_result = {};
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
while (ch !== 0) {
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch === terminator) {
|
|
state.position++;
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = isMapping ? 'mapping' : 'sequence';
|
|
state.result = _result;
|
|
return true;
|
|
} else if (!readNext) {
|
|
throwError(state, 'missed comma between flow collection entries');
|
|
}
|
|
|
|
keyTag = keyNode = valueNode = null;
|
|
isPair = isExplicitPair = false;
|
|
|
|
if (ch === 0x3F/* ? */) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
|
|
if (is_WS_OR_EOL(following)) {
|
|
isPair = isExplicitPair = true;
|
|
state.position++;
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
}
|
|
}
|
|
|
|
_line = state.line;
|
|
composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
|
|
keyTag = state.tag;
|
|
keyNode = state.result;
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
|
|
isPair = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
|
|
valueNode = state.result;
|
|
}
|
|
|
|
if (isMapping) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
|
|
} else if (isPair) {
|
|
_result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
|
|
} else {
|
|
_result.push(keyNode);
|
|
}
|
|
|
|
skipSeparationSpace(state, true, nodeIndent);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch === 0x2C/* , */) {
|
|
readNext = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else {
|
|
readNext = false;
|
|
}
|
|
}
|
|
|
|
throwError(state, 'unexpected end of the stream within a flow collection');
|
|
}
|
|
|
|
function readBlockScalar(state, nodeIndent) {
|
|
var captureStart,
|
|
folding,
|
|
chomping = CHOMPING_CLIP,
|
|
didReadContent = false,
|
|
detectedIndent = false,
|
|
textIndent = nodeIndent,
|
|
emptyLines = 0,
|
|
atMoreIndented = false,
|
|
tmp,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch === 0x7C/* | */) {
|
|
folding = false;
|
|
} else if (ch === 0x3E/* > */) {
|
|
folding = true;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
state.kind = 'scalar';
|
|
state.result = '';
|
|
|
|
while (ch !== 0) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
|
|
if (CHOMPING_CLIP === chomping) {
|
|
chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
|
|
} else {
|
|
throwError(state, 'repeat of a chomping mode identifier');
|
|
}
|
|
|
|
} else if ((tmp = fromDecimalCode(ch)) >= 0) {
|
|
if (tmp === 0) {
|
|
throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
|
|
} else if (!detectedIndent) {
|
|
textIndent = nodeIndent + tmp - 1;
|
|
detectedIndent = true;
|
|
} else {
|
|
throwError(state, 'repeat of an indentation width identifier');
|
|
}
|
|
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (is_WHITE_SPACE(ch)) {
|
|
do { ch = state.input.charCodeAt(++state.position); }
|
|
while (is_WHITE_SPACE(ch));
|
|
|
|
if (ch === 0x23/* # */) {
|
|
do { ch = state.input.charCodeAt(++state.position); }
|
|
while (!is_EOL(ch) && (ch !== 0));
|
|
}
|
|
}
|
|
|
|
while (ch !== 0) {
|
|
readLineBreak(state);
|
|
state.lineIndent = 0;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
while ((!detectedIndent || state.lineIndent < textIndent) &&
|
|
(ch === 0x20/* Space */)) {
|
|
state.lineIndent++;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (!detectedIndent && state.lineIndent > textIndent) {
|
|
textIndent = state.lineIndent;
|
|
}
|
|
|
|
if (is_EOL(ch)) {
|
|
emptyLines++;
|
|
continue;
|
|
}
|
|
if (state.lineIndent < textIndent) {
|
|
if (chomping === CHOMPING_KEEP) {
|
|
state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
|
|
} else if (chomping === CHOMPING_CLIP) {
|
|
if (didReadContent) { // i.e. only if the scalar is not empty.
|
|
state.result += '\n';
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (folding) {
|
|
if (is_WHITE_SPACE(ch)) {
|
|
atMoreIndented = true;
|
|
state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
|
|
} else if (atMoreIndented) {
|
|
atMoreIndented = false;
|
|
state.result += common.repeat('\n', emptyLines + 1);
|
|
} else if (emptyLines === 0) {
|
|
if (didReadContent) { // i.e. only if we have already read some scalar content.
|
|
state.result += ' ';
|
|
}
|
|
} else {
|
|
state.result += common.repeat('\n', emptyLines);
|
|
}
|
|
} else {
|
|
state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
|
|
}
|
|
|
|
didReadContent = true;
|
|
detectedIndent = true;
|
|
emptyLines = 0;
|
|
captureStart = state.position;
|
|
|
|
while (!is_EOL(ch) && (ch !== 0)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
captureSegment(state, captureStart, state.position, false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function readBlockSequence(state, nodeIndent) {
|
|
var _line,
|
|
_tag = state.tag,
|
|
_anchor = state.anchor,
|
|
_result = [],
|
|
following,
|
|
detected = false,
|
|
ch;
|
|
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
while (ch !== 0) {
|
|
|
|
if (ch !== 0x2D/* - */) {
|
|
break;
|
|
}
|
|
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
|
|
if (!is_WS_OR_EOL(following)) {
|
|
break;
|
|
}
|
|
|
|
detected = true;
|
|
state.position++;
|
|
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
if (state.lineIndent <= nodeIndent) {
|
|
_result.push(null);
|
|
ch = state.input.charCodeAt(state.position);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
_line = state.line;
|
|
composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
|
|
_result.push(state.result);
|
|
skipSeparationSpace(state, true, -1);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
|
|
throwError(state, 'bad indentation of a sequence entry');
|
|
} else if (state.lineIndent < nodeIndent) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (detected) {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = 'sequence';
|
|
state.result = _result;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function readBlockMapping(state, nodeIndent, flowIndent) {
|
|
var following,
|
|
allowCompact,
|
|
_line,
|
|
_pos,
|
|
_tag = state.tag,
|
|
_anchor = state.anchor,
|
|
_result = {},
|
|
overridableKeys = {},
|
|
keyTag = null,
|
|
keyNode = null,
|
|
valueNode = null,
|
|
atExplicitKey = false,
|
|
detected = false,
|
|
ch;
|
|
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = _result;
|
|
}
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
while (ch !== 0) {
|
|
following = state.input.charCodeAt(state.position + 1);
|
|
_line = state.line; // Save the current line.
|
|
_pos = state.position;
|
|
if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
|
|
|
|
if (ch === 0x3F/* ? */) {
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
|
|
detected = true;
|
|
atExplicitKey = true;
|
|
allowCompact = true;
|
|
|
|
} else if (atExplicitKey) {
|
|
atExplicitKey = false;
|
|
allowCompact = true;
|
|
|
|
} else {
|
|
throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
|
|
}
|
|
|
|
state.position += 1;
|
|
ch = following;
|
|
} else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
|
|
|
|
if (state.line === _line) {
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (ch === 0x3A/* : */) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if (!is_WS_OR_EOL(ch)) {
|
|
throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
|
|
}
|
|
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
|
|
detected = true;
|
|
atExplicitKey = false;
|
|
allowCompact = false;
|
|
keyTag = state.tag;
|
|
keyNode = state.result;
|
|
|
|
} else if (detected) {
|
|
throwError(state, 'can not read an implicit mapping pair; a colon is missed');
|
|
|
|
} else {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
return true; // Keep the result of `composeNode`.
|
|
}
|
|
|
|
} else if (detected) {
|
|
throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
|
|
|
|
} else {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
return true; // Keep the result of `composeNode`.
|
|
}
|
|
|
|
} else {
|
|
break; // Reading is done. Go to the epilogue.
|
|
}
|
|
if (state.line === _line || state.lineIndent > nodeIndent) {
|
|
if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
|
|
if (atExplicitKey) {
|
|
keyNode = state.result;
|
|
} else {
|
|
valueNode = state.result;
|
|
}
|
|
}
|
|
|
|
if (!atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
|
|
keyTag = keyNode = valueNode = null;
|
|
}
|
|
|
|
skipSeparationSpace(state, true, -1);
|
|
ch = state.input.charCodeAt(state.position);
|
|
}
|
|
|
|
if (state.lineIndent > nodeIndent && (ch !== 0)) {
|
|
throwError(state, 'bad indentation of a mapping entry');
|
|
} else if (state.lineIndent < nodeIndent) {
|
|
break;
|
|
}
|
|
}
|
|
if (atExplicitKey) {
|
|
storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
|
|
}
|
|
if (detected) {
|
|
state.tag = _tag;
|
|
state.anchor = _anchor;
|
|
state.kind = 'mapping';
|
|
state.result = _result;
|
|
}
|
|
|
|
return detected;
|
|
}
|
|
|
|
function readTagProperty(state) {
|
|
var _position,
|
|
isVerbatim = false,
|
|
isNamed = false,
|
|
tagHandle,
|
|
tagName,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch !== 0x21/* ! */) return false;
|
|
|
|
if (state.tag !== null) {
|
|
throwError(state, 'duplication of a tag property');
|
|
}
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
if (ch === 0x3C/* < */) {
|
|
isVerbatim = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
} else if (ch === 0x21/* ! */) {
|
|
isNamed = true;
|
|
tagHandle = '!!';
|
|
ch = state.input.charCodeAt(++state.position);
|
|
|
|
} else {
|
|
tagHandle = '!';
|
|
}
|
|
|
|
_position = state.position;
|
|
|
|
if (isVerbatim) {
|
|
do { ch = state.input.charCodeAt(++state.position); }
|
|
while (ch !== 0 && ch !== 0x3E/* > */);
|
|
|
|
if (state.position < state.length) {
|
|
tagName = state.input.slice(_position, state.position);
|
|
ch = state.input.charCodeAt(++state.position);
|
|
} else {
|
|
throwError(state, 'unexpected end of the stream within a verbatim tag');
|
|
}
|
|
} else {
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
|
|
if (ch === 0x21/* ! */) {
|
|
if (!isNamed) {
|
|
tagHandle = state.input.slice(_position - 1, state.position + 1);
|
|
|
|
if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
|
|
throwError(state, 'named tag handle cannot contain such characters');
|
|
}
|
|
|
|
isNamed = true;
|
|
_position = state.position + 1;
|
|
} else {
|
|
throwError(state, 'tag suffix cannot contain exclamation marks');
|
|
}
|
|
}
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
tagName = state.input.slice(_position, state.position);
|
|
|
|
if (PATTERN_FLOW_INDICATORS.test(tagName)) {
|
|
throwError(state, 'tag suffix cannot contain flow indicator characters');
|
|
}
|
|
}
|
|
|
|
if (tagName && !PATTERN_TAG_URI.test(tagName)) {
|
|
throwError(state, 'tag name cannot contain such characters: ' + tagName);
|
|
}
|
|
|
|
if (isVerbatim) {
|
|
state.tag = tagName;
|
|
|
|
} else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
|
|
state.tag = state.tagMap[tagHandle] + tagName;
|
|
|
|
} else if (tagHandle === '!') {
|
|
state.tag = '!' + tagName;
|
|
|
|
} else if (tagHandle === '!!') {
|
|
state.tag = 'tag:yaml.org,2002:' + tagName;
|
|
|
|
} else {
|
|
throwError(state, 'undeclared tag handle "' + tagHandle + '"');
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function readAnchorProperty(state) {
|
|
var _position,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch !== 0x26/* & */) return false;
|
|
|
|
if (state.anchor !== null) {
|
|
throwError(state, 'duplication of an anchor property');
|
|
}
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (state.position === _position) {
|
|
throwError(state, 'name of an anchor node must contain at least one character');
|
|
}
|
|
|
|
state.anchor = state.input.slice(_position, state.position);
|
|
return true;
|
|
}
|
|
|
|
function readAlias(state) {
|
|
var _position, alias,
|
|
ch;
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (ch !== 0x2A/* * */) return false;
|
|
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (state.position === _position) {
|
|
throwError(state, 'name of an alias node must contain at least one character');
|
|
}
|
|
|
|
alias = state.input.slice(_position, state.position);
|
|
|
|
if (!state.anchorMap.hasOwnProperty(alias)) {
|
|
throwError(state, 'unidentified alias "' + alias + '"');
|
|
}
|
|
|
|
state.result = state.anchorMap[alias];
|
|
skipSeparationSpace(state, true, -1);
|
|
return true;
|
|
}
|
|
|
|
function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
|
|
var allowBlockStyles,
|
|
allowBlockScalars,
|
|
allowBlockCollections,
|
|
indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
|
|
atNewLine = false,
|
|
hasContent = false,
|
|
typeIndex,
|
|
typeQuantity,
|
|
type,
|
|
flowIndent,
|
|
blockIndent;
|
|
|
|
if (state.listener !== null) {
|
|
state.listener('open', state);
|
|
}
|
|
|
|
state.tag = null;
|
|
state.anchor = null;
|
|
state.kind = null;
|
|
state.result = null;
|
|
|
|
allowBlockStyles = allowBlockScalars = allowBlockCollections =
|
|
CONTEXT_BLOCK_OUT === nodeContext ||
|
|
CONTEXT_BLOCK_IN === nodeContext;
|
|
|
|
if (allowToSeek) {
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
atNewLine = true;
|
|
|
|
if (state.lineIndent > parentIndent) {
|
|
indentStatus = 1;
|
|
} else if (state.lineIndent === parentIndent) {
|
|
indentStatus = 0;
|
|
} else if (state.lineIndent < parentIndent) {
|
|
indentStatus = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (indentStatus === 1) {
|
|
while (readTagProperty(state) || readAnchorProperty(state)) {
|
|
if (skipSeparationSpace(state, true, -1)) {
|
|
atNewLine = true;
|
|
allowBlockCollections = allowBlockStyles;
|
|
|
|
if (state.lineIndent > parentIndent) {
|
|
indentStatus = 1;
|
|
} else if (state.lineIndent === parentIndent) {
|
|
indentStatus = 0;
|
|
} else if (state.lineIndent < parentIndent) {
|
|
indentStatus = -1;
|
|
}
|
|
} else {
|
|
allowBlockCollections = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (allowBlockCollections) {
|
|
allowBlockCollections = atNewLine || allowCompact;
|
|
}
|
|
|
|
if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
|
|
if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
|
|
flowIndent = parentIndent;
|
|
} else {
|
|
flowIndent = parentIndent + 1;
|
|
}
|
|
|
|
blockIndent = state.position - state.lineStart;
|
|
|
|
if (indentStatus === 1) {
|
|
if (allowBlockCollections &&
|
|
(readBlockSequence(state, blockIndent) ||
|
|
readBlockMapping(state, blockIndent, flowIndent)) ||
|
|
readFlowCollection(state, flowIndent)) {
|
|
hasContent = true;
|
|
} else {
|
|
if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
|
|
readSingleQuotedScalar(state, flowIndent) ||
|
|
readDoubleQuotedScalar(state, flowIndent)) {
|
|
hasContent = true;
|
|
|
|
} else if (readAlias(state)) {
|
|
hasContent = true;
|
|
|
|
if (state.tag !== null || state.anchor !== null) {
|
|
throwError(state, 'alias node should not have any properties');
|
|
}
|
|
|
|
} else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
|
|
hasContent = true;
|
|
|
|
if (state.tag === null) {
|
|
state.tag = '?';
|
|
}
|
|
}
|
|
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
}
|
|
} else if (indentStatus === 0) {
|
|
hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
|
|
}
|
|
}
|
|
|
|
if (state.tag !== null && state.tag !== '!') {
|
|
if (state.tag === '?') {
|
|
for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
|
|
type = state.implicitTypes[typeIndex];
|
|
|
|
if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
|
|
state.result = type.construct(state.result);
|
|
state.tag = type.tag;
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
|
|
type = state.typeMap[state.kind || 'fallback'][state.tag];
|
|
|
|
if (state.result !== null && type.kind !== state.kind) {
|
|
throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
|
|
}
|
|
|
|
if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched
|
|
throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
|
|
} else {
|
|
state.result = type.construct(state.result);
|
|
if (state.anchor !== null) {
|
|
state.anchorMap[state.anchor] = state.result;
|
|
}
|
|
}
|
|
} else {
|
|
throwError(state, 'unknown tag !<' + state.tag + '>');
|
|
}
|
|
}
|
|
|
|
if (state.listener !== null) {
|
|
state.listener('close', state);
|
|
}
|
|
return state.tag !== null || state.anchor !== null || hasContent;
|
|
}
|
|
|
|
function readDocument(state) {
|
|
var documentStart = state.position,
|
|
_position,
|
|
directiveName,
|
|
directiveArgs,
|
|
hasDirectives = false,
|
|
ch;
|
|
|
|
state.version = null;
|
|
state.checkLineBreaks = state.legacy;
|
|
state.tagMap = {};
|
|
state.anchorMap = {};
|
|
|
|
while ((ch = state.input.charCodeAt(state.position)) !== 0) {
|
|
skipSeparationSpace(state, true, -1);
|
|
|
|
ch = state.input.charCodeAt(state.position);
|
|
|
|
if (state.lineIndent > 0 || ch !== 0x25/* % */) {
|
|
break;
|
|
}
|
|
|
|
hasDirectives = true;
|
|
ch = state.input.charCodeAt(++state.position);
|
|
_position = state.position;
|
|
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
directiveName = state.input.slice(_position, state.position);
|
|
directiveArgs = [];
|
|
|
|
if (directiveName.length < 1) {
|
|
throwError(state, 'directive name must not be less than one character in length');
|
|
}
|
|
|
|
while (ch !== 0) {
|
|
while (is_WHITE_SPACE(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
if (ch === 0x23/* # */) {
|
|
do { ch = state.input.charCodeAt(++state.position); }
|
|
while (ch !== 0 && !is_EOL(ch));
|
|
break;
|
|
}
|
|
|
|
if (is_EOL(ch)) break;
|
|
|
|
_position = state.position;
|
|
|
|
while (ch !== 0 && !is_WS_OR_EOL(ch)) {
|
|
ch = state.input.charCodeAt(++state.position);
|
|
}
|
|
|
|
directiveArgs.push(state.input.slice(_position, state.position));
|
|
}
|
|
|
|
if (ch !== 0) readLineBreak(state);
|
|
|
|
if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
|
|
directiveHandlers[directiveName](state, directiveName, directiveArgs);
|
|
} else {
|
|
throwWarning(state, 'unknown document directive "' + directiveName + '"');
|
|
}
|
|
}
|
|
|
|
skipSeparationSpace(state, true, -1);
|
|
|
|
if (state.lineIndent === 0 &&
|
|
state.input.charCodeAt(state.position) === 0x2D/* - */ &&
|
|
state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
|
|
state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
|
|
state.position += 3;
|
|
skipSeparationSpace(state, true, -1);
|
|
|
|
} else if (hasDirectives) {
|
|
throwError(state, 'directives end mark is expected');
|
|
}
|
|
|
|
composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
|
|
skipSeparationSpace(state, true, -1);
|
|
|
|
if (state.checkLineBreaks &&
|
|
PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
|
|
throwWarning(state, 'non-ASCII line breaks are interpreted as content');
|
|
}
|
|
|
|
state.documents.push(state.result);
|
|
|
|
if (state.position === state.lineStart && testDocumentSeparator(state)) {
|
|
|
|
if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
|
|
state.position += 3;
|
|
skipSeparationSpace(state, true, -1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (state.position < (state.length - 1)) {
|
|
throwError(state, 'end of the stream or a document separator is expected');
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
function loadDocuments(input, options) {
|
|
input = String(input);
|
|
options = options || {};
|
|
|
|
if (input.length !== 0) {
|
|
if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
|
|
input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
|
|
input += '\n';
|
|
}
|
|
if (input.charCodeAt(0) === 0xFEFF) {
|
|
input = input.slice(1);
|
|
}
|
|
}
|
|
|
|
var state = new State(input, options);
|
|
state.input += '\0';
|
|
|
|
while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
|
|
state.lineIndent += 1;
|
|
state.position += 1;
|
|
}
|
|
|
|
while (state.position < (state.length - 1)) {
|
|
readDocument(state);
|
|
}
|
|
|
|
return state.documents;
|
|
}
|
|
|
|
|
|
function loadAll(input, iterator, options) {
|
|
var documents = loadDocuments(input, options), index, length;
|
|
|
|
if (typeof iterator !== 'function') {
|
|
return documents;
|
|
}
|
|
|
|
for (index = 0, length = documents.length; index < length; index += 1) {
|
|
iterator(documents[index]);
|
|
}
|
|
}
|
|
|
|
|
|
function load(input, options) {
|
|
var documents = loadDocuments(input, options);
|
|
|
|
if (documents.length === 0) {
|
|
return undefined;
|
|
} else if (documents.length === 1) {
|
|
return documents[0];
|
|
}
|
|
throw new YAMLException('expected a single document in the stream, but found more');
|
|
}
|
|
|
|
|
|
function safeLoadAll(input, output, options) {
|
|
if (typeof output === 'function') {
|
|
loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
|
|
} else {
|
|
return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
|
|
}
|
|
}
|
|
|
|
|
|
function safeLoad(input, options) {
|
|
return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
|
|
}
|
|
|
|
|
|
module.exports.loadAll = loadAll;
|
|
module.exports.load = load;
|
|
module.exports.safeLoadAll = safeLoadAll;
|
|
module.exports.safeLoad = safeLoad;
|
|
|
|
},{"./common":5,"./exception":7,"./mark":9,"./schema/default_full":12,"./schema/default_safe":13}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var common = require('./common');
|
|
|
|
|
|
function Mark(name, buffer, position, line, column) {
|
|
this.name = name;
|
|
this.buffer = buffer;
|
|
this.position = position;
|
|
this.line = line;
|
|
this.column = column;
|
|
}
|
|
|
|
|
|
Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
|
|
var head, start, tail, end, snippet;
|
|
|
|
if (!this.buffer) return null;
|
|
|
|
indent = indent || 4;
|
|
maxLength = maxLength || 75;
|
|
|
|
head = '';
|
|
start = this.position;
|
|
|
|
while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
|
|
start -= 1;
|
|
if (this.position - start > (maxLength / 2 - 1)) {
|
|
head = ' ... ';
|
|
start += 5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
tail = '';
|
|
end = this.position;
|
|
|
|
while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
|
|
end += 1;
|
|
if (end - this.position > (maxLength / 2 - 1)) {
|
|
tail = ' ... ';
|
|
end -= 5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
snippet = this.buffer.slice(start, end);
|
|
|
|
return common.repeat(' ', indent) + head + snippet + tail + '\n' +
|
|
common.repeat(' ', indent + this.position - start + head.length) + '^';
|
|
};
|
|
|
|
|
|
Mark.prototype.toString = function toString(compact) {
|
|
var snippet, where = '';
|
|
|
|
if (this.name) {
|
|
where += 'in "' + this.name + '" ';
|
|
}
|
|
|
|
where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
|
|
|
|
if (!compact) {
|
|
snippet = this.getSnippet();
|
|
|
|
if (snippet) {
|
|
where += ':\n' + snippet;
|
|
}
|
|
}
|
|
|
|
return where;
|
|
};
|
|
|
|
|
|
module.exports = Mark;
|
|
|
|
},{"./common":5}],10:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var common = require('./common');
|
|
var YAMLException = require('./exception');
|
|
var Type = require('./type');
|
|
|
|
|
|
function compileList(schema, name, result) {
|
|
var exclude = [];
|
|
|
|
schema.include.forEach(function (includedSchema) {
|
|
result = compileList(includedSchema, name, result);
|
|
});
|
|
|
|
schema[name].forEach(function (currentType) {
|
|
result.forEach(function (previousType, previousIndex) {
|
|
if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
|
|
exclude.push(previousIndex);
|
|
}
|
|
});
|
|
|
|
result.push(currentType);
|
|
});
|
|
|
|
return result.filter(function (type, index) {
|
|
return exclude.indexOf(index) === -1;
|
|
});
|
|
}
|
|
|
|
|
|
function compileMap(/* lists... */) {
|
|
var result = {
|
|
scalar: {},
|
|
sequence: {},
|
|
mapping: {},
|
|
fallback: {}
|
|
}, index, length;
|
|
|
|
function collectType(type) {
|
|
result[type.kind][type.tag] = result['fallback'][type.tag] = type;
|
|
}
|
|
|
|
for (index = 0, length = arguments.length; index < length; index += 1) {
|
|
arguments[index].forEach(collectType);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
function Schema(definition) {
|
|
this.include = definition.include || [];
|
|
this.implicit = definition.implicit || [];
|
|
this.explicit = definition.explicit || [];
|
|
|
|
this.implicit.forEach(function (type) {
|
|
if (type.loadKind && type.loadKind !== 'scalar') {
|
|
throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
|
|
}
|
|
});
|
|
|
|
this.compiledImplicit = compileList(this, 'implicit', []);
|
|
this.compiledExplicit = compileList(this, 'explicit', []);
|
|
this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
|
|
}
|
|
|
|
|
|
Schema.DEFAULT = null;
|
|
|
|
|
|
Schema.create = function createSchema() {
|
|
var schemas, types;
|
|
|
|
switch (arguments.length) {
|
|
case 1:
|
|
schemas = Schema.DEFAULT;
|
|
types = arguments[0];
|
|
break;
|
|
|
|
case 2:
|
|
schemas = arguments[0];
|
|
types = arguments[1];
|
|
break;
|
|
|
|
default:
|
|
throw new YAMLException('Wrong number of arguments for Schema.create function');
|
|
}
|
|
|
|
schemas = common.toArray(schemas);
|
|
types = common.toArray(types);
|
|
|
|
if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
|
|
throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
|
|
}
|
|
|
|
if (!types.every(function (type) { return type instanceof Type; })) {
|
|
throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
|
|
}
|
|
|
|
return new Schema({
|
|
include: schemas,
|
|
explicit: types
|
|
});
|
|
};
|
|
|
|
|
|
module.exports = Schema;
|
|
|
|
},{"./common":5,"./exception":7,"./type":16}],11:[function(require,module,exports){
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
var Schema = require('../schema');
|
|
|
|
|
|
module.exports = new Schema({
|
|
include: [
|
|
require('./json')
|
|
]
|
|
});
|
|
|
|
},{"../schema":10,"./json":15}],12:[function(require,module,exports){
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
var Schema = require('../schema');
|
|
|
|
|
|
module.exports = Schema.DEFAULT = new Schema({
|
|
include: [
|
|
require('./default_safe')
|
|
],
|
|
explicit: [
|
|
require('../type/js/undefined'),
|
|
require('../type/js/regexp'),
|
|
require('../type/js/function')
|
|
]
|
|
});
|
|
|
|
},{"../schema":10,"../type/js/function":21,"../type/js/regexp":22,"../type/js/undefined":23,"./default_safe":13}],13:[function(require,module,exports){
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
var Schema = require('../schema');
|
|
|
|
|
|
module.exports = new Schema({
|
|
include: [
|
|
require('./core')
|
|
],
|
|
implicit: [
|
|
require('../type/timestamp'),
|
|
require('../type/merge')
|
|
],
|
|
explicit: [
|
|
require('../type/binary'),
|
|
require('../type/omap'),
|
|
require('../type/pairs'),
|
|
require('../type/set')
|
|
]
|
|
});
|
|
|
|
},{"../schema":10,"../type/binary":17,"../type/merge":25,"../type/omap":27,"../type/pairs":28,"../type/set":30,"../type/timestamp":32,"./core":11}],14:[function(require,module,exports){
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
var Schema = require('../schema');
|
|
|
|
|
|
module.exports = new Schema({
|
|
explicit: [
|
|
require('../type/str'),
|
|
require('../type/seq'),
|
|
require('../type/map')
|
|
]
|
|
});
|
|
|
|
},{"../schema":10,"../type/map":24,"../type/seq":29,"../type/str":31}],15:[function(require,module,exports){
|
|
|
|
|
|
'use strict';
|
|
|
|
|
|
var Schema = require('../schema');
|
|
|
|
|
|
module.exports = new Schema({
|
|
include: [
|
|
require('./failsafe')
|
|
],
|
|
implicit: [
|
|
require('../type/null'),
|
|
require('../type/bool'),
|
|
require('../type/int'),
|
|
require('../type/float')
|
|
]
|
|
});
|
|
|
|
},{"../schema":10,"../type/bool":18,"../type/float":19,"../type/int":20,"../type/null":26,"./failsafe":14}],16:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var YAMLException = require('./exception');
|
|
|
|
var TYPE_CONSTRUCTOR_OPTIONS = [
|
|
'kind',
|
|
'resolve',
|
|
'construct',
|
|
'instanceOf',
|
|
'predicate',
|
|
'represent',
|
|
'defaultStyle',
|
|
'styleAliases'
|
|
];
|
|
|
|
var YAML_NODE_KINDS = [
|
|
'scalar',
|
|
'sequence',
|
|
'mapping'
|
|
];
|
|
|
|
function compileStyleAliases(map) {
|
|
var result = {};
|
|
|
|
if (map !== null) {
|
|
Object.keys(map).forEach(function (style) {
|
|
map[style].forEach(function (alias) {
|
|
result[String(alias)] = style;
|
|
});
|
|
});
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function Type(tag, options) {
|
|
options = options || {};
|
|
|
|
Object.keys(options).forEach(function (name) {
|
|
if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
|
|
throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
|
|
}
|
|
});
|
|
this.tag = tag;
|
|
this.kind = options['kind'] || null;
|
|
this.resolve = options['resolve'] || function () { return true; };
|
|
this.construct = options['construct'] || function (data) { return data; };
|
|
this.instanceOf = options['instanceOf'] || null;
|
|
this.predicate = options['predicate'] || null;
|
|
this.represent = options['represent'] || null;
|
|
this.defaultStyle = options['defaultStyle'] || null;
|
|
this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
|
|
|
|
if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
|
|
throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
|
|
}
|
|
}
|
|
|
|
module.exports = Type;
|
|
|
|
},{"./exception":7}],17:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var NodeBuffer;
|
|
|
|
try {
|
|
var _require = require;
|
|
NodeBuffer = _require('buffer').Buffer;
|
|
} catch (__) {}
|
|
|
|
var Type = require('../type');
|
|
var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
|
|
|
|
|
|
function resolveYamlBinary(data) {
|
|
if (data === null) return false;
|
|
|
|
var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
|
|
for (idx = 0; idx < max; idx++) {
|
|
code = map.indexOf(data.charAt(idx));
|
|
if (code > 64) continue;
|
|
if (code < 0) return false;
|
|
|
|
bitlen += 6;
|
|
}
|
|
return (bitlen % 8) === 0;
|
|
}
|
|
|
|
function constructYamlBinary(data) {
|
|
var idx, tailbits,
|
|
input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
|
|
max = input.length,
|
|
map = BASE64_MAP,
|
|
bits = 0,
|
|
result = [];
|
|
|
|
for (idx = 0; idx < max; idx++) {
|
|
if ((idx % 4 === 0) && idx) {
|
|
result.push((bits >> 16) & 0xFF);
|
|
result.push((bits >> 8) & 0xFF);
|
|
result.push(bits & 0xFF);
|
|
}
|
|
|
|
bits = (bits << 6) | map.indexOf(input.charAt(idx));
|
|
}
|
|
|
|
tailbits = (max % 4) * 6;
|
|
|
|
if (tailbits === 0) {
|
|
result.push((bits >> 16) & 0xFF);
|
|
result.push((bits >> 8) & 0xFF);
|
|
result.push(bits & 0xFF);
|
|
} else if (tailbits === 18) {
|
|
result.push((bits >> 10) & 0xFF);
|
|
result.push((bits >> 2) & 0xFF);
|
|
} else if (tailbits === 12) {
|
|
result.push((bits >> 4) & 0xFF);
|
|
}
|
|
if (NodeBuffer) {
|
|
return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function representYamlBinary(object /*, style*/) {
|
|
var result = '', bits = 0, idx, tail,
|
|
max = object.length,
|
|
map = BASE64_MAP;
|
|
|
|
for (idx = 0; idx < max; idx++) {
|
|
if ((idx % 3 === 0) && idx) {
|
|
result += map[(bits >> 18) & 0x3F];
|
|
result += map[(bits >> 12) & 0x3F];
|
|
result += map[(bits >> 6) & 0x3F];
|
|
result += map[bits & 0x3F];
|
|
}
|
|
|
|
bits = (bits << 8) + object[idx];
|
|
}
|
|
|
|
tail = max % 3;
|
|
|
|
if (tail === 0) {
|
|
result += map[(bits >> 18) & 0x3F];
|
|
result += map[(bits >> 12) & 0x3F];
|
|
result += map[(bits >> 6) & 0x3F];
|
|
result += map[bits & 0x3F];
|
|
} else if (tail === 2) {
|
|
result += map[(bits >> 10) & 0x3F];
|
|
result += map[(bits >> 4) & 0x3F];
|
|
result += map[(bits << 2) & 0x3F];
|
|
result += map[64];
|
|
} else if (tail === 1) {
|
|
result += map[(bits >> 2) & 0x3F];
|
|
result += map[(bits << 4) & 0x3F];
|
|
result += map[64];
|
|
result += map[64];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function isBinary(object) {
|
|
return NodeBuffer && NodeBuffer.isBuffer(object);
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:binary', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlBinary,
|
|
construct: constructYamlBinary,
|
|
predicate: isBinary,
|
|
represent: representYamlBinary
|
|
});
|
|
|
|
},{"../type":16}],18:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
function resolveYamlBoolean(data) {
|
|
if (data === null) return false;
|
|
|
|
var max = data.length;
|
|
|
|
return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
|
|
(max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
|
|
}
|
|
|
|
function constructYamlBoolean(data) {
|
|
return data === 'true' ||
|
|
data === 'True' ||
|
|
data === 'TRUE';
|
|
}
|
|
|
|
function isBoolean(object) {
|
|
return Object.prototype.toString.call(object) === '[object Boolean]';
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:bool', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlBoolean,
|
|
construct: constructYamlBoolean,
|
|
predicate: isBoolean,
|
|
represent: {
|
|
lowercase: function (object) { return object ? 'true' : 'false'; },
|
|
uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
|
|
camelcase: function (object) { return object ? 'True' : 'False'; }
|
|
},
|
|
defaultStyle: 'lowercase'
|
|
});
|
|
|
|
},{"../type":16}],19:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var common = require('../common');
|
|
var Type = require('../type');
|
|
|
|
var YAML_FLOAT_PATTERN = new RegExp(
|
|
'^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
|
|
'|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
|
|
'|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
|
|
'|[-+]?\\.(?:inf|Inf|INF)' +
|
|
'|\\.(?:nan|NaN|NAN))$');
|
|
|
|
function resolveYamlFloat(data) {
|
|
if (data === null) return false;
|
|
|
|
if (!YAML_FLOAT_PATTERN.test(data) ||
|
|
data[data.length - 1] === '_') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function constructYamlFloat(data) {
|
|
var value, sign, base, digits;
|
|
|
|
value = data.replace(/_/g, '').toLowerCase();
|
|
sign = value[0] === '-' ? -1 : 1;
|
|
digits = [];
|
|
|
|
if ('+-'.indexOf(value[0]) >= 0) {
|
|
value = value.slice(1);
|
|
}
|
|
|
|
if (value === '.inf') {
|
|
return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
|
|
|
|
} else if (value === '.nan') {
|
|
return NaN;
|
|
|
|
} else if (value.indexOf(':') >= 0) {
|
|
value.split(':').forEach(function (v) {
|
|
digits.unshift(parseFloat(v, 10));
|
|
});
|
|
|
|
value = 0.0;
|
|
base = 1;
|
|
|
|
digits.forEach(function (d) {
|
|
value += d * base;
|
|
base *= 60;
|
|
});
|
|
|
|
return sign * value;
|
|
|
|
}
|
|
return sign * parseFloat(value, 10);
|
|
}
|
|
|
|
|
|
var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
|
|
|
|
function representYamlFloat(object, style) {
|
|
var res;
|
|
|
|
if (isNaN(object)) {
|
|
switch (style) {
|
|
case 'lowercase': return '.nan';
|
|
case 'uppercase': return '.NAN';
|
|
case 'camelcase': return '.NaN';
|
|
}
|
|
} else if (Number.POSITIVE_INFINITY === object) {
|
|
switch (style) {
|
|
case 'lowercase': return '.inf';
|
|
case 'uppercase': return '.INF';
|
|
case 'camelcase': return '.Inf';
|
|
}
|
|
} else if (Number.NEGATIVE_INFINITY === object) {
|
|
switch (style) {
|
|
case 'lowercase': return '-.inf';
|
|
case 'uppercase': return '-.INF';
|
|
case 'camelcase': return '-.Inf';
|
|
}
|
|
} else if (common.isNegativeZero(object)) {
|
|
return '-0.0';
|
|
}
|
|
|
|
res = object.toString(10);
|
|
|
|
return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
|
|
}
|
|
|
|
function isFloat(object) {
|
|
return (Object.prototype.toString.call(object) === '[object Number]') &&
|
|
(object % 1 !== 0 || common.isNegativeZero(object));
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:float', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlFloat,
|
|
construct: constructYamlFloat,
|
|
predicate: isFloat,
|
|
represent: representYamlFloat,
|
|
defaultStyle: 'lowercase'
|
|
});
|
|
|
|
},{"../common":5,"../type":16}],20:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var common = require('../common');
|
|
var Type = require('../type');
|
|
|
|
function isHexCode(c) {
|
|
return ((c/* 0 */ >= 0x30) && (c <= 0x39/* 9 */)) ||
|
|
((c/* A */ >= 0x41) && (c <= 0x46/* F */)) ||
|
|
((c/* a */ >= 0x61) && (c <= 0x66/* f */));
|
|
}
|
|
|
|
function isOctCode(c) {
|
|
return ((c/* 0 */ >= 0x30) && (c <= 0x37/* 7 */));
|
|
}
|
|
|
|
function isDecCode(c) {
|
|
return ((c/* 0 */ >= 0x30) && (c <= 0x39/* 9 */));
|
|
}
|
|
|
|
function resolveYamlInteger(data) {
|
|
if (data === null) return false;
|
|
|
|
var max = data.length,
|
|
index = 0,
|
|
hasDigits = false,
|
|
ch;
|
|
|
|
if (!max) return false;
|
|
|
|
ch = data[index];
|
|
if (ch === '-' || ch === '+') {
|
|
ch = data[++index];
|
|
}
|
|
|
|
if (ch === '0') {
|
|
if (index + 1 === max) return true;
|
|
ch = data[++index];
|
|
|
|
if (ch === 'b') {
|
|
index++;
|
|
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === '_') continue;
|
|
if (ch !== '0' && ch !== '1') return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== '_';
|
|
}
|
|
|
|
|
|
if (ch === 'x') {
|
|
index++;
|
|
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === '_') continue;
|
|
if (!isHexCode(data.charCodeAt(index))) return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== '_';
|
|
}
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === '_') continue;
|
|
if (!isOctCode(data.charCodeAt(index))) return false;
|
|
hasDigits = true;
|
|
}
|
|
return hasDigits && ch !== '_';
|
|
}
|
|
if (ch === '_') return false;
|
|
|
|
for (; index < max; index++) {
|
|
ch = data[index];
|
|
if (ch === '_') continue;
|
|
if (ch === ':') break;
|
|
if (!isDecCode(data.charCodeAt(index))) {
|
|
return false;
|
|
}
|
|
hasDigits = true;
|
|
}
|
|
if (!hasDigits || ch === '_') return false;
|
|
if (ch !== ':') return true;
|
|
return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
|
|
}
|
|
|
|
function constructYamlInteger(data) {
|
|
var value = data, sign = 1, ch, base, digits = [];
|
|
|
|
if (value.indexOf('_') !== -1) {
|
|
value = value.replace(/_/g, '');
|
|
}
|
|
|
|
ch = value[0];
|
|
|
|
if (ch === '-' || ch === '+') {
|
|
if (ch === '-') sign = -1;
|
|
value = value.slice(1);
|
|
ch = value[0];
|
|
}
|
|
|
|
if (value === '0') return 0;
|
|
|
|
if (ch === '0') {
|
|
if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
|
|
if (value[1] === 'x') return sign * parseInt(value, 16);
|
|
return sign * parseInt(value, 8);
|
|
}
|
|
|
|
if (value.indexOf(':') !== -1) {
|
|
value.split(':').forEach(function (v) {
|
|
digits.unshift(parseInt(v, 10));
|
|
});
|
|
|
|
value = 0;
|
|
base = 1;
|
|
|
|
digits.forEach(function (d) {
|
|
value += (d * base);
|
|
base *= 60;
|
|
});
|
|
|
|
return sign * value;
|
|
|
|
}
|
|
|
|
return sign * parseInt(value, 10);
|
|
}
|
|
|
|
function isInteger(object) {
|
|
return (Object.prototype.toString.call(object)) === '[object Number]' &&
|
|
(object % 1 === 0 && !common.isNegativeZero(object));
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:int', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlInteger,
|
|
construct: constructYamlInteger,
|
|
predicate: isInteger,
|
|
represent: {
|
|
binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
|
|
octal: function (obj) { return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1); },
|
|
decimal: function (obj) { return obj.toString(10); },
|
|
hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); }
|
|
},
|
|
defaultStyle: 'decimal',
|
|
styleAliases: {
|
|
binary: [ 2, 'bin' ],
|
|
octal: [ 8, 'oct' ],
|
|
decimal: [ 10, 'dec' ],
|
|
hexadecimal: [ 16, 'hex' ]
|
|
}
|
|
});
|
|
|
|
},{"../common":5,"../type":16}],21:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var esprima;
|
|
try {
|
|
var _require = require;
|
|
esprima = _require('esprima');
|
|
} catch (_) {
|
|
if (typeof window !== 'undefined') esprima = window.esprima;
|
|
}
|
|
|
|
var Type = require('../../type');
|
|
|
|
function resolveJavascriptFunction(data) {
|
|
if (data === null) return false;
|
|
|
|
try {
|
|
var source = '(' + data + ')',
|
|
ast = esprima.parse(source, { range: true });
|
|
|
|
if (ast.type !== 'Program' ||
|
|
ast.body.length !== 1 ||
|
|
ast.body[0].type !== 'ExpressionStatement' ||
|
|
(ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
|
|
ast.body[0].expression.type !== 'FunctionExpression')) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function constructJavascriptFunction(data) {
|
|
|
|
var source = '(' + data + ')',
|
|
ast = esprima.parse(source, { range: true }),
|
|
params = [],
|
|
body;
|
|
|
|
if (ast.type !== 'Program' ||
|
|
ast.body.length !== 1 ||
|
|
ast.body[0].type !== 'ExpressionStatement' ||
|
|
(ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
|
|
ast.body[0].expression.type !== 'FunctionExpression')) {
|
|
throw new Error('Failed to resolve function');
|
|
}
|
|
|
|
ast.body[0].expression.params.forEach(function (param) {
|
|
params.push(param.name);
|
|
});
|
|
|
|
body = ast.body[0].expression.body.range;
|
|
if (ast.body[0].expression.body.type === 'BlockStatement') {
|
|
return new Function(params, source.slice(body[0] + 1, body[1] - 1));
|
|
}
|
|
return new Function(params, 'return ' + source.slice(body[0], body[1]));
|
|
}
|
|
|
|
function representJavascriptFunction(object /*, style*/) {
|
|
return object.toString();
|
|
}
|
|
|
|
function isFunction(object) {
|
|
return Object.prototype.toString.call(object) === '[object Function]';
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:js/function', {
|
|
kind: 'scalar',
|
|
resolve: resolveJavascriptFunction,
|
|
construct: constructJavascriptFunction,
|
|
predicate: isFunction,
|
|
represent: representJavascriptFunction
|
|
});
|
|
|
|
},{"../../type":16}],22:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../../type');
|
|
|
|
function resolveJavascriptRegExp(data) {
|
|
if (data === null) return false;
|
|
if (data.length === 0) return false;
|
|
|
|
var regexp = data,
|
|
tail = /\/([gim]*)$/.exec(data),
|
|
modifiers = '';
|
|
if (regexp[0] === '/') {
|
|
if (tail) modifiers = tail[1];
|
|
|
|
if (modifiers.length > 3) return false;
|
|
if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function constructJavascriptRegExp(data) {
|
|
var regexp = data,
|
|
tail = /\/([gim]*)$/.exec(data),
|
|
modifiers = '';
|
|
if (regexp[0] === '/') {
|
|
if (tail) modifiers = tail[1];
|
|
regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
|
|
}
|
|
|
|
return new RegExp(regexp, modifiers);
|
|
}
|
|
|
|
function representJavascriptRegExp(object /*, style*/) {
|
|
var result = '/' + object.source + '/';
|
|
|
|
if (object.global) result += 'g';
|
|
if (object.multiline) result += 'm';
|
|
if (object.ignoreCase) result += 'i';
|
|
|
|
return result;
|
|
}
|
|
|
|
function isRegExp(object) {
|
|
return Object.prototype.toString.call(object) === '[object RegExp]';
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:js/regexp', {
|
|
kind: 'scalar',
|
|
resolve: resolveJavascriptRegExp,
|
|
construct: constructJavascriptRegExp,
|
|
predicate: isRegExp,
|
|
represent: representJavascriptRegExp
|
|
});
|
|
|
|
},{"../../type":16}],23:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../../type');
|
|
|
|
function resolveJavascriptUndefined() {
|
|
return true;
|
|
}
|
|
|
|
function constructJavascriptUndefined() {
|
|
return undefined;
|
|
}
|
|
|
|
function representJavascriptUndefined() {
|
|
return '';
|
|
}
|
|
|
|
function isUndefined(object) {
|
|
return typeof object === 'undefined';
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:js/undefined', {
|
|
kind: 'scalar',
|
|
resolve: resolveJavascriptUndefined,
|
|
construct: constructJavascriptUndefined,
|
|
predicate: isUndefined,
|
|
represent: representJavascriptUndefined
|
|
});
|
|
|
|
},{"../../type":16}],24:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:map', {
|
|
kind: 'mapping',
|
|
construct: function (data) { return data !== null ? data : {}; }
|
|
});
|
|
|
|
},{"../type":16}],25:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
function resolveYamlMerge(data) {
|
|
return data === '<<' || data === null;
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:merge', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlMerge
|
|
});
|
|
|
|
},{"../type":16}],26:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
function resolveYamlNull(data) {
|
|
if (data === null) return true;
|
|
|
|
var max = data.length;
|
|
|
|
return (max === 1 && data === '~') ||
|
|
(max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
|
|
}
|
|
|
|
function constructYamlNull() {
|
|
return null;
|
|
}
|
|
|
|
function isNull(object) {
|
|
return object === null;
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:null', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlNull,
|
|
construct: constructYamlNull,
|
|
predicate: isNull,
|
|
represent: {
|
|
canonical: function () { return '~'; },
|
|
lowercase: function () { return 'null'; },
|
|
uppercase: function () { return 'NULL'; },
|
|
camelcase: function () { return 'Null'; }
|
|
},
|
|
defaultStyle: 'lowercase'
|
|
});
|
|
|
|
},{"../type":16}],27:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var _toString = Object.prototype.toString;
|
|
|
|
function resolveYamlOmap(data) {
|
|
if (data === null) return true;
|
|
|
|
var objectKeys = [], index, length, pair, pairKey, pairHasKey,
|
|
object = data;
|
|
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
pairHasKey = false;
|
|
|
|
if (_toString.call(pair) !== '[object Object]') return false;
|
|
|
|
for (pairKey in pair) {
|
|
if (_hasOwnProperty.call(pair, pairKey)) {
|
|
if (!pairHasKey) pairHasKey = true;
|
|
else return false;
|
|
}
|
|
}
|
|
|
|
if (!pairHasKey) return false;
|
|
|
|
if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
|
|
else return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function constructYamlOmap(data) {
|
|
return data !== null ? data : [];
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:omap', {
|
|
kind: 'sequence',
|
|
resolve: resolveYamlOmap,
|
|
construct: constructYamlOmap
|
|
});
|
|
|
|
},{"../type":16}],28:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
var _toString = Object.prototype.toString;
|
|
|
|
function resolveYamlPairs(data) {
|
|
if (data === null) return true;
|
|
|
|
var index, length, pair, keys, result,
|
|
object = data;
|
|
|
|
result = new Array(object.length);
|
|
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
|
|
if (_toString.call(pair) !== '[object Object]') return false;
|
|
|
|
keys = Object.keys(pair);
|
|
|
|
if (keys.length !== 1) return false;
|
|
|
|
result[index] = [ keys[0], pair[keys[0]] ];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function constructYamlPairs(data) {
|
|
if (data === null) return [];
|
|
|
|
var index, length, pair, keys, result,
|
|
object = data;
|
|
|
|
result = new Array(object.length);
|
|
|
|
for (index = 0, length = object.length; index < length; index += 1) {
|
|
pair = object[index];
|
|
|
|
keys = Object.keys(pair);
|
|
|
|
result[index] = [ keys[0], pair[keys[0]] ];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:pairs', {
|
|
kind: 'sequence',
|
|
resolve: resolveYamlPairs,
|
|
construct: constructYamlPairs
|
|
});
|
|
|
|
},{"../type":16}],29:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:seq', {
|
|
kind: 'sequence',
|
|
construct: function (data) { return data !== null ? data : []; }
|
|
});
|
|
|
|
},{"../type":16}],30:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
var _hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
function resolveYamlSet(data) {
|
|
if (data === null) return true;
|
|
|
|
var key, object = data;
|
|
|
|
for (key in object) {
|
|
if (_hasOwnProperty.call(object, key)) {
|
|
if (object[key] !== null) return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function constructYamlSet(data) {
|
|
return data !== null ? data : {};
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:set', {
|
|
kind: 'mapping',
|
|
resolve: resolveYamlSet,
|
|
construct: constructYamlSet
|
|
});
|
|
|
|
},{"../type":16}],31:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:str', {
|
|
kind: 'scalar',
|
|
construct: function (data) { return data !== null ? data : ''; }
|
|
});
|
|
|
|
},{"../type":16}],32:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var Type = require('../type');
|
|
|
|
var YAML_DATE_REGEXP = new RegExp(
|
|
'^([0-9][0-9][0-9][0-9])' + // [1] year
|
|
'-([0-9][0-9])' + // [2] month
|
|
'-([0-9][0-9])$'); // [3] day
|
|
|
|
var YAML_TIMESTAMP_REGEXP = new RegExp(
|
|
'^([0-9][0-9][0-9][0-9])' + // [1] year
|
|
'-([0-9][0-9]?)' + // [2] month
|
|
'-([0-9][0-9]?)' + // [3] day
|
|
'(?:[Tt]|[ \\t]+)' + // ...
|
|
'([0-9][0-9]?)' + // [4] hour
|
|
':([0-9][0-9])' + // [5] minute
|
|
':([0-9][0-9])' + // [6] second
|
|
'(?:\\.([0-9]*))?' + // [7] fraction
|
|
'(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
|
|
'(?::([0-9][0-9]))?))?$'); // [11] tz_minute
|
|
|
|
function resolveYamlTimestamp(data) {
|
|
if (data === null) return false;
|
|
if (YAML_DATE_REGEXP.exec(data) !== null) return true;
|
|
if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
|
|
return false;
|
|
}
|
|
|
|
function constructYamlTimestamp(data) {
|
|
var match, year, month, day, hour, minute, second, fraction = 0,
|
|
delta = null, tz_hour, tz_minute, date;
|
|
|
|
match = YAML_DATE_REGEXP.exec(data);
|
|
if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
|
|
|
|
if (match === null) throw new Error('Date resolve error');
|
|
|
|
year = +(match[1]);
|
|
month = +(match[2]) - 1; // JS month starts with 0
|
|
day = +(match[3]);
|
|
|
|
if (!match[4]) { // no hour
|
|
return new Date(Date.UTC(year, month, day));
|
|
}
|
|
|
|
hour = +(match[4]);
|
|
minute = +(match[5]);
|
|
second = +(match[6]);
|
|
|
|
if (match[7]) {
|
|
fraction = match[7].slice(0, 3);
|
|
while (fraction.length < 3) { // milli-seconds
|
|
fraction += '0';
|
|
}
|
|
fraction = +fraction;
|
|
}
|
|
|
|
if (match[9]) {
|
|
tz_hour = +(match[10]);
|
|
tz_minute = +(match[11] || 0);
|
|
delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
|
|
if (match[9] === '-') delta = -delta;
|
|
}
|
|
|
|
date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
|
|
|
|
if (delta) date.setTime(date.getTime() - delta);
|
|
|
|
return date;
|
|
}
|
|
|
|
function representYamlTimestamp(object /*, style*/) {
|
|
return object.toISOString();
|
|
}
|
|
|
|
module.exports = new Type('tag:yaml.org,2002:timestamp', {
|
|
kind: 'scalar',
|
|
resolve: resolveYamlTimestamp,
|
|
construct: constructYamlTimestamp,
|
|
instanceOf: Date,
|
|
represent: representYamlTimestamp
|
|
});
|
|
|
|
},{"../type":16}],33:[function(require,module,exports){
|
|
(function (global){
|
|
var LARGE_ARRAY_SIZE = 200;
|
|
var HASH_UNDEFINED = '__lodash_hash_undefined__';
|
|
var HOT_COUNT = 800,
|
|
HOT_SPAN = 16;
|
|
var MAX_SAFE_INTEGER = 9007199254740991;
|
|
var argsTag = '[object Arguments]',
|
|
arrayTag = '[object Array]',
|
|
asyncTag = '[object AsyncFunction]',
|
|
boolTag = '[object Boolean]',
|
|
dateTag = '[object Date]',
|
|
errorTag = '[object Error]',
|
|
funcTag = '[object Function]',
|
|
genTag = '[object GeneratorFunction]',
|
|
mapTag = '[object Map]',
|
|
numberTag = '[object Number]',
|
|
nullTag = '[object Null]',
|
|
objectTag = '[object Object]',
|
|
proxyTag = '[object Proxy]',
|
|
regexpTag = '[object RegExp]',
|
|
setTag = '[object Set]',
|
|
stringTag = '[object String]',
|
|
undefinedTag = '[object Undefined]',
|
|
weakMapTag = '[object WeakMap]';
|
|
|
|
var arrayBufferTag = '[object ArrayBuffer]',
|
|
dataViewTag = '[object DataView]',
|
|
float32Tag = '[object Float32Array]',
|
|
float64Tag = '[object Float64Array]',
|
|
int8Tag = '[object Int8Array]',
|
|
int16Tag = '[object Int16Array]',
|
|
int32Tag = '[object Int32Array]',
|
|
uint8Tag = '[object Uint8Array]',
|
|
uint8ClampedTag = '[object Uint8ClampedArray]',
|
|
uint16Tag = '[object Uint16Array]',
|
|
uint32Tag = '[object Uint32Array]';
|
|
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
|
|
var reIsHostCtor = /^\[object .+?Constructor\]$/;
|
|
var reIsUint = /^(?:0|[1-9]\d*)$/;
|
|
var typedArrayTags = {};
|
|
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
|
|
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
|
|
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
|
|
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
|
|
typedArrayTags[uint32Tag] = true;
|
|
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
|
|
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
|
|
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
|
|
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
|
|
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
|
|
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
|
|
typedArrayTags[setTag] = typedArrayTags[stringTag] =
|
|
typedArrayTags[weakMapTag] = false;
|
|
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
|
|
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
|
|
var root = freeGlobal || freeSelf || Function('return this')();
|
|
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
|
|
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
|
|
var moduleExports = freeModule && freeModule.exports === freeExports;
|
|
var freeProcess = moduleExports && freeGlobal.process;
|
|
var nodeUtil = (function() {
|
|
try {
|
|
return freeProcess && freeProcess.binding && freeProcess.binding('util');
|
|
} catch (e) {}
|
|
}());
|
|
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
|
|
function apply(func, thisArg, args) {
|
|
switch (args.length) {
|
|
case 0: return func.call(thisArg);
|
|
case 1: return func.call(thisArg, args[0]);
|
|
case 2: return func.call(thisArg, args[0], args[1]);
|
|
case 3: return func.call(thisArg, args[0], args[1], args[2]);
|
|
}
|
|
return func.apply(thisArg, args);
|
|
}
|
|
function baseTimes(n, iteratee) {
|
|
var index = -1,
|
|
result = Array(n);
|
|
|
|
while (++index < n) {
|
|
result[index] = iteratee(index);
|
|
}
|
|
return result;
|
|
}
|
|
function baseUnary(func) {
|
|
return function(value) {
|
|
return func(value);
|
|
};
|
|
}
|
|
function getValue(object, key) {
|
|
return object == null ? undefined : object[key];
|
|
}
|
|
function overArg(func, transform) {
|
|
return function(arg) {
|
|
return func(transform(arg));
|
|
};
|
|
}
|
|
function safeGet(object, key) {
|
|
return key == '__proto__'
|
|
? undefined
|
|
: object[key];
|
|
}
|
|
var arrayProto = Array.prototype,
|
|
funcProto = Function.prototype,
|
|
objectProto = Object.prototype;
|
|
var coreJsData = root['__core-js_shared__'];
|
|
var funcToString = funcProto.toString;
|
|
var hasOwnProperty = objectProto.hasOwnProperty;
|
|
var maskSrcKey = (function() {
|
|
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
|
|
return uid ? ('Symbol(src)_1.' + uid) : '';
|
|
}());
|
|
var nativeObjectToString = objectProto.toString;
|
|
var objectCtorString = funcToString.call(Object);
|
|
var reIsNative = RegExp('^' +
|
|
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
|
|
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
|
|
);
|
|
var Buffer = moduleExports ? root.Buffer : undefined,
|
|
Symbol = root.Symbol,
|
|
Uint8Array = root.Uint8Array,
|
|
allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
|
|
getPrototype = overArg(Object.getPrototypeOf, Object),
|
|
objectCreate = Object.create,
|
|
propertyIsEnumerable = objectProto.propertyIsEnumerable,
|
|
splice = arrayProto.splice,
|
|
symToStringTag = Symbol ? Symbol.toStringTag : undefined;
|
|
|
|
var defineProperty = (function() {
|
|
try {
|
|
var func = getNative(Object, 'defineProperty');
|
|
func({}, '', {});
|
|
return func;
|
|
} catch (e) {}
|
|
}());
|
|
var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
|
|
nativeMax = Math.max,
|
|
nativeNow = Date.now;
|
|
var Map = getNative(root, 'Map'),
|
|
nativeCreate = getNative(Object, 'create');
|
|
var baseCreate = (function() {
|
|
function object() {}
|
|
return function(proto) {
|
|
if (!isObject(proto)) {
|
|
return {};
|
|
}
|
|
if (objectCreate) {
|
|
return objectCreate(proto);
|
|
}
|
|
object.prototype = proto;
|
|
var result = new object;
|
|
object.prototype = undefined;
|
|
return result;
|
|
};
|
|
}());
|
|
function Hash(entries) {
|
|
var index = -1,
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function hashClear() {
|
|
this.__data__ = nativeCreate ? nativeCreate(null) : {};
|
|
this.size = 0;
|
|
}
|
|
function hashDelete(key) {
|
|
var result = this.has(key) && delete this.__data__[key];
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
function hashGet(key) {
|
|
var data = this.__data__;
|
|
if (nativeCreate) {
|
|
var result = data[key];
|
|
return result === HASH_UNDEFINED ? undefined : result;
|
|
}
|
|
return hasOwnProperty.call(data, key) ? data[key] : undefined;
|
|
}
|
|
function hashHas(key) {
|
|
var data = this.__data__;
|
|
return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
|
|
}
|
|
function hashSet(key, value) {
|
|
var data = this.__data__;
|
|
this.size += this.has(key) ? 0 : 1;
|
|
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
|
|
return this;
|
|
}
|
|
Hash.prototype.clear = hashClear;
|
|
Hash.prototype['delete'] = hashDelete;
|
|
Hash.prototype.get = hashGet;
|
|
Hash.prototype.has = hashHas;
|
|
Hash.prototype.set = hashSet;
|
|
function ListCache(entries) {
|
|
var index = -1,
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function listCacheClear() {
|
|
this.__data__ = [];
|
|
this.size = 0;
|
|
}
|
|
function listCacheDelete(key) {
|
|
var data = this.__data__,
|
|
index = assocIndexOf(data, key);
|
|
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
var lastIndex = data.length - 1;
|
|
if (index == lastIndex) {
|
|
data.pop();
|
|
} else {
|
|
splice.call(data, index, 1);
|
|
}
|
|
--this.size;
|
|
return true;
|
|
}
|
|
function listCacheGet(key) {
|
|
var data = this.__data__,
|
|
index = assocIndexOf(data, key);
|
|
|
|
return index < 0 ? undefined : data[index][1];
|
|
}
|
|
function listCacheHas(key) {
|
|
return assocIndexOf(this.__data__, key) > -1;
|
|
}
|
|
function listCacheSet(key, value) {
|
|
var data = this.__data__,
|
|
index = assocIndexOf(data, key);
|
|
|
|
if (index < 0) {
|
|
++this.size;
|
|
data.push([key, value]);
|
|
} else {
|
|
data[index][1] = value;
|
|
}
|
|
return this;
|
|
}
|
|
ListCache.prototype.clear = listCacheClear;
|
|
ListCache.prototype['delete'] = listCacheDelete;
|
|
ListCache.prototype.get = listCacheGet;
|
|
ListCache.prototype.has = listCacheHas;
|
|
ListCache.prototype.set = listCacheSet;
|
|
function MapCache(entries) {
|
|
var index = -1,
|
|
length = entries == null ? 0 : entries.length;
|
|
|
|
this.clear();
|
|
while (++index < length) {
|
|
var entry = entries[index];
|
|
this.set(entry[0], entry[1]);
|
|
}
|
|
}
|
|
function mapCacheClear() {
|
|
this.size = 0;
|
|
this.__data__ = {
|
|
'hash': new Hash,
|
|
'map': new (Map || ListCache),
|
|
'string': new Hash
|
|
};
|
|
}
|
|
function mapCacheDelete(key) {
|
|
var result = getMapData(this, key)['delete'](key);
|
|
this.size -= result ? 1 : 0;
|
|
return result;
|
|
}
|
|
function mapCacheGet(key) {
|
|
return getMapData(this, key).get(key);
|
|
}
|
|
function mapCacheHas(key) {
|
|
return getMapData(this, key).has(key);
|
|
}
|
|
function mapCacheSet(key, value) {
|
|
var data = getMapData(this, key),
|
|
size = data.size;
|
|
|
|
data.set(key, value);
|
|
this.size += data.size == size ? 0 : 1;
|
|
return this;
|
|
}
|
|
MapCache.prototype.clear = mapCacheClear;
|
|
MapCache.prototype['delete'] = mapCacheDelete;
|
|
MapCache.prototype.get = mapCacheGet;
|
|
MapCache.prototype.has = mapCacheHas;
|
|
MapCache.prototype.set = mapCacheSet;
|
|
function Stack(entries) {
|
|
var data = this.__data__ = new ListCache(entries);
|
|
this.size = data.size;
|
|
}
|
|
function stackClear() {
|
|
this.__data__ = new ListCache;
|
|
this.size = 0;
|
|
}
|
|
function stackDelete(key) {
|
|
var data = this.__data__,
|
|
result = data['delete'](key);
|
|
|
|
this.size = data.size;
|
|
return result;
|
|
}
|
|
function stackGet(key) {
|
|
return this.__data__.get(key);
|
|
}
|
|
function stackHas(key) {
|
|
return this.__data__.has(key);
|
|
}
|
|
function stackSet(key, value) {
|
|
var data = this.__data__;
|
|
if (data instanceof ListCache) {
|
|
var pairs = data.__data__;
|
|
if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
|
|
pairs.push([key, value]);
|
|
this.size = ++data.size;
|
|
return this;
|
|
}
|
|
data = this.__data__ = new MapCache(pairs);
|
|
}
|
|
data.set(key, value);
|
|
this.size = data.size;
|
|
return this;
|
|
}
|
|
Stack.prototype.clear = stackClear;
|
|
Stack.prototype['delete'] = stackDelete;
|
|
Stack.prototype.get = stackGet;
|
|
Stack.prototype.has = stackHas;
|
|
Stack.prototype.set = stackSet;
|
|
function arrayLikeKeys(value, inherited) {
|
|
var isArr = isArray(value),
|
|
isArg = !isArr && isArguments(value),
|
|
isBuff = !isArr && !isArg && isBuffer(value),
|
|
isType = !isArr && !isArg && !isBuff && isTypedArray(value),
|
|
skipIndexes = isArr || isArg || isBuff || isType,
|
|
result = skipIndexes ? baseTimes(value.length, String) : [],
|
|
length = result.length;
|
|
|
|
for (var key in value) {
|
|
if ((inherited || hasOwnProperty.call(value, key)) &&
|
|
!(skipIndexes && (
|
|
key == 'length' ||
|
|
(isBuff && (key == 'offset' || key == 'parent')) ||
|
|
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
|
|
isIndex(key, length)
|
|
))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function assignMergeValue(object, key, value) {
|
|
if ((value !== undefined && !eq(object[key], value)) ||
|
|
(value === undefined && !(key in object))) {
|
|
baseAssignValue(object, key, value);
|
|
}
|
|
}
|
|
function assignValue(object, key, value) {
|
|
var objValue = object[key];
|
|
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
|
|
(value === undefined && !(key in object))) {
|
|
baseAssignValue(object, key, value);
|
|
}
|
|
}
|
|
function assocIndexOf(array, key) {
|
|
var length = array.length;
|
|
while (length--) {
|
|
if (eq(array[length][0], key)) {
|
|
return length;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function baseAssignValue(object, key, value) {
|
|
if (key == '__proto__' && defineProperty) {
|
|
defineProperty(object, key, {
|
|
'configurable': true,
|
|
'enumerable': true,
|
|
'value': value,
|
|
'writable': true
|
|
});
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
var baseFor = createBaseFor();
|
|
function baseGetTag(value) {
|
|
if (value == null) {
|
|
return value === undefined ? undefinedTag : nullTag;
|
|
}
|
|
return (symToStringTag && symToStringTag in Object(value))
|
|
? getRawTag(value)
|
|
: objectToString(value);
|
|
}
|
|
function baseIsArguments(value) {
|
|
return isObjectLike(value) && baseGetTag(value) == argsTag;
|
|
}
|
|
function baseIsNative(value) {
|
|
if (!isObject(value) || isMasked(value)) {
|
|
return false;
|
|
}
|
|
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
|
|
return pattern.test(toSource(value));
|
|
}
|
|
function baseIsTypedArray(value) {
|
|
return isObjectLike(value) &&
|
|
isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
|
|
}
|
|
function baseKeysIn(object) {
|
|
if (!isObject(object)) {
|
|
return nativeKeysIn(object);
|
|
}
|
|
var isProto = isPrototype(object),
|
|
result = [];
|
|
|
|
for (var key in object) {
|
|
if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function baseMerge(object, source, srcIndex, customizer, stack) {
|
|
if (object === source) {
|
|
return;
|
|
}
|
|
baseFor(source, function(srcValue, key) {
|
|
if (isObject(srcValue)) {
|
|
stack || (stack = new Stack);
|
|
baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
|
|
}
|
|
else {
|
|
var newValue = customizer
|
|
? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
|
|
: undefined;
|
|
|
|
if (newValue === undefined) {
|
|
newValue = srcValue;
|
|
}
|
|
assignMergeValue(object, key, newValue);
|
|
}
|
|
}, keysIn);
|
|
}
|
|
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
|
|
var objValue = safeGet(object, key),
|
|
srcValue = safeGet(source, key),
|
|
stacked = stack.get(srcValue);
|
|
|
|
if (stacked) {
|
|
assignMergeValue(object, key, stacked);
|
|
return;
|
|
}
|
|
var newValue = customizer
|
|
? customizer(objValue, srcValue, (key + ''), object, source, stack)
|
|
: undefined;
|
|
|
|
var isCommon = newValue === undefined;
|
|
|
|
if (isCommon) {
|
|
var isArr = isArray(srcValue),
|
|
isBuff = !isArr && isBuffer(srcValue),
|
|
isTyped = !isArr && !isBuff && isTypedArray(srcValue);
|
|
|
|
newValue = srcValue;
|
|
if (isArr || isBuff || isTyped) {
|
|
if (isArray(objValue)) {
|
|
newValue = objValue;
|
|
}
|
|
else if (isArrayLikeObject(objValue)) {
|
|
newValue = copyArray(objValue);
|
|
}
|
|
else if (isBuff) {
|
|
isCommon = false;
|
|
newValue = cloneBuffer(srcValue, true);
|
|
}
|
|
else if (isTyped) {
|
|
isCommon = false;
|
|
newValue = cloneTypedArray(srcValue, true);
|
|
}
|
|
else {
|
|
newValue = [];
|
|
}
|
|
}
|
|
else if (isPlainObject(srcValue) || isArguments(srcValue)) {
|
|
newValue = objValue;
|
|
if (isArguments(objValue)) {
|
|
newValue = toPlainObject(objValue);
|
|
}
|
|
else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
|
|
newValue = initCloneObject(srcValue);
|
|
}
|
|
}
|
|
else {
|
|
isCommon = false;
|
|
}
|
|
}
|
|
if (isCommon) {
|
|
stack.set(srcValue, newValue);
|
|
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
|
|
stack['delete'](srcValue);
|
|
}
|
|
assignMergeValue(object, key, newValue);
|
|
}
|
|
function baseRest(func, start) {
|
|
return setToString(overRest(func, start, identity), func + '');
|
|
}
|
|
var baseSetToString = !defineProperty ? identity : function(func, string) {
|
|
return defineProperty(func, 'toString', {
|
|
'configurable': true,
|
|
'enumerable': false,
|
|
'value': constant(string),
|
|
'writable': true
|
|
});
|
|
};
|
|
function cloneBuffer(buffer, isDeep) {
|
|
if (isDeep) {
|
|
return buffer.slice();
|
|
}
|
|
var length = buffer.length,
|
|
result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
|
|
|
|
buffer.copy(result);
|
|
return result;
|
|
}
|
|
function cloneArrayBuffer(arrayBuffer) {
|
|
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
|
|
new Uint8Array(result).set(new Uint8Array(arrayBuffer));
|
|
return result;
|
|
}
|
|
function cloneTypedArray(typedArray, isDeep) {
|
|
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
|
|
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
|
|
}
|
|
function copyArray(source, array) {
|
|
var index = -1,
|
|
length = source.length;
|
|
|
|
array || (array = Array(length));
|
|
while (++index < length) {
|
|
array[index] = source[index];
|
|
}
|
|
return array;
|
|
}
|
|
function copyObject(source, props, object, customizer) {
|
|
var isNew = !object;
|
|
object || (object = {});
|
|
|
|
var index = -1,
|
|
length = props.length;
|
|
|
|
while (++index < length) {
|
|
var key = props[index];
|
|
|
|
var newValue = customizer
|
|
? customizer(object[key], source[key], key, object, source)
|
|
: undefined;
|
|
|
|
if (newValue === undefined) {
|
|
newValue = source[key];
|
|
}
|
|
if (isNew) {
|
|
baseAssignValue(object, key, newValue);
|
|
} else {
|
|
assignValue(object, key, newValue);
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function createAssigner(assigner) {
|
|
return baseRest(function(object, sources) {
|
|
var index = -1,
|
|
length = sources.length,
|
|
customizer = length > 1 ? sources[length - 1] : undefined,
|
|
guard = length > 2 ? sources[2] : undefined;
|
|
|
|
customizer = (assigner.length > 3 && typeof customizer == 'function')
|
|
? (length--, customizer)
|
|
: undefined;
|
|
|
|
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
|
|
customizer = length < 3 ? undefined : customizer;
|
|
length = 1;
|
|
}
|
|
object = Object(object);
|
|
while (++index < length) {
|
|
var source = sources[index];
|
|
if (source) {
|
|
assigner(object, source, index, customizer);
|
|
}
|
|
}
|
|
return object;
|
|
});
|
|
}
|
|
function createBaseFor(fromRight) {
|
|
return function(object, iteratee, keysFunc) {
|
|
var index = -1,
|
|
iterable = Object(object),
|
|
props = keysFunc(object),
|
|
length = props.length;
|
|
|
|
while (length--) {
|
|
var key = props[fromRight ? length : ++index];
|
|
if (iteratee(iterable[key], key, iterable) === false) {
|
|
break;
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
}
|
|
function getMapData(map, key) {
|
|
var data = map.__data__;
|
|
return isKeyable(key)
|
|
? data[typeof key == 'string' ? 'string' : 'hash']
|
|
: data.map;
|
|
}
|
|
function getNative(object, key) {
|
|
var value = getValue(object, key);
|
|
return baseIsNative(value) ? value : undefined;
|
|
}
|
|
function getRawTag(value) {
|
|
var isOwn = hasOwnProperty.call(value, symToStringTag),
|
|
tag = value[symToStringTag];
|
|
|
|
try {
|
|
value[symToStringTag] = undefined;
|
|
var unmasked = true;
|
|
} catch (e) {}
|
|
|
|
var result = nativeObjectToString.call(value);
|
|
if (unmasked) {
|
|
if (isOwn) {
|
|
value[symToStringTag] = tag;
|
|
} else {
|
|
delete value[symToStringTag];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function initCloneObject(object) {
|
|
return (typeof object.constructor == 'function' && !isPrototype(object))
|
|
? baseCreate(getPrototype(object))
|
|
: {};
|
|
}
|
|
function isIndex(value, length) {
|
|
var type = typeof value;
|
|
length = length == null ? MAX_SAFE_INTEGER : length;
|
|
|
|
return !!length &&
|
|
(type == 'number' ||
|
|
(type != 'symbol' && reIsUint.test(value))) &&
|
|
(value > -1 && value % 1 == 0 && value < length);
|
|
}
|
|
function isIterateeCall(value, index, object) {
|
|
if (!isObject(object)) {
|
|
return false;
|
|
}
|
|
var type = typeof index;
|
|
if (type == 'number'
|
|
? (isArrayLike(object) && isIndex(index, object.length))
|
|
: (type == 'string' && index in object)
|
|
) {
|
|
return eq(object[index], value);
|
|
}
|
|
return false;
|
|
}
|
|
function isKeyable(value) {
|
|
var type = typeof value;
|
|
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
|
|
? (value !== '__proto__')
|
|
: (value === null);
|
|
}
|
|
function isMasked(func) {
|
|
return !!maskSrcKey && (maskSrcKey in func);
|
|
}
|
|
function isPrototype(value) {
|
|
var Ctor = value && value.constructor,
|
|
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
|
|
|
|
return value === proto;
|
|
}
|
|
function nativeKeysIn(object) {
|
|
var result = [];
|
|
if (object != null) {
|
|
for (var key in Object(object)) {
|
|
result.push(key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function objectToString(value) {
|
|
return nativeObjectToString.call(value);
|
|
}
|
|
function overRest(func, start, transform) {
|
|
start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
|
|
return function() {
|
|
var args = arguments,
|
|
index = -1,
|
|
length = nativeMax(args.length - start, 0),
|
|
array = Array(length);
|
|
|
|
while (++index < length) {
|
|
array[index] = args[start + index];
|
|
}
|
|
index = -1;
|
|
var otherArgs = Array(start + 1);
|
|
while (++index < start) {
|
|
otherArgs[index] = args[index];
|
|
}
|
|
otherArgs[start] = transform(array);
|
|
return apply(func, this, otherArgs);
|
|
};
|
|
}
|
|
var setToString = shortOut(baseSetToString);
|
|
function shortOut(func) {
|
|
var count = 0,
|
|
lastCalled = 0;
|
|
|
|
return function() {
|
|
var stamp = nativeNow(),
|
|
remaining = HOT_SPAN - (stamp - lastCalled);
|
|
|
|
lastCalled = stamp;
|
|
if (remaining > 0) {
|
|
if (++count >= HOT_COUNT) {
|
|
return arguments[0];
|
|
}
|
|
} else {
|
|
count = 0;
|
|
}
|
|
return func.apply(undefined, arguments);
|
|
};
|
|
}
|
|
function toSource(func) {
|
|
if (func != null) {
|
|
try {
|
|
return funcToString.call(func);
|
|
} catch (e) {}
|
|
try {
|
|
return (func + '');
|
|
} catch (e) {}
|
|
}
|
|
return '';
|
|
}
|
|
function eq(value, other) {
|
|
return value === other || (value !== value && other !== other);
|
|
}
|
|
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
|
|
return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
|
|
!propertyIsEnumerable.call(value, 'callee');
|
|
};
|
|
var isArray = Array.isArray;
|
|
function isArrayLike(value) {
|
|
return value != null && isLength(value.length) && !isFunction(value);
|
|
}
|
|
function isArrayLikeObject(value) {
|
|
return isObjectLike(value) && isArrayLike(value);
|
|
}
|
|
var isBuffer = nativeIsBuffer || stubFalse;
|
|
function isFunction(value) {
|
|
if (!isObject(value)) {
|
|
return false;
|
|
}
|
|
var tag = baseGetTag(value);
|
|
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
|
|
}
|
|
function isLength(value) {
|
|
return typeof value == 'number' &&
|
|
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
|
|
}
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return value != null && (type == 'object' || type == 'function');
|
|
}
|
|
function isObjectLike(value) {
|
|
return value != null && typeof value == 'object';
|
|
}
|
|
function isPlainObject(value) {
|
|
if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
|
|
return false;
|
|
}
|
|
var proto = getPrototype(value);
|
|
if (proto === null) {
|
|
return true;
|
|
}
|
|
var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
|
|
return typeof Ctor == 'function' && Ctor instanceof Ctor &&
|
|
funcToString.call(Ctor) == objectCtorString;
|
|
}
|
|
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
|
|
function toPlainObject(value) {
|
|
return copyObject(value, keysIn(value));
|
|
}
|
|
function keysIn(object) {
|
|
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
|
|
}
|
|
var merge = createAssigner(function(object, source, srcIndex) {
|
|
baseMerge(object, source, srcIndex);
|
|
});
|
|
function constant(value) {
|
|
return function() {
|
|
return value;
|
|
};
|
|
}
|
|
function identity(value) {
|
|
return value;
|
|
}
|
|
function stubFalse() {
|
|
return false;
|
|
}
|
|
|
|
module.exports = merge;
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
|
|
},{}]},{},[2])(2);
|
|
});
|
|
});
|
|
|
|
ace.define("ace/mode/yaml_worker",[], function(require, exports) {
|
|
"use strict";
|
|
|
|
var oop = require("../lib/oop");
|
|
var Mirror = require("../worker/mirror").Mirror;
|
|
var lint = require("./yaml/yaml-lint").lint;
|
|
|
|
var YamlWorker = exports.YamlWorker = function(sender) {
|
|
Mirror.call(this, sender);
|
|
this.setTimeout(500);
|
|
this.setOptions();
|
|
};
|
|
|
|
oop.inherits(YamlWorker, Mirror);
|
|
|
|
(function() {
|
|
this.setOptions = function() {
|
|
this.doc.getValue() && this.deferredUpdate.schedule(100);
|
|
};
|
|
|
|
this.changeOptions = function(newOptions) {
|
|
oop.mixin(this.options, newOptions);
|
|
this.doc.getValue() && this.deferredUpdate.schedule(100);
|
|
};
|
|
|
|
this.onUpdate = function() {
|
|
var _this = this;
|
|
var value = this.doc.getValue();
|
|
var errors = [];
|
|
|
|
lint(value, {}, function(error) {
|
|
if (!error) {
|
|
_this.sender.emit("annotate", errors);
|
|
return;
|
|
}
|
|
|
|
errors.push({
|
|
row: error.mark.line,
|
|
column: error.mark.column,
|
|
text: error.reason,
|
|
type: 'error',
|
|
raw: error
|
|
});
|
|
|
|
_this.sender.emit("annotate", errors);
|
|
});
|
|
};
|
|
|
|
}).call(YamlWorker.prototype);
|
|
|
|
});
|