1031 lines
37 KiB
JavaScript
1031 lines
37 KiB
JavaScript
// modules are defined as an array
|
|
// [ module function, map of requires ]
|
|
//
|
|
// map of requires is short require name -> numeric require
|
|
//
|
|
// anything defined in a previous bundle is accessed via the
|
|
// orig method which is the require for previous bundles
|
|
|
|
(function (modules, entry, mainEntry, parcelRequireName, globalName) {
|
|
/* eslint-disable no-undef */
|
|
var globalObject =
|
|
typeof globalThis !== 'undefined'
|
|
? globalThis
|
|
: typeof self !== 'undefined'
|
|
? self
|
|
: typeof window !== 'undefined'
|
|
? window
|
|
: typeof global !== 'undefined'
|
|
? global
|
|
: {};
|
|
/* eslint-enable no-undef */
|
|
|
|
// Save the require from previous bundle to this closure if any
|
|
var previousRequire =
|
|
typeof globalObject[parcelRequireName] === 'function' &&
|
|
globalObject[parcelRequireName];
|
|
|
|
var cache = previousRequire.cache || {};
|
|
// Do not use `require` to prevent Webpack from trying to bundle this call
|
|
var nodeRequire =
|
|
typeof module !== 'undefined' &&
|
|
typeof module.require === 'function' &&
|
|
module.require.bind(module);
|
|
|
|
function newRequire(name, jumped) {
|
|
if (!cache[name]) {
|
|
if (!modules[name]) {
|
|
// if we cannot find the module within our internal map or
|
|
// cache jump to the current global require ie. the last bundle
|
|
// that was added to the page.
|
|
var currentRequire =
|
|
typeof globalObject[parcelRequireName] === 'function' &&
|
|
globalObject[parcelRequireName];
|
|
if (!jumped && currentRequire) {
|
|
return currentRequire(name, true);
|
|
}
|
|
|
|
// If there are other bundles on this page the require from the
|
|
// previous one is saved to 'previousRequire'. Repeat this as
|
|
// many times as there are bundles until the module is found or
|
|
// we exhaust the require chain.
|
|
if (previousRequire) {
|
|
return previousRequire(name, true);
|
|
}
|
|
|
|
// Try the node require function if it exists.
|
|
if (nodeRequire && typeof name === 'string') {
|
|
return nodeRequire(name);
|
|
}
|
|
|
|
var err = new Error("Cannot find module '" + name + "'");
|
|
err.code = 'MODULE_NOT_FOUND';
|
|
throw err;
|
|
}
|
|
|
|
localRequire.resolve = resolve;
|
|
localRequire.cache = {};
|
|
|
|
var module = (cache[name] = new newRequire.Module(name));
|
|
|
|
modules[name][0].call(
|
|
module.exports,
|
|
localRequire,
|
|
module,
|
|
module.exports,
|
|
this
|
|
);
|
|
}
|
|
|
|
return cache[name].exports;
|
|
|
|
function localRequire(x) {
|
|
var res = localRequire.resolve(x);
|
|
return res === false ? {} : newRequire(res);
|
|
}
|
|
|
|
function resolve(x) {
|
|
var id = modules[name][1][x];
|
|
return id != null ? id : x;
|
|
}
|
|
}
|
|
|
|
function Module(moduleName) {
|
|
this.id = moduleName;
|
|
this.bundle = newRequire;
|
|
this.exports = {};
|
|
}
|
|
|
|
newRequire.isParcelRequire = true;
|
|
newRequire.Module = Module;
|
|
newRequire.modules = modules;
|
|
newRequire.cache = cache;
|
|
newRequire.parent = previousRequire;
|
|
newRequire.register = function (id, exports) {
|
|
modules[id] = [
|
|
function (require, module) {
|
|
module.exports = exports;
|
|
},
|
|
{},
|
|
];
|
|
};
|
|
|
|
Object.defineProperty(newRequire, 'root', {
|
|
get: function () {
|
|
return globalObject[parcelRequireName];
|
|
},
|
|
});
|
|
|
|
globalObject[parcelRequireName] = newRequire;
|
|
|
|
for (var i = 0; i < entry.length; i++) {
|
|
newRequire(entry[i]);
|
|
}
|
|
|
|
if (mainEntry) {
|
|
// Expose entry point to Node, AMD or browser globals
|
|
// Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
|
|
var mainExports = newRequire(mainEntry);
|
|
|
|
// CommonJS
|
|
if (typeof exports === 'object' && typeof module !== 'undefined') {
|
|
module.exports = mainExports;
|
|
|
|
// RequireJS
|
|
} else if (typeof define === 'function' && define.amd) {
|
|
define(function () {
|
|
return mainExports;
|
|
});
|
|
|
|
// <script>
|
|
} else if (globalName) {
|
|
this[globalName] = mainExports;
|
|
}
|
|
}
|
|
})({"9vtUI":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "DiffEditor", ()=>we);
|
|
parcelHelpers.export(exports, "Editor", ()=>de);
|
|
parcelHelpers.export(exports, "default", ()=>Ft);
|
|
parcelHelpers.export(exports, "loader", ()=>(0, _loaderDefault.default));
|
|
parcelHelpers.export(exports, "useMonaco", ()=>Le);
|
|
var _loader = require("@monaco-editor/loader");
|
|
var _loaderDefault = parcelHelpers.interopDefault(_loader);
|
|
var _react = require("react");
|
|
var _reactDefault = parcelHelpers.interopDefault(_react);
|
|
var le = {
|
|
wrapper: {
|
|
display: "flex",
|
|
position: "relative",
|
|
textAlign: "initial"
|
|
},
|
|
fullWidth: {
|
|
width: "100%"
|
|
},
|
|
hide: {
|
|
display: "none"
|
|
}
|
|
}, v = le;
|
|
var ae = {
|
|
container: {
|
|
display: "flex",
|
|
height: "100%",
|
|
width: "100%",
|
|
justifyContent: "center",
|
|
alignItems: "center"
|
|
}
|
|
}, Y = ae;
|
|
function Me({ children: e }) {
|
|
return (0, _reactDefault.default).createElement("div", {
|
|
style: Y.container
|
|
}, e);
|
|
}
|
|
var Z = Me;
|
|
var $ = Z;
|
|
function Ee({ width: e, height: r, isEditorReady: n, loading: t, _ref: a, className: m, wrapperProps: E }) {
|
|
return (0, _reactDefault.default).createElement("section", {
|
|
style: {
|
|
...v.wrapper,
|
|
width: e,
|
|
height: r
|
|
},
|
|
...E
|
|
}, !n && (0, _reactDefault.default).createElement($, null, t), (0, _reactDefault.default).createElement("div", {
|
|
ref: a,
|
|
style: {
|
|
...v.fullWidth,
|
|
...!n && v.hide
|
|
},
|
|
className: m
|
|
}));
|
|
}
|
|
var ee = Ee;
|
|
var H = (0, _react.memo)(ee);
|
|
function Ce(e) {
|
|
(0, _react.useEffect)(e, []);
|
|
}
|
|
var k = Ce;
|
|
function he(e, r, n = !0) {
|
|
let t = (0, _react.useRef)(!0);
|
|
(0, _react.useEffect)(t.current || !n ? ()=>{
|
|
t.current = !1;
|
|
} : e, r);
|
|
}
|
|
var l = he;
|
|
function D() {}
|
|
function h(e, r, n, t) {
|
|
return De(e, t) || be(e, r, n, t);
|
|
}
|
|
function De(e, r) {
|
|
return e.editor.getModel(te(e, r));
|
|
}
|
|
function be(e, r, n, t) {
|
|
return e.editor.createModel(r, n, t ? te(e, t) : void 0);
|
|
}
|
|
function te(e, r) {
|
|
return e.Uri.parse(r);
|
|
}
|
|
function Oe({ original: e, modified: r, language: n, originalLanguage: t, modifiedLanguage: a, originalModelPath: m, modifiedModelPath: E, keepCurrentOriginalModel: g = !1, keepCurrentModifiedModel: N = !1, theme: x = "light", loading: P = "Loading...", options: y = {}, height: V = "100%", width: z = "100%", className: F, wrapperProps: j = {}, beforeMount: A = D, onMount: q = D }) {
|
|
let [M, O] = (0, _react.useState)(!1), [T, s] = (0, _react.useState)(!0), u = (0, _react.useRef)(null), c = (0, _react.useRef)(null), w = (0, _react.useRef)(null), d = (0, _react.useRef)(q), o = (0, _react.useRef)(A), b = (0, _react.useRef)(!1);
|
|
k(()=>{
|
|
let i = (0, _loaderDefault.default).init();
|
|
return i.then((f)=>(c.current = f) && s(!1)).catch((f)=>f?.type !== "cancelation" && console.error("Monaco initialization: error:", f)), ()=>u.current ? I() : i.cancel();
|
|
}), l(()=>{
|
|
if (u.current && c.current) {
|
|
let i = u.current.getOriginalEditor(), f = h(c.current, e || "", t || n || "text", m || "");
|
|
f !== i.getModel() && i.setModel(f);
|
|
}
|
|
}, [
|
|
m
|
|
], M), l(()=>{
|
|
if (u.current && c.current) {
|
|
let i = u.current.getModifiedEditor(), f = h(c.current, r || "", a || n || "text", E || "");
|
|
f !== i.getModel() && i.setModel(f);
|
|
}
|
|
}, [
|
|
E
|
|
], M), l(()=>{
|
|
let i = u.current.getModifiedEditor();
|
|
i.getOption(c.current.editor.EditorOption.readOnly) ? i.setValue(r || "") : r !== i.getValue() && (i.executeEdits("", [
|
|
{
|
|
range: i.getModel().getFullModelRange(),
|
|
text: r || "",
|
|
forceMoveMarkers: !0
|
|
}
|
|
]), i.pushUndoStop());
|
|
}, [
|
|
r
|
|
], M), l(()=>{
|
|
u.current?.getModel()?.original.setValue(e || "");
|
|
}, [
|
|
e
|
|
], M), l(()=>{
|
|
let { original: i, modified: f } = u.current.getModel();
|
|
c.current.editor.setModelLanguage(i, t || n || "text"), c.current.editor.setModelLanguage(f, a || n || "text");
|
|
}, [
|
|
n,
|
|
t,
|
|
a
|
|
], M), l(()=>{
|
|
c.current?.editor.setTheme(x);
|
|
}, [
|
|
x
|
|
], M), l(()=>{
|
|
u.current?.updateOptions(y);
|
|
}, [
|
|
y
|
|
], M);
|
|
let L = (0, _react.useCallback)(()=>{
|
|
if (!c.current) return;
|
|
o.current(c.current);
|
|
let i = h(c.current, e || "", t || n || "text", m || ""), f = h(c.current, r || "", a || n || "text", E || "");
|
|
u.current?.setModel({
|
|
original: i,
|
|
modified: f
|
|
});
|
|
}, [
|
|
n,
|
|
r,
|
|
a,
|
|
e,
|
|
t,
|
|
m,
|
|
E
|
|
]), U = (0, _react.useCallback)(()=>{
|
|
!b.current && w.current && (u.current = c.current.editor.createDiffEditor(w.current, {
|
|
automaticLayout: !0,
|
|
...y
|
|
}), L(), c.current?.editor.setTheme(x), O(!0), b.current = !0);
|
|
}, [
|
|
y,
|
|
x,
|
|
L
|
|
]);
|
|
(0, _react.useEffect)(()=>{
|
|
M && d.current(u.current, c.current);
|
|
}, [
|
|
M
|
|
]), (0, _react.useEffect)(()=>{
|
|
!T && !M && U();
|
|
}, [
|
|
T,
|
|
M,
|
|
U
|
|
]);
|
|
function I() {
|
|
let i = u.current?.getModel();
|
|
g || i?.original?.dispose(), N || i?.modified?.dispose(), u.current?.dispose();
|
|
}
|
|
return (0, _reactDefault.default).createElement(H, {
|
|
width: z,
|
|
height: V,
|
|
isEditorReady: M,
|
|
loading: P,
|
|
_ref: w,
|
|
className: F,
|
|
wrapperProps: j
|
|
});
|
|
}
|
|
var ie = Oe;
|
|
var we = (0, _react.memo)(ie);
|
|
function Pe() {
|
|
let [e, r] = (0, _react.useState)((0, _loaderDefault.default).__getMonacoInstance());
|
|
return k(()=>{
|
|
let n;
|
|
return e || (n = (0, _loaderDefault.default).init(), n.then((t)=>{
|
|
r(t);
|
|
})), ()=>n?.cancel();
|
|
}), e;
|
|
}
|
|
var Le = Pe;
|
|
function He(e) {
|
|
let r = (0, _react.useRef)();
|
|
return (0, _react.useEffect)(()=>{
|
|
r.current = e;
|
|
}, [
|
|
e
|
|
]), r.current;
|
|
}
|
|
var se = He;
|
|
var _ = new Map;
|
|
function Ve({ defaultValue: e, defaultLanguage: r, defaultPath: n, value: t, language: a, path: m, theme: E = "light", line: g, loading: N = "Loading...", options: x = {}, overrideServices: P = {}, saveViewState: y = !0, keepCurrentModel: V = !1, width: z = "100%", height: F = "100%", className: j, wrapperProps: A = {}, beforeMount: q = D, onMount: M = D, onChange: O, onValidate: T = D }) {
|
|
let [s, u] = (0, _react.useState)(!1), [c, w] = (0, _react.useState)(!0), d = (0, _react.useRef)(null), o = (0, _react.useRef)(null), b = (0, _react.useRef)(null), L = (0, _react.useRef)(M), U = (0, _react.useRef)(q), I = (0, _react.useRef)(), i = (0, _react.useRef)(t), f = se(m), Q = (0, _react.useRef)(!1), B = (0, _react.useRef)(!1);
|
|
k(()=>{
|
|
let p = (0, _loaderDefault.default).init();
|
|
return p.then((R)=>(d.current = R) && w(!1)).catch((R)=>R?.type !== "cancelation" && console.error("Monaco initialization: error:", R)), ()=>o.current ? pe() : p.cancel();
|
|
}), l(()=>{
|
|
let p = h(d.current, e || t || "", r || a || "", m || n || "");
|
|
p !== o.current?.getModel() && (y && _.set(f, o.current?.saveViewState()), o.current?.setModel(p), y && o.current?.restoreViewState(_.get(m)));
|
|
}, [
|
|
m
|
|
], s), l(()=>{
|
|
o.current?.updateOptions(x);
|
|
}, [
|
|
x
|
|
], s), l(()=>{
|
|
!o.current || t === void 0 || (o.current.getOption(d.current.editor.EditorOption.readOnly) ? o.current.setValue(t) : t !== o.current.getValue() && (B.current = !0, o.current.executeEdits("", [
|
|
{
|
|
range: o.current.getModel().getFullModelRange(),
|
|
text: t,
|
|
forceMoveMarkers: !0
|
|
}
|
|
]), o.current.pushUndoStop(), B.current = !1));
|
|
}, [
|
|
t
|
|
], s), l(()=>{
|
|
let p = o.current?.getModel();
|
|
p && a && d.current?.editor.setModelLanguage(p, a);
|
|
}, [
|
|
a
|
|
], s), l(()=>{
|
|
g !== void 0 && o.current?.revealLine(g);
|
|
}, [
|
|
g
|
|
], s), l(()=>{
|
|
d.current?.editor.setTheme(E);
|
|
}, [
|
|
E
|
|
], s);
|
|
let X = (0, _react.useCallback)(()=>{
|
|
if (!(!b.current || !d.current) && !Q.current) {
|
|
U.current(d.current);
|
|
let p = m || n, R = h(d.current, t || e || "", r || a || "", p || "");
|
|
o.current = d.current?.editor.create(b.current, {
|
|
model: R,
|
|
automaticLayout: !0,
|
|
...x
|
|
}, P), y && o.current.restoreViewState(_.get(p)), d.current.editor.setTheme(E), g !== void 0 && o.current.revealLine(g), u(!0), Q.current = !0;
|
|
}
|
|
}, [
|
|
e,
|
|
r,
|
|
n,
|
|
t,
|
|
a,
|
|
m,
|
|
x,
|
|
P,
|
|
y,
|
|
E,
|
|
g
|
|
]);
|
|
(0, _react.useEffect)(()=>{
|
|
s && L.current(o.current, d.current);
|
|
}, [
|
|
s
|
|
]), (0, _react.useEffect)(()=>{
|
|
!c && !s && X();
|
|
}, [
|
|
c,
|
|
s,
|
|
X
|
|
]), i.current = t, (0, _react.useEffect)(()=>{
|
|
s && O && (I.current?.dispose(), I.current = o.current?.onDidChangeModelContent((p)=>{
|
|
B.current || O(o.current.getValue(), p);
|
|
}));
|
|
}, [
|
|
s,
|
|
O
|
|
]), (0, _react.useEffect)(()=>{
|
|
if (s) {
|
|
let p = d.current.editor.onDidChangeMarkers((R)=>{
|
|
let G = o.current.getModel()?.uri;
|
|
if (G && R.find((J)=>J.path === G.path)) {
|
|
let J = d.current.editor.getModelMarkers({
|
|
resource: G
|
|
});
|
|
T?.(J);
|
|
}
|
|
});
|
|
return ()=>{
|
|
p?.dispose();
|
|
};
|
|
}
|
|
return ()=>{};
|
|
}, [
|
|
s,
|
|
T
|
|
]);
|
|
function pe() {
|
|
I.current?.dispose(), V ? y && _.set(m, o.current.saveViewState()) : o.current.getModel()?.dispose(), o.current.dispose();
|
|
}
|
|
return (0, _reactDefault.default).createElement(H, {
|
|
width: z,
|
|
height: F,
|
|
isEditorReady: s,
|
|
loading: N,
|
|
_ref: b,
|
|
className: j,
|
|
wrapperProps: A
|
|
});
|
|
}
|
|
var fe = Ve;
|
|
var de = (0, _react.memo)(fe);
|
|
var Ft = de;
|
|
|
|
},{"@monaco-editor/loader":"9AKKa","react":"ftK02","@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"9AKKa":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "default", ()=>(0, _indexJsDefault.default));
|
|
var _indexJs = require("./loader/index.js");
|
|
var _indexJsDefault = parcelHelpers.interopDefault(_indexJs);
|
|
|
|
},{"./loader/index.js":"eem3i","@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"eem3i":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
var _rollupPluginBabelHelpersJs = require("../_virtual/_rollupPluginBabelHelpers.js");
|
|
var _stateLocal = require("state-local");
|
|
var _stateLocalDefault = parcelHelpers.interopDefault(_stateLocal);
|
|
var _indexJs = require("../config/index.js");
|
|
var _indexJsDefault = parcelHelpers.interopDefault(_indexJs);
|
|
var _indexJs1 = require("../validators/index.js");
|
|
var _indexJsDefault1 = parcelHelpers.interopDefault(_indexJs1);
|
|
var _composeJs = require("../utils/compose.js");
|
|
var _composeJsDefault = parcelHelpers.interopDefault(_composeJs);
|
|
var _deepMergeJs = require("../utils/deepMerge.js");
|
|
var _deepMergeJsDefault = parcelHelpers.interopDefault(_deepMergeJs);
|
|
var _makeCancelableJs = require("../utils/makeCancelable.js");
|
|
var _makeCancelableJsDefault = parcelHelpers.interopDefault(_makeCancelableJs);
|
|
/** the local state of the module */ var _state$create = (0, _stateLocalDefault.default).create({
|
|
config: (0, _indexJsDefault.default),
|
|
isInitialized: false,
|
|
resolve: null,
|
|
reject: null,
|
|
monaco: null
|
|
}), _state$create2 = (0, _rollupPluginBabelHelpersJs.slicedToArray)(_state$create, 2), getState = _state$create2[0], setState = _state$create2[1];
|
|
/**
|
|
* set the loader configuration
|
|
* @param {Object} config - the configuration object
|
|
*/ function config(globalConfig) {
|
|
var _validators$config = (0, _indexJsDefault1.default).config(globalConfig), monaco = _validators$config.monaco, config = (0, _rollupPluginBabelHelpersJs.objectWithoutProperties)(_validators$config, [
|
|
"monaco"
|
|
]);
|
|
setState(function(state) {
|
|
return {
|
|
config: (0, _deepMergeJsDefault.default)(state.config, config),
|
|
monaco: monaco
|
|
};
|
|
});
|
|
}
|
|
/**
|
|
* handles the initialization of the monaco-editor
|
|
* @return {Promise} - returns an instance of monaco (with a cancelable promise)
|
|
*/ function init() {
|
|
var state = getState(function(_ref) {
|
|
var monaco = _ref.monaco, isInitialized = _ref.isInitialized, resolve = _ref.resolve;
|
|
return {
|
|
monaco: monaco,
|
|
isInitialized: isInitialized,
|
|
resolve: resolve
|
|
};
|
|
});
|
|
if (!state.isInitialized) {
|
|
setState({
|
|
isInitialized: true
|
|
});
|
|
if (state.monaco) {
|
|
state.resolve(state.monaco);
|
|
return (0, _makeCancelableJsDefault.default)(wrapperPromise);
|
|
}
|
|
if (window.monaco && window.monaco.editor) {
|
|
storeMonacoInstance(window.monaco);
|
|
state.resolve(window.monaco);
|
|
return (0, _makeCancelableJsDefault.default)(wrapperPromise);
|
|
}
|
|
(0, _composeJsDefault.default)(injectScripts, getMonacoLoaderScript)(configureLoader);
|
|
}
|
|
return (0, _makeCancelableJsDefault.default)(wrapperPromise);
|
|
}
|
|
/**
|
|
* injects provided scripts into the document.body
|
|
* @param {Object} script - an HTML script element
|
|
* @return {Object} - the injected HTML script element
|
|
*/ function injectScripts(script) {
|
|
return document.body.appendChild(script);
|
|
}
|
|
/**
|
|
* creates an HTML script element with/without provided src
|
|
* @param {string} [src] - the source path of the script
|
|
* @return {Object} - the created HTML script element
|
|
*/ function createScript(src) {
|
|
var script = document.createElement("script");
|
|
return src && (script.src = src), script;
|
|
}
|
|
/**
|
|
* creates an HTML script element with the monaco loader src
|
|
* @return {Object} - the created HTML script element
|
|
*/ function getMonacoLoaderScript(configureLoader) {
|
|
var state = getState(function(_ref2) {
|
|
var config = _ref2.config, reject = _ref2.reject;
|
|
return {
|
|
config: config,
|
|
reject: reject
|
|
};
|
|
});
|
|
var loaderScript = createScript("".concat(state.config.paths.vs, "/loader.js"));
|
|
loaderScript.onload = function() {
|
|
return configureLoader();
|
|
};
|
|
loaderScript.onerror = state.reject;
|
|
return loaderScript;
|
|
}
|
|
/**
|
|
* configures the monaco loader
|
|
*/ function configureLoader() {
|
|
var state = getState(function(_ref3) {
|
|
var config = _ref3.config, resolve = _ref3.resolve, reject = _ref3.reject;
|
|
return {
|
|
config: config,
|
|
resolve: resolve,
|
|
reject: reject
|
|
};
|
|
});
|
|
var require1 = window.require;
|
|
require1.config(state.config);
|
|
require1([
|
|
"vs/editor/editor.main"
|
|
], function(monaco) {
|
|
storeMonacoInstance(monaco);
|
|
state.resolve(monaco);
|
|
}, function(error) {
|
|
state.reject(error);
|
|
});
|
|
}
|
|
/**
|
|
* store monaco instance in local state
|
|
*/ function storeMonacoInstance(monaco) {
|
|
if (!getState().monaco) setState({
|
|
monaco: monaco
|
|
});
|
|
}
|
|
/**
|
|
* internal helper function
|
|
* extracts stored monaco instance
|
|
* @return {Object|null} - the monaco instance
|
|
*/ function __getMonacoInstance() {
|
|
return getState(function(_ref4) {
|
|
var monaco = _ref4.monaco;
|
|
return monaco;
|
|
});
|
|
}
|
|
var wrapperPromise = new Promise(function(resolve, reject) {
|
|
return setState({
|
|
resolve: resolve,
|
|
reject: reject
|
|
});
|
|
});
|
|
var loader = {
|
|
config: config,
|
|
init: init,
|
|
__getMonacoInstance: __getMonacoInstance
|
|
};
|
|
exports.default = loader;
|
|
|
|
},{"../_virtual/_rollupPluginBabelHelpers.js":"2IW10","state-local":"hhsp8","../config/index.js":"kZ5PH","../validators/index.js":"73nBP","../utils/compose.js":"erSDU","../utils/deepMerge.js":"1ZqPg","../utils/makeCancelable.js":"2Q7H4","@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"2IW10":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "arrayLikeToArray", ()=>_arrayLikeToArray);
|
|
parcelHelpers.export(exports, "arrayWithHoles", ()=>_arrayWithHoles);
|
|
parcelHelpers.export(exports, "defineProperty", ()=>_defineProperty);
|
|
parcelHelpers.export(exports, "iterableToArrayLimit", ()=>_iterableToArrayLimit);
|
|
parcelHelpers.export(exports, "nonIterableRest", ()=>_nonIterableRest);
|
|
parcelHelpers.export(exports, "objectSpread2", ()=>_objectSpread2);
|
|
parcelHelpers.export(exports, "objectWithoutProperties", ()=>_objectWithoutProperties);
|
|
parcelHelpers.export(exports, "objectWithoutPropertiesLoose", ()=>_objectWithoutPropertiesLoose);
|
|
parcelHelpers.export(exports, "slicedToArray", ()=>_slicedToArray);
|
|
parcelHelpers.export(exports, "unsupportedIterableToArray", ()=>_unsupportedIterableToArray);
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
else obj[key] = value;
|
|
return obj;
|
|
}
|
|
function ownKeys(object, enumerableOnly) {
|
|
var keys = Object.keys(object);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(object);
|
|
if (enumerableOnly) symbols = symbols.filter(function(sym) {
|
|
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
});
|
|
keys.push.apply(keys, symbols);
|
|
}
|
|
return keys;
|
|
}
|
|
function _objectSpread2(target) {
|
|
for(var i = 1; i < arguments.length; i++){
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
if (i % 2) ownKeys(Object(source), true).forEach(function(key) {
|
|
_defineProperty(target, key, source[key]);
|
|
});
|
|
else if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
|
else ownKeys(Object(source)).forEach(function(key) {
|
|
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
function _objectWithoutPropertiesLoose(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = {};
|
|
var sourceKeys = Object.keys(source);
|
|
var key, i;
|
|
for(i = 0; i < sourceKeys.length; i++){
|
|
key = sourceKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
target[key] = source[key];
|
|
}
|
|
return target;
|
|
}
|
|
function _objectWithoutProperties(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = _objectWithoutPropertiesLoose(source, excluded);
|
|
var key, i;
|
|
if (Object.getOwnPropertySymbols) {
|
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
|
for(i = 0; i < sourceSymbolKeys.length; i++){
|
|
key = sourceSymbolKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
function _slicedToArray(arr, i) {
|
|
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
|
|
}
|
|
function _arrayWithHoles(arr) {
|
|
if (Array.isArray(arr)) return arr;
|
|
}
|
|
function _iterableToArrayLimit(arr, i) {
|
|
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
|
|
var _arr = [];
|
|
var _n = true;
|
|
var _d = false;
|
|
var _e = undefined;
|
|
try {
|
|
for(var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true){
|
|
_arr.push(_s.value);
|
|
if (i && _arr.length === i) break;
|
|
}
|
|
} catch (err) {
|
|
_d = true;
|
|
_e = err;
|
|
} finally{
|
|
try {
|
|
if (!_n && _i["return"] != null) _i["return"]();
|
|
} finally{
|
|
if (_d) throw _e;
|
|
}
|
|
}
|
|
return _arr;
|
|
}
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
if (n === "Map" || n === "Set") return Array.from(o);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
|
}
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length) len = arr.length;
|
|
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
|
|
return arr2;
|
|
}
|
|
function _nonIterableRest() {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"hhsp8":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
else obj[key] = value;
|
|
return obj;
|
|
}
|
|
function ownKeys(object, enumerableOnly) {
|
|
var keys = Object.keys(object);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(object);
|
|
if (enumerableOnly) symbols = symbols.filter(function(sym) {
|
|
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
});
|
|
keys.push.apply(keys, symbols);
|
|
}
|
|
return keys;
|
|
}
|
|
function _objectSpread2(target) {
|
|
for(var i = 1; i < arguments.length; i++){
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
if (i % 2) ownKeys(Object(source), true).forEach(function(key) {
|
|
_defineProperty(target, key, source[key]);
|
|
});
|
|
else if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
|
else ownKeys(Object(source)).forEach(function(key) {
|
|
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
function compose() {
|
|
for(var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++)fns[_key] = arguments[_key];
|
|
return function(x) {
|
|
return fns.reduceRight(function(y, f) {
|
|
return f(y);
|
|
}, x);
|
|
};
|
|
}
|
|
function curry(fn) {
|
|
return function curried() {
|
|
var _this = this;
|
|
for(var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++)args[_key2] = arguments[_key2];
|
|
return args.length >= fn.length ? fn.apply(this, args) : function() {
|
|
for(var _len3 = arguments.length, nextArgs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++)nextArgs[_key3] = arguments[_key3];
|
|
return curried.apply(_this, [].concat(args, nextArgs));
|
|
};
|
|
};
|
|
}
|
|
function isObject(value) {
|
|
return ({}).toString.call(value).includes("Object");
|
|
}
|
|
function isEmpty(obj) {
|
|
return !Object.keys(obj).length;
|
|
}
|
|
function isFunction(value) {
|
|
return typeof value === "function";
|
|
}
|
|
function hasOwnProperty(object, property) {
|
|
return Object.prototype.hasOwnProperty.call(object, property);
|
|
}
|
|
function validateChanges(initial, changes) {
|
|
if (!isObject(changes)) errorHandler("changeType");
|
|
if (Object.keys(changes).some(function(field) {
|
|
return !hasOwnProperty(initial, field);
|
|
})) errorHandler("changeField");
|
|
return changes;
|
|
}
|
|
function validateSelector(selector) {
|
|
if (!isFunction(selector)) errorHandler("selectorType");
|
|
}
|
|
function validateHandler(handler) {
|
|
if (!(isFunction(handler) || isObject(handler))) errorHandler("handlerType");
|
|
if (isObject(handler) && Object.values(handler).some(function(_handler) {
|
|
return !isFunction(_handler);
|
|
})) errorHandler("handlersType");
|
|
}
|
|
function validateInitial(initial) {
|
|
if (!initial) errorHandler("initialIsRequired");
|
|
if (!isObject(initial)) errorHandler("initialType");
|
|
if (isEmpty(initial)) errorHandler("initialContent");
|
|
}
|
|
function throwError(errorMessages, type) {
|
|
throw new Error(errorMessages[type] || errorMessages["default"]);
|
|
}
|
|
var errorMessages = {
|
|
initialIsRequired: "initial state is required",
|
|
initialType: "initial state should be an object",
|
|
initialContent: "initial state shouldn't be an empty object",
|
|
handlerType: "handler should be an object or a function",
|
|
handlersType: "all handlers should be a functions",
|
|
selectorType: "selector should be a function",
|
|
changeType: "provided value of changes should be an object",
|
|
changeField: 'it seams you want to change a field in the state which is not specified in the "initial" state',
|
|
"default": "an unknown error accured in `state-local` package"
|
|
};
|
|
var errorHandler = curry(throwError)(errorMessages);
|
|
var validators = {
|
|
changes: validateChanges,
|
|
selector: validateSelector,
|
|
handler: validateHandler,
|
|
initial: validateInitial
|
|
};
|
|
function create(initial) {
|
|
var handler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
validators.initial(initial);
|
|
validators.handler(handler);
|
|
var state = {
|
|
current: initial
|
|
};
|
|
var didUpdate = curry(didStateUpdate)(state, handler);
|
|
var update = curry(updateState)(state);
|
|
var validate = curry(validators.changes)(initial);
|
|
var getChanges = curry(extractChanges)(state);
|
|
function getState() {
|
|
var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function(state) {
|
|
return state;
|
|
};
|
|
validators.selector(selector);
|
|
return selector(state.current);
|
|
}
|
|
function setState(causedChanges) {
|
|
compose(didUpdate, update, validate, getChanges)(causedChanges);
|
|
}
|
|
return [
|
|
getState,
|
|
setState
|
|
];
|
|
}
|
|
function extractChanges(state, causedChanges) {
|
|
return isFunction(causedChanges) ? causedChanges(state.current) : causedChanges;
|
|
}
|
|
function updateState(state, changes) {
|
|
state.current = _objectSpread2(_objectSpread2({}, state.current), changes);
|
|
return changes;
|
|
}
|
|
function didStateUpdate(state, handler, changes) {
|
|
isFunction(handler) ? handler(state.current) : Object.keys(changes).forEach(function(field) {
|
|
var _handler$field;
|
|
return (_handler$field = handler[field]) === null || _handler$field === void 0 ? void 0 : _handler$field.call(handler, state.current[field]);
|
|
});
|
|
return changes;
|
|
}
|
|
var index = {
|
|
create: create
|
|
};
|
|
exports.default = index;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"kZ5PH":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
var config = {
|
|
paths: {
|
|
vs: "https://cdn.jsdelivr.net/npm/monaco-editor@0.43.0/min/vs"
|
|
}
|
|
};
|
|
exports.default = config;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"73nBP":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "errorHandler", ()=>errorHandler);
|
|
parcelHelpers.export(exports, "errorMessages", ()=>errorMessages);
|
|
var _curryJs = require("../utils/curry.js");
|
|
var _curryJsDefault = parcelHelpers.interopDefault(_curryJs);
|
|
var _isObjectJs = require("../utils/isObject.js");
|
|
var _isObjectJsDefault = parcelHelpers.interopDefault(_isObjectJs);
|
|
/**
|
|
* validates the configuration object and informs about deprecation
|
|
* @param {Object} config - the configuration object
|
|
* @return {Object} config - the validated configuration object
|
|
*/ function validateConfig(config) {
|
|
if (!config) errorHandler("configIsRequired");
|
|
if (!(0, _isObjectJsDefault.default)(config)) errorHandler("configType");
|
|
if (config.urls) {
|
|
informAboutDeprecation();
|
|
return {
|
|
paths: {
|
|
vs: config.urls.monacoBase
|
|
}
|
|
};
|
|
}
|
|
return config;
|
|
}
|
|
/**
|
|
* logs deprecation message
|
|
*/ function informAboutDeprecation() {
|
|
console.warn(errorMessages.deprecation);
|
|
}
|
|
function throwError(errorMessages, type) {
|
|
throw new Error(errorMessages[type] || errorMessages["default"]);
|
|
}
|
|
var errorMessages = {
|
|
configIsRequired: "the configuration object is required",
|
|
configType: "the configuration object should be an object",
|
|
"default": "an unknown error accured in `@monaco-editor/loader` package",
|
|
deprecation: "Deprecation warning!\n You are using deprecated way of configuration.\n\n Instead of using\n monaco.config({ urls: { monacoBase: '...' } })\n use\n monaco.config({ paths: { vs: '...' } })\n\n For more please check the link https://github.com/suren-atoyan/monaco-loader#config\n "
|
|
};
|
|
var errorHandler = (0, _curryJsDefault.default)(throwError)(errorMessages);
|
|
var validators = {
|
|
config: validateConfig
|
|
};
|
|
exports.default = validators;
|
|
|
|
},{"../utils/curry.js":"hP1Ue","../utils/isObject.js":"5OC1Y","@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"hP1Ue":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
function curry(fn) {
|
|
return function curried() {
|
|
var _this = this;
|
|
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)args[_key] = arguments[_key];
|
|
return args.length >= fn.length ? fn.apply(this, args) : function() {
|
|
for(var _len2 = arguments.length, nextArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++)nextArgs[_key2] = arguments[_key2];
|
|
return curried.apply(_this, [].concat(args, nextArgs));
|
|
};
|
|
};
|
|
}
|
|
exports.default = curry;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"5OC1Y":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
function isObject(value) {
|
|
return ({}).toString.call(value).includes("Object");
|
|
}
|
|
exports.default = isObject;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"erSDU":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
var compose = function compose() {
|
|
for(var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++)fns[_key] = arguments[_key];
|
|
return function(x) {
|
|
return fns.reduceRight(function(y, f) {
|
|
return f(y);
|
|
}, x);
|
|
};
|
|
};
|
|
exports.default = compose;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"1ZqPg":[function(require,module,exports) {
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
var _rollupPluginBabelHelpersJs = require("../_virtual/_rollupPluginBabelHelpers.js");
|
|
function merge(target, source) {
|
|
Object.keys(source).forEach(function(key) {
|
|
if (source[key] instanceof Object) {
|
|
if (target[key]) Object.assign(source[key], merge(target[key], source[key]));
|
|
}
|
|
});
|
|
return (0, _rollupPluginBabelHelpersJs.objectSpread2)((0, _rollupPluginBabelHelpersJs.objectSpread2)({}, target), source);
|
|
}
|
|
exports.default = merge;
|
|
|
|
},{"../_virtual/_rollupPluginBabelHelpers.js":"2IW10","@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}],"2Q7H4":[function(require,module,exports) {
|
|
// The source (has been changed) is https://github.com/facebook/react/issues/5465#issuecomment-157888325
|
|
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
|
parcelHelpers.defineInteropFlag(exports);
|
|
parcelHelpers.export(exports, "CANCELATION_MESSAGE", ()=>CANCELATION_MESSAGE);
|
|
var CANCELATION_MESSAGE = {
|
|
type: "cancelation",
|
|
msg: "operation is manually canceled"
|
|
};
|
|
function makeCancelable(promise) {
|
|
var hasCanceled_ = false;
|
|
var wrappedPromise = new Promise(function(resolve, reject) {
|
|
promise.then(function(val) {
|
|
return hasCanceled_ ? reject(CANCELATION_MESSAGE) : resolve(val);
|
|
});
|
|
promise["catch"](reject);
|
|
});
|
|
return wrappedPromise.cancel = function() {
|
|
return hasCanceled_ = true;
|
|
}, wrappedPromise;
|
|
}
|
|
exports.default = makeCancelable;
|
|
|
|
},{"@parcel/transformer-js/src/esmodule-helpers.js":"lwmMb"}]},[], null, "parcelRequire2d1f")
|
|
|
|
//# sourceMappingURL=dist.1f9430ff.js.map
|