vite-plugin-inspect
Version:
Inspect the intermediate state of Vite plugins
1,102 lines (1,013 loc) • 782 kB
JavaScript
import { _ as _sfc_main$4, e as _sfc_main$5, a as __unplugin_components_3, b as _sfc_main$7, d as _sfc_main$9 } from './QuerySelector.vue_vue_type_script_setup_true_lang-DZag_XE-.js';
import { A as h, c as createElementBlock, o as openBlock, R as renderSlot, n as normalizeStyle, w as watch, d as defineComponent, D as toRefs, T as useTemplateRef, f as onMounted, G as watchEffect, I as nextTick, e as computed, x as createBlock, h as unref, q as withCtx, k as withDirectives, i as createVNode, U as vShow, a as createBaseVNode, g as createCommentVNode, t as toDisplayString, z as createTextVNode, F as Fragment, r as renderList, p as useRoute, u as useRouter, V as tryOnScopeDispose, W as customRef, X as toValue, m as usePayloadStore, b as ref, L as withAsyncContext, O as onModuleUpdated, P as isStaticMode, M as rpc, s as resolveComponent, j as normalizeClass } from './index-BHfFAmtB.js';
import { u as useOptionsStore, _ as _sfc_main$a } from './options-CljnBO7w.js';
import { a as _sfc_main$6, k as kt, _ as _sfc_main$8 } from './ModuleList.vue_vue_type_script_setup_true_lang-CswcXVt4.js';
import { g as getHot } from './hot-CPekYFok.js';
import './_plugin-vue_export-helper-DgDhiqFL.js';
function guessMode(code) {
if (code.trimStart().startsWith("<"))
return "htmlmixed";
if (code.match(/^import\s/))
return "javascript";
if (code.match(/^[.#].+\{/))
return "css";
return "javascript";
}
function inspectSourcemaps({ code, sourcemaps }) {
console.info("sourcemaps", JSON.stringify(sourcemaps, null, 2));
const serialized = serializeForSourcemapsVisualizer(code, sourcemaps);
window.open(`https://evanw.github.io/source-map-visualization#${serialized}`, "_blank");
}
function safeJsonParse(str) {
try {
return JSON.parse(str);
} catch {
console.error("Failed to parse JSON", str);
return null;
}
}
function serializeForSourcemapsVisualizer(code, map) {
const encoder = new TextEncoder();
const codeArray = encoder.encode(code);
const mapArray = encoder.encode(map);
const codeLengthArray = encoder.encode(codeArray.length.toString());
const mapLengthArray = encoder.encode(mapArray.length.toString());
const combinedArray = new Uint8Array(codeLengthArray.length + 1 + codeArray.length + mapLengthArray.length + 1 + mapArray.length);
combinedArray.set(codeLengthArray);
combinedArray.set([0], codeLengthArray.length);
combinedArray.set(codeArray, codeLengthArray.length + 1);
combinedArray.set(mapLengthArray, codeLengthArray.length + 1 + codeArray.length);
combinedArray.set([0], codeLengthArray.length + 1 + codeArray.length + mapLengthArray.length);
combinedArray.set(mapArray, codeLengthArray.length + 1 + codeArray.length + mapLengthArray.length + 1);
let binary = "";
const len = combinedArray.byteLength;
for (let i = 0; i < len; i++)
binary += String.fromCharCode(combinedArray[i]);
return btoa(binary);
}
/* Injected with object hook! */
const M = {
// eslint-disable-next-line vue/multi-word-component-names
name: "splitpanes",
emits: ["ready", "resize", "resized", "pane-click", "pane-maximize", "pane-add", "pane-remove", "splitter-click"],
props: {
horizontal: { type: Boolean },
pushOtherPanes: { type: Boolean, default: true },
dblClickSplitter: { type: Boolean, default: true },
rtl: { type: Boolean, default: false },
// Right to left direction.
firstSplitter: { type: Boolean }
},
provide() {
return {
requestUpdate: this.requestUpdate,
onPaneAdd: this.onPaneAdd,
onPaneRemove: this.onPaneRemove,
onPaneClick: this.onPaneClick
};
},
data: () => ({
container: null,
ready: false,
panes: [],
touch: {
mouseDown: false,
dragging: false,
activeSplitter: null
},
splitterTaps: {
// Used to detect double click on touch devices.
splitter: null,
timeoutId: null
}
}),
computed: {
panesCount() {
return this.panes.length;
},
// Indexed panes by `uid` of Pane components for fast lookup.
// Every time a pane is destroyed this index is recomputed.
indexedPanes() {
return this.panes.reduce((e, i) => (e[i.id] = i) && e, {});
}
},
methods: {
updatePaneComponents() {
this.panes.forEach((e) => {
e.update && e.update({
// Panes are indexed by Pane component uid, as they might be inserted at different index.
[this.horizontal ? "height" : "width"]: `${this.indexedPanes[e.id].size}%`
});
});
},
bindEvents() {
document.addEventListener("mousemove", this.onMouseMove, { passive: false }), document.addEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.addEventListener("touchmove", this.onMouseMove, { passive: false }), document.addEventListener("touchend", this.onMouseUp));
},
unbindEvents() {
document.removeEventListener("mousemove", this.onMouseMove, { passive: false }), document.removeEventListener("mouseup", this.onMouseUp), "ontouchstart" in window && (document.removeEventListener("touchmove", this.onMouseMove, { passive: false }), document.removeEventListener("touchend", this.onMouseUp));
},
onMouseDown(e, i) {
this.bindEvents(), this.touch.mouseDown = true, this.touch.activeSplitter = i;
},
onMouseMove(e) {
this.touch.mouseDown && (e.preventDefault(), this.touch.dragging = true, this.calculatePanesSize(this.getCurrentMouseDrag(e)), this.$emit("resize", this.panes.map((i) => ({ min: i.min, max: i.max, size: i.size }))));
},
onMouseUp() {
this.touch.dragging && this.$emit("resized", this.panes.map((e) => ({ min: e.min, max: e.max, size: e.size }))), this.touch.mouseDown = false, setTimeout(() => {
this.touch.dragging = false, this.unbindEvents();
}, 100);
},
// If touch device, detect double tap manually (2 taps separated by less than 500ms).
onSplitterClick(e, i) {
"ontouchstart" in window && (e.preventDefault(), this.dblClickSplitter && (this.splitterTaps.splitter === i ? (clearTimeout(this.splitterTaps.timeoutId), this.splitterTaps.timeoutId = null, this.onSplitterDblClick(e, i), this.splitterTaps.splitter = null) : (this.splitterTaps.splitter = i, this.splitterTaps.timeoutId = setTimeout(() => {
this.splitterTaps.splitter = null;
}, 500)))), this.touch.dragging || this.$emit("splitter-click", this.panes[i]);
},
// On splitter dbl click or dbl tap maximize this pane.
onSplitterDblClick(e, i) {
let s = 0;
this.panes = this.panes.map((n, t) => (n.size = t === i ? n.max : n.min, t !== i && (s += n.min), n)), this.panes[i].size -= s, this.$emit("pane-maximize", this.panes[i]), this.$emit("resized", this.panes.map((n) => ({ min: n.min, max: n.max, size: n.size })));
},
onPaneClick(e, i) {
this.$emit("pane-click", this.indexedPanes[i]);
},
// Get the cursor position relative to the splitpane container.
getCurrentMouseDrag(e) {
const i = this.container.getBoundingClientRect(), { clientX: s, clientY: n } = "ontouchstart" in window && e.touches ? e.touches[0] : e;
return {
x: s - i.left,
y: n - i.top
};
},
// Returns the drag percentage of the splitter relative to the container (ranging from 0 to 100%).
getCurrentDragPercentage(e) {
e = e[this.horizontal ? "y" : "x"];
const i = this.container[this.horizontal ? "clientHeight" : "clientWidth"];
return this.rtl && !this.horizontal && (e = i - e), e * 100 / i;
},
calculatePanesSize(e) {
const i = this.touch.activeSplitter;
let s = {
prevPanesSize: this.sumPrevPanesSize(i),
nextPanesSize: this.sumNextPanesSize(i),
prevReachedMinPanes: 0,
nextReachedMinPanes: 0
};
const n = 0 + (this.pushOtherPanes ? 0 : s.prevPanesSize), t = 100 - (this.pushOtherPanes ? 0 : s.nextPanesSize), a = Math.max(Math.min(this.getCurrentDragPercentage(e), t), n);
let r = [i, i + 1], o = this.panes[r[0]] || null, h = this.panes[r[1]] || null;
const l = o.max < 100 && a >= o.max + s.prevPanesSize, u = h.max < 100 && a <= 100 - (h.max + this.sumNextPanesSize(i + 1));
if (l || u) {
l ? (o.size = o.max, h.size = Math.max(100 - o.max - s.prevPanesSize - s.nextPanesSize, 0)) : (o.size = Math.max(100 - h.max - s.prevPanesSize - this.sumNextPanesSize(i + 1), 0), h.size = h.max);
return;
}
if (this.pushOtherPanes) {
const d = this.doPushOtherPanes(s, a);
if (!d) return;
(({ sums: s, panesToResize: r } = d)), o = this.panes[r[0]] || null, h = this.panes[r[1]] || null;
}
o !== null && (o.size = Math.min(Math.max(a - s.prevPanesSize - s.prevReachedMinPanes, o.min), o.max)), h !== null && (h.size = Math.min(Math.max(100 - a - s.nextPanesSize - s.nextReachedMinPanes, h.min), h.max));
},
doPushOtherPanes(e, i) {
const s = this.touch.activeSplitter, n = [s, s + 1];
return i < e.prevPanesSize + this.panes[n[0]].min && (n[0] = this.findPrevExpandedPane(s).index, e.prevReachedMinPanes = 0, n[0] < s && this.panes.forEach((t, a) => {
a > n[0] && a <= s && (t.size = t.min, e.prevReachedMinPanes += t.min);
}), e.prevPanesSize = this.sumPrevPanesSize(n[0]), n[0] === void 0) ? (e.prevReachedMinPanes = 0, this.panes[0].size = this.panes[0].min, this.panes.forEach((t, a) => {
a > 0 && a <= s && (t.size = t.min, e.prevReachedMinPanes += t.min);
}), this.panes[n[1]].size = 100 - e.prevReachedMinPanes - this.panes[0].min - e.prevPanesSize - e.nextPanesSize, null) : i > 100 - e.nextPanesSize - this.panes[n[1]].min && (n[1] = this.findNextExpandedPane(s).index, e.nextReachedMinPanes = 0, n[1] > s + 1 && this.panes.forEach((t, a) => {
a > s && a < n[1] && (t.size = t.min, e.nextReachedMinPanes += t.min);
}), e.nextPanesSize = this.sumNextPanesSize(n[1] - 1), n[1] === void 0) ? (e.nextReachedMinPanes = 0, this.panes[this.panesCount - 1].size = this.panes[this.panesCount - 1].min, this.panes.forEach((t, a) => {
a < this.panesCount - 1 && a >= s + 1 && (t.size = t.min, e.nextReachedMinPanes += t.min);
}), this.panes[n[0]].size = 100 - e.prevPanesSize - e.nextReachedMinPanes - this.panes[this.panesCount - 1].min - e.nextPanesSize, null) : { sums: e, panesToResize: n };
},
sumPrevPanesSize(e) {
return this.panes.reduce((i, s, n) => i + (n < e ? s.size : 0), 0);
},
sumNextPanesSize(e) {
return this.panes.reduce((i, s, n) => i + (n > e + 1 ? s.size : 0), 0);
},
// Return the previous pane from siblings which has a size (width for vert or height for horz) of more than 0.
findPrevExpandedPane(e) {
return [...this.panes].reverse().find((s) => s.index < e && s.size > s.min) || {};
},
// Return the next pane from siblings which has a size (width for vert or height for horz) of more than 0.
findNextExpandedPane(e) {
return this.panes.find((s) => s.index > e + 1 && s.size > s.min) || {};
},
checkSplitpanesNodes() {
Array.from(this.container.children).forEach((i) => {
const s = i.classList.contains("splitpanes__pane"), n = i.classList.contains("splitpanes__splitter");
!s && !n && (i.parentNode.removeChild(i), console.warn("Splitpanes: Only <pane> elements are allowed at the root of <splitpanes>. One of your DOM nodes was removed."));
});
},
addSplitter(e, i, s = false) {
const n = e - 1, t = document.createElement("div");
t.classList.add("splitpanes__splitter"), s || (t.onmousedown = (a) => this.onMouseDown(a, n), typeof window < "u" && "ontouchstart" in window && (t.ontouchstart = (a) => this.onMouseDown(a, n)), t.onclick = (a) => this.onSplitterClick(a, n + 1)), this.dblClickSplitter && (t.ondblclick = (a) => this.onSplitterDblClick(a, n + 1)), i.parentNode.insertBefore(t, i);
},
removeSplitter(e) {
e.onmousedown = void 0, e.onclick = void 0, e.ondblclick = void 0, e.parentNode.removeChild(e);
},
redoSplitters() {
const e = Array.from(this.container.children);
e.forEach((s) => {
s.className.includes("splitpanes__splitter") && this.removeSplitter(s);
});
let i = 0;
e.forEach((s) => {
s.className.includes("splitpanes__pane") && (!i && this.firstSplitter ? this.addSplitter(i, s, true) : i && this.addSplitter(i, s), i++);
});
},
// Called by Pane component on programmatic resize.
requestUpdate({ target: e, ...i }) {
const s = this.indexedPanes[e._.uid];
Object.entries(i).forEach(([n, t]) => s[n] = t);
},
onPaneAdd(e) {
let i = -1;
Array.from(e.$el.parentNode.children).some((t) => (t.className.includes("splitpanes__pane") && i++, t === e.$el));
const s = parseFloat(e.minSize), n = parseFloat(e.maxSize);
this.panes.splice(i, 0, {
id: e._.uid,
index: i,
min: isNaN(s) ? 0 : s,
max: isNaN(n) ? 100 : n,
size: e.size === null ? null : parseFloat(e.size),
givenSize: e.size,
update: e.update
}), this.panes.forEach((t, a) => t.index = a), this.ready && this.$nextTick(() => {
this.redoSplitters(), this.resetPaneSizes({ addedPane: this.panes[i] }), this.$emit("pane-add", { index: i, panes: this.panes.map((t) => ({ min: t.min, max: t.max, size: t.size })) });
});
},
onPaneRemove(e) {
const i = this.panes.findIndex((n) => n.id === e._.uid), s = this.panes.splice(i, 1)[0];
this.panes.forEach((n, t) => n.index = t), this.$nextTick(() => {
this.redoSplitters(), this.resetPaneSizes({ removedPane: { ...s, index: i } }), this.$emit("pane-remove", { removed: s, panes: this.panes.map((n) => ({ min: n.min, max: n.max, size: n.size })) });
});
},
resetPaneSizes(e = {}) {
!e.addedPane && !e.removedPane ? this.initialPanesSizing() : this.panes.some((i) => i.givenSize !== null || i.min || i.max < 100) ? this.equalizeAfterAddOrRemove(e) : this.equalize(), this.ready && this.$emit("resized", this.panes.map((i) => ({ min: i.min, max: i.max, size: i.size })));
},
equalize() {
const e = 100 / this.panesCount;
let i = 0;
const s = [], n = [];
this.panes.forEach((t) => {
t.size = Math.max(Math.min(e, t.max), t.min), i -= t.size, t.size >= t.max && s.push(t.id), t.size <= t.min && n.push(t.id);
}), i > 0.1 && this.readjustSizes(i, s, n);
},
initialPanesSizing() {
let e = 100;
const i = [], s = [];
let n = 0;
this.panes.forEach((a) => {
e -= a.size, a.size !== null && n++, a.size >= a.max && i.push(a.id), a.size <= a.min && s.push(a.id);
});
let t = 100;
e > 0.1 && (this.panes.forEach((a) => {
a.size === null && (a.size = Math.max(Math.min(e / (this.panesCount - n), a.max), a.min)), t -= a.size;
}), t > 0.1 && this.readjustSizes(e, i, s));
},
equalizeAfterAddOrRemove({ addedPane: e, removedPane: i } = {}) {
let s = 100 / this.panesCount, n = 0;
const t = [], a = [];
e && e.givenSize !== null && (s = (100 - e.givenSize) / (this.panesCount - 1)), this.panes.forEach((r) => {
n -= r.size, r.size >= r.max && t.push(r.id), r.size <= r.min && a.push(r.id);
}), !(Math.abs(n) < 0.1) && (this.panes.forEach((r) => {
e && e.givenSize !== null && e.id === r.id || (r.size = Math.max(Math.min(s, r.max), r.min)), n -= r.size, r.size >= r.max && t.push(r.id), r.size <= r.min && a.push(r.id);
}), n > 0.1 && this.readjustSizes(n, t, a));
},
/* recalculatePaneSizes ({ addedPane, removedPane } = {}) {
let leftToAllocate = 100
let equalSpaceToAllocate = leftToAllocate / this.panesCount
let ungrowable = []
let unshrinkable = []
// When adding a pane with no size, apply min-size if defined otherwise divide another pane
// (next or prev) in 2.
// if (addedPane && addedPane.size === null) {
// if (addedPane.min) addedPane.size = addedPane.min
// else {
// const paneToDivide = this.panes[addedPane.index + 1] || this.panes[addedPane.index - 1]
// if (paneToDivide) {
// // @todo: Dividing that pane in 2 could be incorrect if becoming lower than its min size.
// addedPane.size = paneToDivide.size / 2
// paneToDivide.size /= 2
// }
// }
// }
this.panes.forEach((pane, i) => {
// Added pane - reduce the size of the next pane.
if (addedPane && addedPane.index + 1 === i) {
pane.size = Math.max(Math.min(100 - this.sumPrevPanesSize(i) - this.sumNextPanesSize(i + 1), pane.max), pane.min)
// @todo: if could not allocate correctly, try to allocate in the next pane straight away,
// then still do the second loop if not correct.
}
// Removed pane - increase the size of the next pane.
else if (removedPane && removedPane.index === i) {
pane.size = Math.max(Math.min(100 - this.sumPrevPanesSize(i) - this.sumNextPanesSize(i + 1), pane.max), pane.min)
// @todo: if could not allocate correctly, try to allocate in the next pane straight away,
// then still do the second loop if not correct.
}
// Initial load and on demand recalculation.
else if (!addedPane && !removedPane && pane.size === null) {
pane.size = Math.max(Math.min(equalSpaceToAllocate, pane.max), pane.min)
}
leftToAllocate -= pane.size
if (pane.size >= pane.max) ungrowable.push(pane.id)
if (pane.size <= pane.min) unshrinkable.push(pane.id)
})
// Do one more loop to adjust sizes if still wrong.
// > 0.1: Prevent maths rounding issues due to bytes.
if (Math.abs(leftToAllocate) > 0.1) this.readjustSizes(leftToAllocate, ungrowable, unshrinkable)
}, */
// Second loop to adjust sizes now that we know more about the panes constraints.
readjustSizes(e, i, s) {
let n;
e > 0 ? n = e / (this.panesCount - i.length) : n = e / (this.panesCount - s.length), this.panes.forEach((t, a) => {
if (e > 0 && !i.includes(t.id)) {
const r = Math.max(Math.min(t.size + n, t.max), t.min), o = r - t.size;
e -= o, t.size = r;
} else if (!s.includes(t.id)) {
const r = Math.max(Math.min(t.size + n, t.max), t.min), o = r - t.size;
e -= o, t.size = r;
}
t.update({
[this.horizontal ? "height" : "width"]: `${this.indexedPanes[t.id].size}%`
});
}), Math.abs(e) > 0.1 && this.$nextTick(() => {
this.ready && console.warn("Splitpanes: Could not resize panes correctly due to their constraints.");
});
}
/* distributeEmptySpace () {
let growablePanes = []
let collapsedPanesCount = 0
let growableAmount = 0 // Total of how much the current panes can grow to fill blank space.
let spaceToDistribute = 100 - this.panes.reduce((sum, pane) => (sum += pane.size) && sum, 0)
// Do a first loop to determine if we can distribute the new blank space between all the
// expandedPanes, without expanding the collapsed ones.
this.panes.forEach(pane => {
if (pane.size < pane.max) growablePanes.push(pane)
if (!pane.size) collapsedPanesCount++
else growableAmount += pane.max - pane.size
})
// If the blank space to distribute is too great for the expanded panes, also expand collapsed ones.
let expandCollapsedPanes = growableAmount < spaceToDistribute
// New space to distribute equally.
let growablePanesCount = (growablePanes.length - (expandCollapsedPanes ? 0 : collapsedPanesCount))
let equalSpaceToDistribute = spaceToDistribute / growablePanesCount
// if (growablePanesCount === 1) equalSpace = 100 / this.panesCount
let spaceLeftToDistribute = spaceToDistribute
// Now add the equalSpaceToDistribute to each pane size accordingly.
growablePanes.forEach(pane => {
if (pane.size < pane.max && (pane.size || (!pane.size && expandCollapsedPanes))) {
const newSize = Math.min(pane.size + equalSpaceToDistribute, pane.max)
let allocatedSpace = (newSize - pane.size)
spaceLeftToDistribute -= allocatedSpace
pane.size = newSize
// If the equalSpaceToDistribute is not fully added to the current pane, distribute the remainder
// to the next panes.
// Also fix decimal issue due to bites - E.g. calculating 8.33 and getting 8.3299999999999
if (equalSpaceToDistribute - allocatedSpace > 0.1) equalSpaceToDistribute = spaceLeftToDistribute / (--growablePanesCount)
}
})
/* Disabled otherwise will show up on hot reload.
// if there is still space to allocate show warning message.
if (this.panesCount && ~~spaceLeftToDistribute) {
// eslint-disable-next-line no-console
console.warn('Splitpanes: Could not distribute all the empty space between panes due to their constraints.')
} *\/
this.$emit('resized', this.panes.map(pane => ({ min: pane.min, max: pane.max, size: pane.size })))
} */
},
watch: {
panes: {
// Every time a pane is updated, update the panes accordingly.
deep: true,
immediate: false,
handler() {
this.updatePaneComponents();
}
},
horizontal() {
this.updatePaneComponents();
},
firstSplitter() {
this.redoSplitters();
},
dblClickSplitter(e) {
[...this.container.querySelectorAll(".splitpanes__splitter")].forEach((s, n) => {
s.ondblclick = e ? (t) => this.onSplitterDblClick(t, n) : void 0;
});
}
},
beforeUnmount() {
this.ready = false;
},
mounted() {
this.container = this.$refs.container, this.checkSplitpanesNodes(), this.redoSplitters(), this.resetPaneSizes(), this.$emit("ready"), this.ready = true;
},
render() {
return h(
"div",
{
ref: "container",
class: [
"splitpanes",
`splitpanes--${this.horizontal ? "horizontal" : "vertical"}`,
{
"splitpanes--dragging": this.touch.dragging
}
]
},
this.$slots.default()
);
}
}, S = (e, i) => {
const s = e.__vccOpts || e;
for (const [n, t] of i)
s[n] = t;
return s;
}, x = {
// eslint-disable-next-line vue/multi-word-component-names
name: "pane",
inject: ["requestUpdate", "onPaneAdd", "onPaneRemove", "onPaneClick"],
props: {
size: { type: [Number, String], default: null },
minSize: { type: [Number, String], default: 0 },
maxSize: { type: [Number, String], default: 100 }
},
data: () => ({
style: {}
}),
mounted() {
this.onPaneAdd(this);
},
beforeUnmount() {
this.onPaneRemove(this);
},
methods: {
// Called from the splitpanes component.
update(e) {
this.style = e;
}
},
computed: {
sizeNumber() {
return this.size || this.size === 0 ? parseFloat(this.size) : null;
},
minSizeNumber() {
return parseFloat(this.minSize);
},
maxSizeNumber() {
return parseFloat(this.maxSize);
}
},
watch: {
sizeNumber(e) {
this.requestUpdate({ target: this, size: e });
},
minSizeNumber(e) {
this.requestUpdate({ target: this, min: e });
},
maxSizeNumber(e) {
this.requestUpdate({ target: this, max: e });
}
}
};
function P(e, i, s, n, t, a) {
return openBlock(), createElementBlock("div", {
class: "splitpanes__pane",
onClick: i[0] || (i[0] = (r) => a.onPaneClick(r, e._.uid)),
style: normalizeStyle(e.style)
}, [
renderSlot(e.$slots, "default")
], 4);
}
const g = /* @__PURE__ */ S(x, [["render", P]]);
/* Injected with object hook! */
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
/* Injected with object hook! */
var codemirror$1 = {exports: {}};/* Injected with object hook! */
var codemirror = codemirror$1.exports;
var hasRequiredCodemirror;
function requireCodemirror () {
if (hasRequiredCodemirror) return codemirror$1.exports;
hasRequiredCodemirror = 1;
(function (module, exports) {
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/5/LICENSE
// This is CodeMirror (https://codemirror.net/5), a code editor
// implemented in JavaScript on top of the browser's DOM.
//
// You can find some technical background for some of the code below
// at http://marijnhaverbeke.nl/blog/#cm-internals .
(function (global, factory) {
module.exports = factory() ;
}(codemirror, (function () {
// Kludges for bugs and behavior differences that can't be feature
// detected are enabled based on userAgent etc sniffing.
var userAgent = navigator.userAgent;
var platform = navigator.platform;
var gecko = /gecko\/\d/i.test(userAgent);
var ie_upto10 = /MSIE \d/.test(userAgent);
var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
var edge = /Edge\/(\d+)/.exec(userAgent);
var ie = ie_upto10 || ie_11up || edge;
var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);
var webkit = !edge && /WebKit\//.test(userAgent);
var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
var chrome = !edge && /Chrome\/(\d+)/.exec(userAgent);
var chrome_version = chrome && +chrome[1];
var presto = /Opera\//.test(userAgent);
var safari = /Apple Computer/.test(navigator.vendor);
var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent);
var phantom = /PhantomJS/.test(userAgent);
var ios = safari && (/Mobile\/\w+/.test(userAgent) || navigator.maxTouchPoints > 2);
var android = /Android/.test(userAgent);
// This is woefully incomplete. Suggestions for alternative methods welcome.
var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
var mac = ios || /Mac/.test(platform);
var chromeOS = /\bCrOS\b/.test(userAgent);
var windows = /win/i.test(platform);
var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
if (presto_version) { presto_version = Number(presto_version[1]); }
if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
// Some browsers use the wrong event properties to signal cmd/ctrl on OS X
var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
var captureRightClick = gecko || (ie && ie_version >= 9);
function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }
var rmClass = function(node, cls) {
var current = node.className;
var match = classTest(cls).exec(current);
if (match) {
var after = current.slice(match.index + match[0].length);
node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
}
};
function removeChildren(e) {
for (var count = e.childNodes.length; count > 0; --count)
{ e.removeChild(e.firstChild); }
return e
}
function removeChildrenAndAdd(parent, e) {
return removeChildren(parent).appendChild(e)
}
function elt(tag, content, className, style) {
var e = document.createElement(tag);
if (className) { e.className = className; }
if (style) { e.style.cssText = style; }
if (typeof content == "string") { e.appendChild(document.createTextNode(content)); }
else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]); } }
return e
}
// wrapper for elt, which removes the elt from the accessibility tree
function eltP(tag, content, className, style) {
var e = elt(tag, content, className, style);
e.setAttribute("role", "presentation");
return e
}
var range;
if (document.createRange) { range = function(node, start, end, endNode) {
var r = document.createRange();
r.setEnd(endNode || node, end);
r.setStart(node, start);
return r
}; }
else { range = function(node, start, end) {
var r = document.body.createTextRange();
try { r.moveToElementText(node.parentNode); }
catch(e) { return r }
r.collapse(true);
r.moveEnd("character", end);
r.moveStart("character", start);
return r
}; }
function contains(parent, child) {
if (child.nodeType == 3) // Android browser always returns false when child is a textnode
{ child = child.parentNode; }
if (parent.contains)
{ return parent.contains(child) }
do {
if (child.nodeType == 11) { child = child.host; }
if (child == parent) { return true }
} while (child = child.parentNode)
}
function activeElt(rootNode) {
// IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
// IE < 10 will throw when accessed while the page is loading or in an iframe.
// IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
var doc = rootNode.ownerDocument || rootNode;
var activeElement;
try {
activeElement = rootNode.activeElement;
} catch(e) {
activeElement = doc.body || null;
}
while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
{ activeElement = activeElement.shadowRoot.activeElement; }
return activeElement
}
function addClass(node, cls) {
var current = node.className;
if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls; }
}
function joinClasses(a, b) {
var as = a.split(" ");
for (var i = 0; i < as.length; i++)
{ if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i]; } }
return b
}
var selectInput = function(node) { node.select(); };
if (ios) // Mobile Safari apparently has a bug where select() is broken.
{ selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; }; }
else if (ie) // Suppress mysterious IE10 errors
{ selectInput = function(node) { try { node.select(); } catch(_e) {} }; }
function doc(cm) { return cm.display.wrapper.ownerDocument }
function root(cm) {
return rootNode(cm.display.wrapper)
}
function rootNode(element) {
// Detect modern browsers (2017+).
return element.getRootNode ? element.getRootNode() : element.ownerDocument
}
function win(cm) { return doc(cm).defaultView }
function bind(f) {
var args = Array.prototype.slice.call(arguments, 1);
return function(){return f.apply(null, args)}
}
function copyObj(obj, target, overwrite) {
if (!target) { target = {}; }
for (var prop in obj)
{ if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
{ target[prop] = obj[prop]; } }
return target
}
// Counts the column offset in a string, taking tabs into account.
// Used mostly to find indentation.
function countColumn(string, end, tabSize, startIndex, startValue) {
if (end == null) {
end = string.search(/[^\s\u00a0]/);
if (end == -1) { end = string.length; }
}
for (var i = startIndex || 0, n = startValue || 0;;) {
var nextTab = string.indexOf("\t", i);
if (nextTab < 0 || nextTab >= end)
{ return n + (end - i) }
n += nextTab - i;
n += tabSize - (n % tabSize);
i = nextTab + 1;
}
}
var Delayed = function() {
this.id = null;
this.f = null;
this.time = 0;
this.handler = bind(this.onTimeout, this);
};
Delayed.prototype.onTimeout = function (self) {
self.id = 0;
if (self.time <= +new Date) {
self.f();
} else {
setTimeout(self.handler, self.time - +new Date);
}
};
Delayed.prototype.set = function (ms, f) {
this.f = f;
var time = +new Date + ms;
if (!this.id || time < this.time) {
clearTimeout(this.id);
this.id = setTimeout(this.handler, ms);
this.time = time;
}
};
function indexOf(array, elt) {
for (var i = 0; i < array.length; ++i)
{ if (array[i] == elt) { return i } }
return -1
}
// Number of pixels added to scroller and sizer to hide scrollbar
var scrollerGap = 50;
// Returned or thrown by various protocols to signal 'I'm not
// handling this'.
var Pass = {toString: function(){return "CodeMirror.Pass"}};
// Reused option objects for setSelection & friends
var sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"};
// The inverse of countColumn -- find the offset that corresponds to
// a particular column.
function findColumn(string, goal, tabSize) {
for (var pos = 0, col = 0;;) {
var nextTab = string.indexOf("\t", pos);
if (nextTab == -1) { nextTab = string.length; }
var skipped = nextTab - pos;
if (nextTab == string.length || col + skipped >= goal)
{ return pos + Math.min(skipped, goal - col) }
col += nextTab - pos;
col += tabSize - (col % tabSize);
pos = nextTab + 1;
if (col >= goal) { return pos }
}
}
var spaceStrs = [""];
function spaceStr(n) {
while (spaceStrs.length <= n)
{ spaceStrs.push(lst(spaceStrs) + " "); }
return spaceStrs[n]
}
function lst(arr) { return arr[arr.length-1] }
function map(array, f) {
var out = [];
for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); }
return out
}
function insertSorted(array, value, score) {
var pos = 0, priority = score(value);
while (pos < array.length && score(array[pos]) <= priority) { pos++; }
array.splice(pos, 0, value);
}
function nothing() {}
function createObj(base, props) {
var inst;
if (Object.create) {
inst = Object.create(base);
} else {
nothing.prototype = base;
inst = new nothing();
}
if (props) { copyObj(props, inst); }
return inst
}
var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
function isWordCharBasic(ch) {
return /\w/.test(ch) || ch > "\x80" &&
(ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))
}
function isWordChar(ch, helper) {
if (!helper) { return isWordCharBasic(ch) }
if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }
return helper.test(ch)
}
function isEmpty(obj) {
for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }
return true
}
// Extending unicode characters. A series of a non-extending char +
// any number of extending chars is treated as a single unit as far
// as editing and measuring is concerned. This is not fully correct,
// since some scripts/fonts/browsers also treat other configurations
// of code points as a group.
var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }
// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.
function skipExtendingChars(str, pos, dir) {
while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; }
return pos
}
// Returns the value from the range [`from`; `to`] that satisfies
// `pred` and is closest to `from`. Assumes that at least `to`
// satisfies `pred`. Supports `from` being greater than `to`.
function findFirst(pred, from, to) {
// At any point we are certain `to` satisfies `pred`, don't know
// whether `from` does.
var dir = from > to ? -1 : 1;
for (;;) {
if (from == to) { return from }
var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);
if (mid == from) { return pred(mid) ? from : to }
if (pred(mid)) { to = mid; }
else { from = mid + dir; }
}
}
// BIDI HELPERS
function iterateBidiSections(order, from, to, f) {
if (!order) { return f(from, to, "ltr", 0) }
var found = false;
for (var i = 0; i < order.length; ++i) {
var part = order[i];
if (part.from < to && part.to > from || from == to && part.to == from) {
f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr", i);
found = true;
}
}
if (!found) { f(from, to, "ltr"); }
}
var bidiOther = null;
function getBidiPartAt(order, ch, sticky) {
var found;
bidiOther = null;
for (var i = 0; i < order.length; ++i) {
var cur = order[i];
if (cur.from < ch && cur.to > ch) { return i }
if (cur.to == ch) {
if (cur.from != cur.to && sticky == "before") { found = i; }
else { bidiOther = i; }
}
if (cur.from == ch) {
if (cur.from != cur.to && sticky != "before") { found = i; }
else { bidiOther = i; }
}
}
return found != null ? found : bidiOther
}
// Bidirectional ordering algorithm
// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
// that this (partially) implements.
// One-char codes used for character types:
// L (L): Left-to-Right
// R (R): Right-to-Left
// r (AL): Right-to-Left Arabic
// 1 (EN): European Number
// + (ES): European Number Separator
// % (ET): European Number Terminator
// n (AN): Arabic Number
// , (CS): Common Number Separator
// m (NSM): Non-Spacing Mark
// b (BN): Boundary Neutral
// s (B): Paragraph Separator
// t (S): Segment Separator
// w (WS): Whitespace
// N (ON): Other Neutrals
// Returns null if characters are ordered as they appear
// (left-to-right), or an array of sections ({from, to, level}
// objects) in the order in which they occur visually.
var bidiOrdering = (function() {
// Character types for codepoints 0 to 0xff
var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
// Character types for codepoints 0x600 to 0x6f9
var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111";
function charType(code) {
if (code <= 0xf7) { return lowTypes.charAt(code) }
else if (0x590 <= code && code <= 0x5f4) { return "R" }
else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }
else if (0x6ee <= code && code <= 0x8ac) { return "r" }
else if (0x2000 <= code && code <= 0x200b) { return "w" }
else if (code == 0x200c) { return "b" }
else { return "L" }
}
var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;
function BidiSpan(level, from, to) {
this.level = level;
this.from = from; this.to = to;
}
return function(str, direction) {
var outerType = direction == "ltr" ? "L" : "R";
if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false }
var len = str.length, types = [];
for (var i = 0; i < len; ++i)
{ types.push(charType(str.charCodeAt(i))); }
// W1. Examine each non-spacing mark (NSM) in the level run, and
// change the type of the NSM to the type of the previous
// character. If the NSM is at the start of the level run, it will
// get the type of sor.
for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
var type = types[i$1];
if (type == "m") { types[i$1] = prev; }
else { prev = type; }
}
// W2. Search backwards from each instance of a European number
// until the first strong type (R, L, AL, or sor) is found. If an
// AL is found, change the type of the European number to Arabic
// number.
// W3. Change all ALs to R.
for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
var type$1 = types[i$2];
if (type$1 == "1" && cur == "r") { types[i$2] = "n"; }
else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } }
}
// W4. A single European separator between two European numbers
// changes to a European number. A single common separator between
// two numbers of the same type changes to that type.
for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
var type$2 = types[i$3];
if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; }
else if (type$2 == "," && prev$1 == types[i$3+1] &&
(prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; }
prev$1 = type$2;
}
// W5. A sequence of European terminators adjacent to European
// numbers changes to all European numbers.
// W6. Otherwise, separators and terminators change to Other
// Neutral.
for (var i$4 = 0; i$4 < len; ++i$4) {
var type$3 = types[i$4];
if (type$3 == ",") { types[i$4] = "N"; }
else if (type$3 == "%") {
var end = (void 0);
for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
for (var j = i$4; j < end; ++j) { types[j] = replace; }
i$4 = end - 1;
}
}
// W7. Search backwards from each instance of a European number
// until the first strong type (R, L, or sor) is found. If an L is
// found, then change the type of the European number to L.
for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
var type$4 = types[i$5];
if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; }
else if (isStrong.test(type$4)) { cur$1 = type$4; }
}
// N1. A sequence of neutrals takes the direction of the
// surrounding strong text if the text on both sides has the same
// direction. European and Arabic numbers act as if they were R in
// terms of their influence on neutrals. Start-of-level-run (sor)
// and end-of-level-run (eor) are used at level run boundaries.
// N2. Any remaining neutrals take the embedding direction.
for (var i$6 = 0; i$6 < len; ++i$6) {
if (isNeutral.test(types[i$6])) {
var end$1 = (void 0);
for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
var before = (i$6 ? types[i$6-1] : outerType) == "L";
var after = (end$1 < len ? types[end$1] : outerType) == "L";
var replace$1 = before == after ? (before ? "L" : "R") : outerType;
for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; }
i$6 = end$1 - 1;
}
}
// Here we depart from the documented algorithm, in order to avoid
// building up an actual levels array. Since there are only three
// levels (0, 1, 2) in an implementation that doesn't take
// explicit embedding into account, we can build up the order on
// the fly, without following the level-based algorithm.
var order = [], m;
for (var i$7 = 0; i$7 < len;) {
if (countsAsLeft.test(types[i$7])) {
var start = i$7;
for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
order.push(new BidiSpan(0, start, i$7));
} else {
var pos = i$7, at = order.length, isRTL = direction == "rtl" ? 1 : 0;
for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
for (var j$2 = pos; j$2 < i$7;) {
if (countsAsNum.test(types[j$2])) {
if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); at += isRTL; }
var nstart = j$2;
for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
order.splice(at, 0, new BidiSpan(2, nstart, j$2));
at += isRTL;
pos = j$2;
} else { ++j$2; }
}
if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); }
}
}
if (direction == "ltr") {
if (order[0].level == 1 && (m = str.match(/^\s+/))) {
order[0].from = m[0].length;
order.unshift(new BidiSpan(0, 0, m[0].length));
}
if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
lst(order).to -= m[0].length;
order.push(new BidiSpan(0, len - m[0].length, len));
}
}
return direction == "rtl" ? order.reverse() : order
}
})();
// Get the bidi ordering for the given line (and cache it). Returns
// false for lines that are fully left-to-right, and an array of
// BidiSpan objects otherwise.
function getOrder(line, direction) {
var order = line.order;
if (order == null) { order = line.order = bidiOrdering(line.text, direction); }
return order
}
// EVENT HANDLING
// Lightweight event framework. on/off also work on DOM nodes,
// registering native DOM handlers.
var noHandlers = [];
var on = function(emitter, type, f) {
if (emitter.addEventListener) {
emitter.addEventListener(type, f, false);
} else if (emitter.attachEvent) {
emitter.attachEvent("on" + type, f);
} else {
var map = emitter._handlers || (emitter._handlers = {});
map[type] = (map[type] || noHandlers).concat(f);
}
};
function getHandlers(emitter, type) {
return emitter._handlers && emitter._handlers[type] || noHandlers
}
function off(emitter, type, f) {
if (emitter.removeEventListener) {
emitter.removeEventListener(type, f, false);
} else if (emitter.detachEvent) {
emitter.detachEvent("on" + type, f);
} else {
var map = emitter._handlers, arr = map && map[type];
if (arr) {
var index = indexOf(arr, f);
if (index > -1)
{ map[type] = arr.slice(0, index).concat(arr.slice(index + 1)); }
}
}
}
function signal(emitter, type /*, values...*/) {
var handlers = getHandlers(emitter, type);
if (!handlers.length) { return }
var args = Array.prototype.slice.call(arguments, 2);
for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); }
}
// The DOM events that CodeMirror handles c