Page Menu
Home
WickedGov Phorge
Search
Configure Global Search
Log In
Files
F4065831
worker-yaml.js
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Size
162 KB
Referenced Files
None
Subscribers
None
worker-yaml.js
View Options
"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
Range
=
/** @class */
(
function
()
{
function
Range
(
startRow
,
startColumn
,
endRow
,
endColumn
)
{
this
.
start
=
{
row
:
startRow
,
column
:
startColumn
};
this
.
end
=
{
row
:
endRow
,
column
:
endColumn
};
}
Range
.
prototype
.
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
;
};
Range
.
prototype
.
toString
=
function
()
{
return
(
"Range: ["
+
this
.
start
.
row
+
"/"
+
this
.
start
.
column
+
"] -> ["
+
this
.
end
.
row
+
"/"
+
this
.
end
.
column
+
"]"
);
};
Range
.
prototype
.
contains
=
function
(
row
,
column
)
{
return
this
.
compare
(
row
,
column
)
==
0
;
};
Range
.
prototype
.
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
;
}
}
};
Range
.
prototype
.
comparePoint
=
function
(
p
)
{
return
this
.
compare
(
p
.
row
,
p
.
column
);
};
Range
.
prototype
.
containsRange
=
function
(
range
)
{
return
this
.
comparePoint
(
range
.
start
)
==
0
&&
this
.
comparePoint
(
range
.
end
)
==
0
;
};
Range
.
prototype
.
intersects
=
function
(
range
)
{
var
cmp
=
this
.
compareRange
(
range
);
return
(
cmp
==
-
1
||
cmp
==
0
||
cmp
==
1
);
};
Range
.
prototype
.
isEnd
=
function
(
row
,
column
)
{
return
this
.
end
.
row
==
row
&&
this
.
end
.
column
==
column
;
};
Range
.
prototype
.
isStart
=
function
(
row
,
column
)
{
return
this
.
start
.
row
==
row
&&
this
.
start
.
column
==
column
;
};
Range
.
prototype
.
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
;
}
};
Range
.
prototype
.
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
;
}
};
Range
.
prototype
.
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
;
};
Range
.
prototype
.
insideStart
=
function
(
row
,
column
)
{
if
(
this
.
compare
(
row
,
column
)
==
0
)
{
if
(
this
.
isEnd
(
row
,
column
))
{
return
false
;
}
else
{
return
true
;
}
}
return
false
;
};
Range
.
prototype
.
insideEnd
=
function
(
row
,
column
)
{
if
(
this
.
compare
(
row
,
column
)
==
0
)
{
if
(
this
.
isStart
(
row
,
column
))
{
return
false
;
}
else
{
return
true
;
}
}
return
false
;
};
Range
.
prototype
.
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
;
};
Range
.
prototype
.
compareStart
=
function
(
row
,
column
)
{
if
(
this
.
start
.
row
==
row
&&
this
.
start
.
column
==
column
)
{
return
-
1
;
}
else
{
return
this
.
compare
(
row
,
column
);
}
};
Range
.
prototype
.
compareEnd
=
function
(
row
,
column
)
{
if
(
this
.
end
.
row
==
row
&&
this
.
end
.
column
==
column
)
{
return
1
;
}
else
{
return
this
.
compare
(
row
,
column
);
}
};
Range
.
prototype
.
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
);
}
};
Range
.
prototype
.
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
);
};
Range
.
prototype
.
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
);
};
Range
.
prototype
.
isEmpty
=
function
()
{
return
(
this
.
start
.
row
===
this
.
end
.
row
&&
this
.
start
.
column
===
this
.
end
.
column
);
};
Range
.
prototype
.
isMultiLine
=
function
()
{
return
(
this
.
start
.
row
!==
this
.
end
.
row
);
};
Range
.
prototype
.
clone
=
function
()
{
return
Range
.
fromPoints
(
this
.
start
,
this
.
end
);
};
Range
.
prototype
.
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
);
};
Range
.
prototype
.
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
);
};
Range
.
prototype
.
moveBy
=
function
(
row
,
column
)
{
this
.
start
.
row
+=
row
;
this
.
start
.
column
+=
column
;
this
.
end
.
row
+=
row
;
this
.
end
.
column
+=
column
;
};
return
Range
;
}());
Range
.
fromPoints
=
function
(
start
,
end
)
{
return
new
Range
(
start
.
row
,
start
.
column
,
end
.
row
,
end
.
column
);
};
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
=
/** @class */
(
function
()
{
function
Anchor
(
doc
,
row
,
column
)
{
this
.
$onChange
=
this
.
onChange
.
bind
(
this
);
this
.
attach
(
doc
);
if
(
typeof
row
!=
"number"
)
this
.
setPosition
(
row
.
row
,
row
.
column
);
else
this
.
setPosition
(
row
,
column
);
}
Anchor
.
prototype
.
getPosition
=
function
()
{
return
this
.
$clipPositionToDocument
(
this
.
row
,
this
.
column
);
};
Anchor
.
prototype
.
getDocument
=
function
()
{
return
this
.
document
;
};
Anchor
.
prototype
.
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
);
};
Anchor
.
prototype
.
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
});
};
Anchor
.
prototype
.
detach
=
function
()
{
this
.
document
.
off
(
"change"
,
this
.
$onChange
);
};
Anchor
.
prototype
.
attach
=
function
(
doc
)
{
this
.
document
=
doc
||
this
.
document
;
this
.
document
.
on
(
"change"
,
this
.
$onChange
);
};
Anchor
.
prototype
.
$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
;
};
return
Anchor
;
}());
Anchor
.
prototype
.
$insertRight
=
false
;
oop
.
implement
(
Anchor
.
prototype
,
EventEmitter
);
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
};
}
exports
.
Anchor
=
Anchor
;
});
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
=
/** @class */
(
function
()
{
function
Document
(
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
);
}
}
Document
.
prototype
.
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
||
""
);
};
Document
.
prototype
.
getValue
=
function
()
{
return
this
.
getAllLines
().
join
(
this
.
getNewLineCharacter
());
};
Document
.
prototype
.
createAnchor
=
function
(
row
,
column
)
{
return
new
Anchor
(
this
,
row
,
column
);
};
Document
.
prototype
.
$detectNewLine
=
function
(
text
)
{
var
match
=
text
.
match
(
/^.*?(\r\n|\r|\n)/m
);
this
.
$autoNewLine
=
match
?
match
[
1
]
:
"\n"
;
this
.
_signal
(
"changeNewLineMode"
);
};
Document
.
prototype
.
getNewLineCharacter
=
function
()
{
switch
(
this
.
$newLineMode
)
{
case
"windows"
:
return
"\r\n"
;
case
"unix"
:
return
"\n"
;
default
:
return
this
.
$autoNewLine
||
"\n"
;
}
};
Document
.
prototype
.
setNewLineMode
=
function
(
newLineMode
)
{
if
(
this
.
$newLineMode
===
newLineMode
)
return
;
this
.
$newLineMode
=
newLineMode
;
this
.
_signal
(
"changeNewLineMode"
);
};
Document
.
prototype
.
getNewLineMode
=
function
()
{
return
this
.
$newLineMode
;
};
Document
.
prototype
.
isNewLine
=
function
(
text
)
{
return
(
text
==
"\r\n"
||
text
==
"\r"
||
text
==
"\n"
);
};
Document
.
prototype
.
getLine
=
function
(
row
)
{
return
this
.
$lines
[
row
]
||
""
;
};
Document
.
prototype
.
getLines
=
function
(
firstRow
,
lastRow
)
{
return
this
.
$lines
.
slice
(
firstRow
,
lastRow
+
1
);
};
Document
.
prototype
.
getAllLines
=
function
()
{
return
this
.
getLines
(
0
,
this
.
getLength
());
};
Document
.
prototype
.
getLength
=
function
()
{
return
this
.
$lines
.
length
;
};
Document
.
prototype
.
getTextRange
=
function
(
range
)
{
return
this
.
getLinesForRange
(
range
).
join
(
this
.
getNewLineCharacter
());
};
Document
.
prototype
.
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
;
};
Document
.
prototype
.
insertLines
=
function
(
row
,
lines
)
{
console
.
warn
(
"Use of document.insertLines is deprecated. Use the insertFullLines method instead."
);
return
this
.
insertFullLines
(
row
,
lines
);
};
Document
.
prototype
.
removeLines
=
function
(
firstRow
,
lastRow
)
{
console
.
warn
(
"Use of document.removeLines is deprecated. Use the removeFullLines method instead."
);
return
this
.
removeFullLines
(
firstRow
,
lastRow
);
};
Document
.
prototype
.
insertNewLine
=
function
(
position
)
{
console
.
warn
(
"Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead."
);
return
this
.
insertMergedLines
(
position
,
[
""
,
""
]);
};
Document
.
prototype
.
insert
=
function
(
position
,
text
)
{
if
(
this
.
getLength
()
<=
1
)
this
.
$detectNewLine
(
text
);
return
this
.
insertMergedLines
(
position
,
this
.
$split
(
text
));
};
Document
.
prototype
.
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
);
};
Document
.
prototype
.
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
};
};
Document
.
prototype
.
clonePos
=
function
(
pos
)
{
return
{
row
:
pos
.
row
,
column
:
pos
.
column
};
};
Document
.
prototype
.
pos
=
function
(
row
,
column
)
{
return
{
row
:
row
,
column
:
column
};
};
Document
.
prototype
.
$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
;
};
Document
.
prototype
.
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
);
};
Document
.
prototype
.
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
);
};
Document
.
prototype
.
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
);
};
Document
.
prototype
.
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
);
};
Document
.
prototype
.
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
;
};
Document
.
prototype
.
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
:
[
""
,
""
]
});
}
};
Document
.
prototype
.
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
;
};
Document
.
prototype
.
applyDeltas
=
function
(
deltas
)
{
for
(
var
i
=
0
;
i
<
deltas
.
length
;
i
++
)
{
this
.
applyDelta
(
deltas
[
i
]);
}
};
Document
.
prototype
.
revertDeltas
=
function
(
deltas
)
{
for
(
var
i
=
deltas
.
length
-
1
;
i
>=
0
;
i
--
)
{
this
.
revertDelta
(
deltas
[
i
]);
}
};
Document
.
prototype
.
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
);
}
};
Document
.
prototype
.
$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
);
}
};
Document
.
prototype
.
$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
);
};
Document
.
prototype
.
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
()
});
};
Document
.
prototype
.
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
};
};
Document
.
prototype
.
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
;
};
Document
.
prototype
.
$split
=
function
(
text
)
{
return
text
.
split
(
/\r\n|\r|\n/
);
};
return
Document
;
}());
Document
.
prototype
.
$autoNewLine
=
""
;
Document
.
prototype
.
$newLineMode
=
"auto"
;
oop
.
implement
(
Document
.
prototype
,
EventEmitter
);
exports
.
Document
=
Document
;
});
ace
.
define
(
"ace/lib/deep_copy"
,[],
function
(
require
,
exports
,
module
){
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
;
};
});
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
=
require
(
"./deep_copy"
).
deepCopy
;
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
;
};
exports
.
supportsLookbehind
=
function
()
{
try
{
new
RegExp
(
'(?<=.)'
);
}
catch
(
e
)
{
return
false
;
}
return
true
;
};
exports
.
skipEmptyMatch
=
function
(
line
,
last
,
supportsUnicodeFlag
)
{
return
supportsUnicodeFlag
&&
line
.
codePointAt
(
last
)
>
0xffff
?
2
:
1
;
};
});
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
;
}
var
markDefined
=
!!
error
.
mark
;
errors
.
push
({
row
:
markDefined
?
error
.
mark
.
line
:
0
,
column
:
markDefined
?
error
.
mark
.
column
:
0
,
text
:
error
.
reason
,
type
:
'error'
,
raw
:
error
});
_this
.
sender
.
emit
(
"annotate"
,
errors
);
});
};
}).
call
(
YamlWorker
.
prototype
);
});
File Metadata
Details
Attached
Mime Type
text/plain
Expires
Aug 16 2026, 15:46 (13 w, 4 d ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
be/b1/761463b5c842a1185bcb0ad852de
Default Alt Text
worker-yaml.js (162 KB)
Attached To
Mode
rMWPROD MediaWiki Production
Attached
Detach File
Event Timeline
Log In to Comment