@veltra/desktop 1.2.28 → 1.2.29

package/dist/components/pop-confirm/pop-confirm.vue.d.ts

@@ -12,8 +12,8 @@ declare const __VLS_base: import("vue").DefineComponent<PopConfirmProps, {}, {},
   onConfirm?: (() => any) | undefined;
   onCancel?: (() => any) | undefined;
 }>, {
-  trigger: "hover" | "click";
   direction: TipDirection;
+  trigger: "hover" | "click";
   icon: import("vue").Component;
   iconColor: string;
   confirmText: string;

package/dist/components/radio-group/radio-group.vue.d.ts

@@ -14,10 +14,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
   "onUpdate:modelValue"?: ((value: any) => any) | undefined;
   onChange?: ((item: Record<string, any>) => any) | undefined;
 }>, {
-  labelKey: string;
-  valueKey: string;
   disabled: boolean;
   readonly: boolean;
+  labelKey: string;
+  valueKey: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 //#endregion

package/dist/components/select/select.vue.d.ts

@@ -24,10 +24,10 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {
   "onUpdate:text"?: ((value: any) => any) | undefined;
   "onUpdate:label"?: ((label?: string | undefined) => any) | undefined;
 }>, {
-  labelKey: string;
-  valueKey: string;
   disabled: boolean;
   readonly: boolean;
+  labelKey: string;
+  valueKey: string;
   placeholder: string;
   clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/steps/steps.vue.d.ts

@@ -12,8 +12,8 @@ declare const __VLS_base: import("vue").DefineComponent<StepsProps, {}, {}, {},
   "onItem-click"?: ((item: Record<string, any>, index: number) => any) | undefined;
   "onUpdate:current"?: ((value?: string | number | undefined) => any) | undefined;
 }>, {
-  labelKey: string;
   direction: "horizontal" | "vertical";
+  labelKey: string;
   finishedStepType: import("@veltra/utils").ColorType;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/textarea/textarea.vue.d.ts

@@ -9,15 +9,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
   "update:modelValue": (value: string | undefined) => any;
 } & {
   "update:modelValue": (value: string) => any;
+  clear: () => any;
   change: (value: string) => any;
   focus: () => any;
-  clear: () => any;
   blur: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
   "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+  onClear?: (() => any) | undefined;
   onChange?: ((value: string) => any) | undefined;
   onFocus?: (() => any) | undefined;
-  onClear?: (() => any) | undefined;
   onBlur?: (() => any) | undefined;
 }>, {
   disabled: boolean;

package/dist/components/tip/tip.vue.d.ts

@@ -9,12 +9,12 @@ declare const __VLS_base: import("vue").DefineComponent<TipProps, {}, {}, {}, {}
 }, string, import("vue").PublicProps, Readonly<TipProps> & Readonly<{
   "onUpdate:visible"?: ((value: boolean) => any) | undefined;
 }>, {
+  direction: TipDirection;
   trigger: "hover" | "click";
   contentTag: string;
   visible: boolean;
-  direction: TipDirection;
-  alignment: TipAlign;
   content: string;
+  alignment: TipAlign;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/tree-select/tree-select.vue.d.ts

@@ -15,24 +15,24 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {
   "update:modelValue": (value: string | number | undefined) => any;
 } & {
   "update:modelValue": (value?: string | number | undefined) => any;
-  change: (selectedData?: Record<string, any> | undefined) => any;
   clear: () => any;
+  change: (selectedData?: Record<string, any> | undefined) => any;
   "update:text": (text?: string | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
   "onUpdate:modelValue"?: ((value?: string | number | undefined) => any) | undefined;
-  onChange?: ((selectedData?: Record<string, any> | undefined) => any) | undefined;
   onClear?: (() => any) | undefined;
+  onChange?: ((selectedData?: Record<string, any> | undefined) => any) | undefined;
   "onUpdate:text"?: ((text?: string | undefined) => any) | undefined;
 }>, {
+  disabled: boolean;
+  readonly: boolean;
+  minWidth: string;
   expandAll: boolean;
   labelKey: string;
   valueKey: string;
-  disabled: boolean;
-  readonly: boolean;
   placeholder: string;
   clearable: boolean;
   filterable: boolean;
-  minWidth: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/node_modules/.bun/@codemirror_language@6.12.4/node_modules/@codemirror/language/dist/index.js

@@ -1,7 +1,7 @@
 import { EditorState, Facet, Prec, RangeSet, RangeSetBuilder, StateEffect, StateField, combineConfig, countColumn } from "../../../../../@codemirror_state@6.7.0/node_modules/@codemirror/state/dist/index.js";
 import { StyleModule } from "../../../../../style-mod@4.1.3/node_modules/style-mod/src/style-mod.js";
 import { Decoration, Direction, EditorView, GutterMarker, ViewPlugin, WidgetType, gutter, logException } from "../../../../../@codemirror_view@6.43.4/node_modules/@codemirror/view/dist/index.js";
-import { IterMode, NodeProp, NodeType, Parser, Tree, TreeFragment } from "../../../../../@lezer_common@1.5.2/node_modules/@lezer/common/dist/index.js";
+import { IterMode, NodeProp, NodeSet, NodeType, Parser, Tree, TreeFragment } from "../../../../../@lezer_common@1.5.2/node_modules/@lezer/common/dist/index.js";
 import { highlightTree, styleTags, tagHighlighter, tags } from "../../../../../@lezer_highlight@1.2.3/node_modules/@lezer/highlight/dist/index.js";
 //#region ../../node_modules/.bun/@codemirror+language@6.12.4/node_modules/@codemirror/language/dist/index.js
 var _a;
@@ -1710,8 +1710,438 @@ function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, b
 		matched: false
 	} : null;
 }
+function countCol(string, end, tabSize, startIndex = 0, startValue = 0) {
+	if (end == null) {
+		end = string.search(/[^\s\u00a0]/);
+		if (end == -1) end = string.length;
+	}
+	let n = startValue;
+	for (let i = startIndex; i < end; i++) if (string.charCodeAt(i) == 9) n += tabSize - n % tabSize;
+	else n++;
+	return n;
+}
+/**
+Encapsulates a single line of input. Given to stream syntax code,
+which uses it to tokenize the content.
+*/
+var StringStream = class {
+	/**
+	Create a stream.
+	*/
+	constructor(string, tabSize, indentUnit, overrideIndent) {
+		this.string = string;
+		this.tabSize = tabSize;
+		this.indentUnit = indentUnit;
+		this.overrideIndent = overrideIndent;
+		/**
+		The current position on the line.
+		*/
+		this.pos = 0;
+		/**
+		The start position of the current token.
+		*/
+		this.start = 0;
+		this.lastColumnPos = 0;
+		this.lastColumnValue = 0;
+	}
+	/**
+	True if we are at the end of the line.
+	*/
+	eol() {
+		return this.pos >= this.string.length;
+	}
+	/**
+	True if we are at the start of the line.
+	*/
+	sol() {
+		return this.pos == 0;
+	}
+	/**
+	Get the next code unit after the current position, or undefined
+	if we're at the end of the line.
+	*/
+	peek() {
+		return this.string.charAt(this.pos) || void 0;
+	}
+	/**
+	Read the next code unit and advance `this.pos`.
+	*/
+	next() {
+		if (this.pos < this.string.length) return this.string.charAt(this.pos++);
+	}
+	/**
+	Match the next character against the given string, regular
+	expression, or predicate. Consume and return it if it matches.
+	*/
+	eat(match) {
+		let ch = this.string.charAt(this.pos);
+		let ok;
+		if (typeof match == "string") ok = ch == match;
+		else ok = ch && (match instanceof RegExp ? match.test(ch) : match(ch));
+		if (ok) {
+			++this.pos;
+			return ch;
+		}
+	}
+	/**
+	Continue matching characters that match the given string,
+	regular expression, or predicate function. Return true if any
+	characters were consumed.
+	*/
+	eatWhile(match) {
+		let start = this.pos;
+		while (this.eat(match));
+		return this.pos > start;
+	}
+	/**
+	Consume whitespace ahead of `this.pos`. Return true if any was
+	found.
+	*/
+	eatSpace() {
+		let start = this.pos;
+		while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+		return this.pos > start;
+	}
+	/**
+	Move to the end of the line.
+	*/
+	skipToEnd() {
+		this.pos = this.string.length;
+	}
+	/**
+	Move to directly before the given character, if found on the
+	current line.
+	*/
+	skipTo(ch) {
+		let found = this.string.indexOf(ch, this.pos);
+		if (found > -1) {
+			this.pos = found;
+			return true;
+		}
+	}
+	/**
+	Move back `n` characters.
+	*/
+	backUp(n) {
+		this.pos -= n;
+	}
+	/**
+	Get the column position at `this.pos`.
+	*/
+	column() {
+		if (this.lastColumnPos < this.start) {
+			this.lastColumnValue = countCol(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
+			this.lastColumnPos = this.start;
+		}
+		return this.lastColumnValue;
+	}
+	/**
+	Get the indentation column of the current line.
+	*/
+	indentation() {
+		var _a;
+		return (_a = this.overrideIndent) !== null && _a !== void 0 ? _a : countCol(this.string, null, this.tabSize);
+	}
+	/**
+	Match the input against the given string or regular expression
+	(which should start with a `^`). Return true or the regexp match
+	if it matches.
+	
+	Unless `consume` is set to `false`, this will move `this.pos`
+	past the matched text.
+	
+	When matching a string `caseInsensitive` can be set to true to
+	make the match case-insensitive.
+	*/
+	match(pattern, consume, caseInsensitive) {
+		if (typeof pattern == "string") {
+			let cased = (str) => caseInsensitive ? str.toLowerCase() : str;
+			if (cased(this.string.substr(this.pos, pattern.length)) == cased(pattern)) {
+				if (consume !== false) this.pos += pattern.length;
+				return true;
+			} else return null;
+		} else {
+			let match = this.string.slice(this.pos).match(pattern);
+			if (match && match.index > 0) return null;
+			if (match && consume !== false) this.pos += match[0].length;
+			return match;
+		}
+	}
+	/**
+	Get the current token.
+	*/
+	current() {
+		return this.string.slice(this.start, this.pos);
+	}
+};
+function fullParser(spec) {
+	return {
+		name: spec.name || "",
+		token: spec.token,
+		blankLine: spec.blankLine || (() => {}),
+		startState: spec.startState || (() => true),
+		copyState: spec.copyState || defaultCopyState,
+		indent: spec.indent || (() => null),
+		languageData: spec.languageData || {},
+		tokenTable: spec.tokenTable || noTokens,
+		mergeTokens: spec.mergeTokens !== false
+	};
+}
+function defaultCopyState(state) {
+	if (typeof state != "object") return state;
+	let newState = {};
+	for (let prop in state) {
+		let val = state[prop];
+		newState[prop] = val instanceof Array ? val.slice() : val;
+	}
+	return newState;
+}
+const IndentedFrom = /*@__PURE__*/ new WeakMap();
+/**
+A [language](https://codemirror.net/6/docs/ref/#language.Language) class based on a CodeMirror
+5-style [streaming parser](https://codemirror.net/6/docs/ref/#language.StreamParser).
+*/
+var StreamLanguage = class StreamLanguage extends Language {
+	constructor(parser) {
+		let data = defineLanguageFacet(parser.languageData);
+		let p = fullParser(parser), self;
+		let impl = new class extends Parser {
+			createParse(input, fragments, ranges) {
+				return new Parse(self, input, fragments, ranges);
+			}
+		}();
+		super(data, impl, [], parser.name);
+		this.topNode = docID(data, this);
+		self = this;
+		this.streamParser = p;
+		this.stateAfter = new NodeProp({ perNode: true });
+		this.tokenTable = parser.tokenTable ? new TokenTable(p.tokenTable) : defaultTokenTable;
+	}
+	/**
+	Define a stream language.
+	*/
+	static define(spec) {
+		return new StreamLanguage(spec);
+	}
+	/**
+	@internal
+	*/
+	getIndent(cx) {
+		let from = void 0;
+		let { overrideIndentation } = cx.options;
+		if (overrideIndentation) {
+			from = IndentedFrom.get(cx.state);
+			if (from != null && from < cx.pos - 1e4) from = void 0;
+		}
+		let start = findState(this, cx.node.tree, cx.node.from, cx.node.from, from !== null && from !== void 0 ? from : cx.pos), statePos, state;
+		if (start) {
+			state = start.state;
+			statePos = start.pos + 1;
+		} else {
+			state = this.streamParser.startState(cx.unit);
+			statePos = cx.node.from;
+		}
+		if (cx.pos - statePos > 1e4) return null;
+		while (statePos < cx.pos) {
+			let line = cx.state.doc.lineAt(statePos), end = Math.min(cx.pos, line.to);
+			if (line.length) {
+				let indentation = overrideIndentation ? overrideIndentation(line.from) : -1;
+				let stream = new StringStream(line.text, cx.state.tabSize, cx.unit, indentation < 0 ? void 0 : indentation);
+				while (stream.pos < end - line.from) readToken(this.streamParser.token, stream, state);
+			} else this.streamParser.blankLine(state, cx.unit);
+			if (end == cx.pos) break;
+			statePos = line.to + 1;
+		}
+		let line = cx.lineAt(cx.pos);
+		if (overrideIndentation && from == null) IndentedFrom.set(cx.state, line.from);
+		return this.streamParser.indent(state, /^\s*(.*)/.exec(line.text)[1], cx);
+	}
+	get allowsNesting() {
+		return false;
+	}
+};
+function findState(lang, tree, off, startPos, before) {
+	let state = off >= startPos && off + tree.length <= before && tree.prop(lang.stateAfter);
+	if (state) return {
+		state: lang.streamParser.copyState(state),
+		pos: off + tree.length
+	};
+	for (let i = tree.children.length - 1; i >= 0; i--) {
+		let child = tree.children[i], pos = off + tree.positions[i];
+		let found = child instanceof Tree && pos < before && findState(lang, child, pos, startPos, before);
+		if (found) return found;
+	}
+	return null;
+}
+function cutTree(lang, tree, from, to, inside) {
+	if (inside && from <= 0 && to >= tree.length) return tree;
+	if (!inside && from == 0 && tree.type == lang.topNode) inside = true;
+	for (let i = tree.children.length - 1; i >= 0; i--) {
+		let pos = tree.positions[i], child = tree.children[i], inner;
+		if (pos < to && child instanceof Tree) {
+			if (!(inner = cutTree(lang, child, from - pos, to - pos, inside))) break;
+			return !inside ? inner : new Tree(tree.type, tree.children.slice(0, i).concat(inner), tree.positions.slice(0, i + 1), pos + inner.length);
+		}
+	}
+	return null;
+}
+function findStartInFragments(lang, fragments, startPos, endPos, editorState) {
+	for (let f of fragments) {
+		let from = f.from + (f.openStart ? 25 : 0), to = f.to - (f.openEnd ? 25 : 0);
+		let found = from <= startPos && to > startPos && findState(lang, f.tree, 0 - f.offset, startPos, to), tree;
+		if (found && found.pos <= endPos && (tree = cutTree(lang, f.tree, startPos + f.offset, found.pos + f.offset, false))) return {
+			state: found.state,
+			tree
+		};
+	}
+	return {
+		state: lang.streamParser.startState(editorState ? getIndentUnit(editorState) : 4),
+		tree: Tree.empty
+	};
+}
+var Parse = class {
+	constructor(lang, input, fragments, ranges) {
+		this.lang = lang;
+		this.input = input;
+		this.fragments = fragments;
+		this.ranges = ranges;
+		this.stoppedAt = null;
+		this.chunks = [];
+		this.chunkPos = [];
+		this.chunk = [];
+		this.chunkReused = void 0;
+		this.rangeIndex = 0;
+		this.to = ranges[ranges.length - 1].to;
+		let context = ParseContext.get(), from = ranges[0].from;
+		let { state, tree } = findStartInFragments(lang, fragments, from, this.to, context === null || context === void 0 ? void 0 : context.state);
+		this.state = state;
+		this.parsedPos = this.chunkStart = from + tree.length;
+		for (let i = 0; i < tree.children.length; i++) {
+			this.chunks.push(tree.children[i]);
+			this.chunkPos.push(tree.positions[i]);
+		}
+		if (context && this.parsedPos < context.viewport.from - 1e5 && ranges.some((r) => r.from <= context.viewport.from && r.to >= context.viewport.from)) {
+			this.state = this.lang.streamParser.startState(getIndentUnit(context.state));
+			context.skipUntilInView(this.parsedPos, context.viewport.from);
+			this.parsedPos = context.viewport.from;
+		}
+		this.moveRangeIndex();
+	}
+	advance() {
+		let context = ParseContext.get();
+		let parseEnd = this.stoppedAt == null ? this.to : Math.min(this.to, this.stoppedAt);
+		let end = Math.min(parseEnd, this.chunkStart + 512);
+		if (context) end = Math.min(end, context.viewport.to);
+		while (this.parsedPos < end) this.parseLine(context);
+		if (this.chunkStart < this.parsedPos) this.finishChunk();
+		if (this.parsedPos >= parseEnd) return this.finish();
+		if (context && this.parsedPos >= context.viewport.to) {
+			context.skipUntilInView(this.parsedPos, parseEnd);
+			return this.finish();
+		}
+		return null;
+	}
+	stopAt(pos) {
+		this.stoppedAt = pos;
+	}
+	lineAfter(pos) {
+		let chunk = this.input.chunk(pos);
+		if (!this.input.lineChunks) {
+			let eol = chunk.indexOf("\n");
+			if (eol > -1) chunk = chunk.slice(0, eol);
+		} else if (chunk == "\n") chunk = "";
+		return pos + chunk.length <= this.to ? chunk : chunk.slice(0, this.to - pos);
+	}
+	nextLine() {
+		let from = this.parsedPos, line = this.lineAfter(from), end = from + line.length;
+		for (let index = this.rangeIndex;;) {
+			let rangeEnd = this.ranges[index].to;
+			if (rangeEnd >= end) break;
+			line = line.slice(0, rangeEnd - (end - line.length));
+			index++;
+			if (index == this.ranges.length) break;
+			let rangeStart = this.ranges[index].from;
+			let after = this.lineAfter(rangeStart);
+			line += after;
+			end = rangeStart + after.length;
+		}
+		return {
+			line,
+			end
+		};
+	}
+	skipGapsTo(pos, offset, side) {
+		for (;;) {
+			let end = this.ranges[this.rangeIndex].to, offPos = pos + offset;
+			if (side > 0 ? end > offPos : end >= offPos) break;
+			let start = this.ranges[++this.rangeIndex].from;
+			offset += start - end;
+		}
+		return offset;
+	}
+	moveRangeIndex() {
+		while (this.ranges[this.rangeIndex].to < this.parsedPos) this.rangeIndex++;
+	}
+	emitToken(id, from, to, offset) {
+		let size = 4;
+		if (this.ranges.length > 1) {
+			offset = this.skipGapsTo(from, offset, 1);
+			from += offset;
+			let len0 = this.chunk.length;
+			offset = this.skipGapsTo(to, offset, -1);
+			to += offset;
+			size += this.chunk.length - len0;
+		}
+		let last = this.chunk.length - 4;
+		if (this.lang.streamParser.mergeTokens && size == 4 && last >= 0 && this.chunk[last] == id && this.chunk[last + 2] == from) this.chunk[last + 2] = to;
+		else this.chunk.push(id, from, to, size);
+		return offset;
+	}
+	parseLine(context) {
+		let { line, end } = this.nextLine(), offset = 0, { streamParser } = this.lang;
+		let stream = new StringStream(line, context ? context.state.tabSize : 4, context ? getIndentUnit(context.state) : 2);
+		if (stream.eol()) streamParser.blankLine(this.state, stream.indentUnit);
+		else while (!stream.eol()) {
+			let token = readToken(streamParser.token, stream, this.state);
+			if (token) offset = this.emitToken(this.lang.tokenTable.resolve(token), this.parsedPos + stream.start, this.parsedPos + stream.pos, offset);
+			if (stream.start > 1e4) break;
+		}
+		this.parsedPos = end;
+		this.moveRangeIndex();
+		if (this.parsedPos < this.to) this.parsedPos++;
+	}
+	finishChunk() {
+		let tree = Tree.build({
+			buffer: this.chunk,
+			start: this.chunkStart,
+			length: this.parsedPos - this.chunkStart,
+			nodeSet,
+			topID: 0,
+			maxBufferLength: 512,
+			reused: this.chunkReused
+		});
+		tree = new Tree(tree.type, tree.children, tree.positions, tree.length, [[this.lang.stateAfter, this.lang.streamParser.copyState(this.state)]]);
+		this.chunks.push(tree);
+		this.chunkPos.push(this.chunkStart - this.ranges[0].from);
+		this.chunk = [];
+		this.chunkReused = void 0;
+		this.chunkStart = this.parsedPos;
+	}
+	finish() {
+		return new Tree(this.lang.topNode, this.chunks, this.chunkPos, this.parsedPos - this.ranges[0].from).balance();
+	}
+};
+function readToken(token, stream, state) {
+	stream.start = stream.pos;
+	for (let i = 0; i < 10; i++) {
+		let result = token(stream, state);
+		if (stream.pos > stream.start) return result;
+	}
+	throw new Error("Stream parser failed to advance stream.");
+}
 const noTokens = /*@__PURE__*/ Object.create(null);
 const typeArray = [NodeType.none];
+const nodeSet = /*@__PURE__*/ new NodeSet(typeArray);
 const warned = [];
 const byTag = /*@__PURE__*/ Object.create(null);
 const defaultTable = /*@__PURE__*/ Object.create(null);
@@ -1729,6 +2159,16 @@ for (let [legacyName, name] of [
 	["header", "heading"],
 	["property", "propertyName"]
 ]) defaultTable[legacyName] = /*@__PURE__*/ createTokenType(noTokens, name);
+var TokenTable = class {
+	constructor(extra) {
+		this.extra = extra;
+		this.table = Object.assign(Object.create(null), defaultTable);
+	}
+	resolve(tag) {
+		return !tag ? 0 : this.table[tag] || (this.table[tag] = createTokenType(this.extra, tag));
+	}
+};
+const defaultTokenTable = /*@__PURE__*/ new TokenTable(noTokens);
 function warnForPart(part, msg) {
 	if (warned.indexOf(part) > -1) return;
 	warned.push(part);
@@ -1760,8 +2200,18 @@ function createTokenType(extra, tagStr) {
 	typeArray.push(type);
 	return type.id;
 }
+function docID(data, lang) {
+	let type = NodeType.define({
+		id: typeArray.length,
+		name: "Document",
+		props: [languageDataProp.add(() => data), indentNodeProp.add(() => (cx) => lang.getIndent(cx))],
+		top: true
+	});
+	typeArray.push(type);
+	return type;
+}
 Direction.RTL, Direction.LTR;
 //#endregion
-export { HighlightStyle, IndentContext, LRLanguage, LanguageSupport, bracketMatching, continuedIndent, defaultHighlightStyle, defineLanguageFacet, delimitedIndent, flatIndent, foldGutter, foldInside, foldKeymap, foldNodeProp, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentString, indentUnit, matchBrackets, sublanguageProp, syntaxHighlighting, syntaxTree };
+export { HighlightStyle, IndentContext, LRLanguage, LanguageSupport, StreamLanguage, bracketMatching, continuedIndent, defaultHighlightStyle, defineLanguageFacet, delimitedIndent, flatIndent, foldGutter, foldInside, foldKeymap, foldNodeProp, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentString, indentUnit, matchBrackets, sublanguageProp, syntaxHighlighting, syntaxTree };
 
 //# sourceMappingURL=index.js.map