@sdata/web-vue 4.3.1 → 4.4.0

package/es/regex-vis/parser/parser.js

@@ -0,0 +1,357 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.146.0/helpers/esm/objectSpread2.js";
+import { lookAround, namedCapturing, nonCapturing, quantifier } from "./patterns.js";
+import { removeBackslash } from "./backslash.js";
+import { TokenType } from "./token.js";
+import { lookAround as lookAround$1 } from "./dict.js";
+import Lexer from "./lexer.js";
+//#region components/regex-vis/parser/parser.ts
+var rangeEscapeCharacters = {
+	"b": "\b",
+	"f": "\f",
+	"n": "\n",
+	"r": "\r",
+	"t": "	",
+	"v": "\v",
+	"0": "\0"
+};
+var decodeRangeCharacter = (raw) => {
+	if (!raw.startsWith("\\") || /^\\[dDwWsS]$/.test(raw)) return raw;
+	const escape = raw.slice(1);
+	if (escape in rangeEscapeCharacters) return rangeEscapeCharacters[escape];
+	if (/^c[A-Za-z]$/.test(escape)) return String.fromCharCode(escape.charCodeAt(1) % 32);
+	if (/^x[0-9A-Fa-f]{2}$/.test(escape)) return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+	if (/^u[0-9A-Fa-f]{4}$/.test(escape)) return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+	if (/^u\{[0-9A-Fa-f]{1,6}\}$/.test(escape)) return String.fromCodePoint(Number.parseInt(escape.slice(2, -1), 16));
+	return escape;
+};
+var Parser = class {
+	constructor(regex, { idGenerator, escapeBackslash = false, flags = [] } = {}) {
+		this.escapeBackslash = false;
+		this.literal = false;
+		this.flags = [];
+		this.message = "";
+		this.groupIndex = 1;
+		this.regex = regex;
+		this.escapeBackslash = escapeBackslash;
+		this.flags = flags;
+		let id = 0;
+		this.idGenerator = idGenerator !== null && idGenerator !== void 0 ? idGenerator : (() => `regex-vis-${id++}`);
+	}
+	parse() {
+		if (!this.validate()) return {
+			type: "error",
+			message: this.message
+		};
+		this.lexer = new Lexer(this.regex, this.escapeBackslash, this.unicodeMode);
+		const body = this.parseNodes();
+		return {
+			id: this.id(),
+			type: "regex",
+			body,
+			flags: this.flags,
+			literal: this.literal,
+			escapeBackslash: this.escapeBackslash
+		};
+	}
+	id() {
+		return this.idGenerator();
+	}
+	get unicodeMode() {
+		return this.flags.includes("u");
+	}
+	parseNodes() {
+		const branches = [];
+		let nodes = [];
+		const pushCharacterString = (str, quantifier) => {
+			let qStr = "";
+			if (quantifier) {
+				qStr = str.slice(-1);
+				str = str.slice(0, str.length - 1);
+			}
+			if (str && nodes.length > 0) {
+				const lastNode = nodes[nodes.length - 1];
+				if (lastNode.type === "character" && lastNode.kind === "string" && !lastNode.quantifier) {
+					lastNode.value += str;
+					str = "";
+				}
+			}
+			if (str) nodes.push({
+				id: this.id(),
+				type: "character",
+				kind: "string",
+				value: str,
+				quantifier: null
+			});
+			if (qStr) nodes.push({
+				id: this.id(),
+				type: "character",
+				kind: "string",
+				value: qStr,
+				quantifier
+			});
+		};
+		while (true) {
+			const { type, span: { start, end } } = this.lexer.read();
+			switch (type) {
+				case TokenType.GraphEnd:
+				case TokenType.RegexBodyEnd: if (branches.length > 0) {
+					if (nodes.length === 0) nodes.push({
+						id: this.id(),
+						type: "character",
+						kind: "string",
+						value: "",
+						quantifier: null
+					});
+					branches.push(nodes);
+					return [{
+						id: this.id(),
+						type: "choice",
+						branches
+					}];
+				} else return nodes;
+				case TokenType.CharacterClass: {
+					const value = this.regex.slice(start, end);
+					const quantifier = this.parseQuantifier();
+					nodes.push({
+						id: this.id(),
+						type: "character",
+						kind: "class",
+						value,
+						quantifier
+					});
+					break;
+				}
+				case TokenType.BackReference: {
+					const ref = this.regex[start + 1] === "k" ? this.regex.slice(start + 3, end - 1) : this.regex.slice(start + 1, end);
+					const quantifier = this.parseQuantifier();
+					nodes.push({
+						id: this.id(),
+						type: "backReference",
+						ref,
+						quantifier
+					});
+					break;
+				}
+				case TokenType.Assertion: {
+					const value = this.regex.slice(start, end);
+					let node = {
+						id: this.id(),
+						type: "boundaryAssertion",
+						kind: "beginning"
+					};
+					switch (value) {
+						case "\\b":
+							node = _objectSpread2(_objectSpread2({}, node), {}, {
+								kind: "word",
+								negate: false
+							});
+							break;
+						case "\\B":
+							node = _objectSpread2(_objectSpread2({}, node), {}, {
+								kind: "word",
+								negate: true
+							});
+							break;
+						case "$": node = _objectSpread2(_objectSpread2({}, node), {}, { kind: "end" });
+					}
+					nodes.push(node);
+					break;
+				}
+				case TokenType.NormalCharacter:
+					pushCharacterString(this.regex.slice(start, end), this.parseQuantifier());
+					break;
+				case TokenType.EscapedChar:
+					pushCharacterString(this.regex.slice(end - 1, end), this.parseQuantifier());
+					break;
+				case TokenType.GroupStart: {
+					const matches = this.lexer.readByRegex(lookAround);
+					if (matches) {
+						const lookAround = lookAround$1.get(matches[0]);
+						nodes.push(this.parseLookAround(lookAround));
+					} else nodes.push(this.parseGroup());
+					break;
+				}
+				case TokenType.RangeStart:
+					nodes.push(this.parseRanges(start));
+					break;
+				case TokenType.Choice:
+					if (nodes.length === 0) nodes.push({
+						id: this.id(),
+						type: "character",
+						kind: "string",
+						value: "",
+						quantifier: null
+					});
+					branches.push(nodes);
+					nodes = [];
+			}
+		}
+	}
+	parseQuantifier() {
+		let quantifier$1 = null;
+		const target = this.lexer.readTargets([
+			"?",
+			"+",
+			"*"
+		]);
+		if (target) switch (target) {
+			case "?":
+				quantifier$1 = {
+					kind: "?",
+					min: 0,
+					max: 1,
+					greedy: true
+				};
+				break;
+			case "+":
+				quantifier$1 = {
+					kind: "+",
+					min: 1,
+					max: Infinity,
+					greedy: true
+				};
+				break;
+			case "*": quantifier$1 = {
+				kind: "*",
+				min: 0,
+				max: Infinity,
+				greedy: true
+			};
+		}
+		else {
+			const matches = this.lexer.readByRegex(quantifier);
+			if (matches) {
+				const min = Number.parseInt(matches[1]);
+				let max = min;
+				if (matches[2]) {
+					max = Infinity;
+					if (matches[3]) max = Number.parseInt(matches[3]);
+				}
+				quantifier$1 = {
+					kind: "custom",
+					min,
+					max,
+					greedy: true
+				};
+			}
+		}
+		if (quantifier$1) {
+			if (this.lexer.readTarget("?")) quantifier$1.greedy = false;
+		}
+		return quantifier$1;
+	}
+	parseRanges(rangeStart) {
+		const ranges = [];
+		let negate = false;
+		if (this.lexer.readTarget("^")) negate = true;
+		let from = null;
+		const pushCharacter = (value) => {
+			ranges.push({
+				id: this.id(),
+				from: value,
+				to: value
+			});
+		};
+		while (true) {
+			const { type, span: { start, end } } = this.lexer.readRange();
+			if (type === TokenType.RangeEnd) break;
+			const raw = this.regex.slice(start, end);
+			const isCharacterSet = type === TokenType.CharacterClass && (/^\\[dDwWsS]$/.test(raw) || this.unicodeMode && /^\\[pP]\{[^}]*\}$/.test(raw));
+			const value = decodeRangeCharacter(raw);
+			if (from) {
+				if (isCharacterSet) {
+					pushCharacter(from);
+					pushCharacter("-");
+					pushCharacter(raw);
+				} else ranges.push({
+					id: this.id(),
+					from,
+					to: value
+				});
+				from = null;
+				continue;
+			}
+			if (!isCharacterSet && this.lexer.readTarget("-")) {
+				from = value;
+				continue;
+			}
+			pushCharacter(isCharacterSet ? raw : value);
+		}
+		if (from) {
+			pushCharacter(from);
+			pushCharacter("-");
+		}
+		const rangeEnd = this.lexer.index;
+		const quantifier = this.parseQuantifier();
+		return {
+			id: this.id(),
+			type: "character",
+			kind: "ranges",
+			raw: this.regex.slice(rangeStart, rangeEnd),
+			ranges,
+			negate,
+			quantifier
+		};
+	}
+	parseGroup() {
+		let group = { kind: "nonCapturing" };
+		const matches = this.lexer.readByRegex(namedCapturing);
+		if (matches) group = {
+			kind: "namedCapturing",
+			name: matches[1],
+			index: this.groupIndex++
+		};
+		else if (!this.lexer.readByRegex(nonCapturing)) {
+			const index = this.groupIndex++;
+			group = {
+				kind: "capturing",
+				index,
+				name: index.toString()
+			};
+		}
+		const children = this.parseNodes();
+		const quantifier = this.parseQuantifier();
+		return _objectSpread2(_objectSpread2({
+			id: this.id(),
+			type: "group"
+		}, group), {}, {
+			children,
+			quantifier
+		});
+	}
+	parseLookAround(lookAround) {
+		const children = this.parseNodes();
+		const quantifier = this.parseQuantifier();
+		return _objectSpread2(_objectSpread2({
+			id: this.id(),
+			type: "lookAroundAssertion"
+		}, lookAround), {}, {
+			children,
+			quantifier
+		});
+	}
+	validate() {
+		try {
+			if (this.validateAsLiteral()) this.literal = true;
+			let regex = this.regex;
+			if (this.escapeBackslash) regex = removeBackslash(regex);
+			new RegExp(regex, this.flags.join(""));
+		} catch (error) {
+			if (error instanceof Error) this.message = error.message;
+			return false;
+		}
+		return true;
+	}
+	validateAsLiteral() {
+		const start = this.regex.indexOf("/");
+		const end = this.regex.lastIndexOf("/");
+		if (start !== 0 || end === 0) return false;
+		const flags = this.regex.slice(end + 1);
+		new RegExp("", flags);
+		this.flags = flags.split("");
+		this.regex = this.regex.slice(start + 1, end);
+		return true;
+	}
+};
+//#endregion
+export { Parser };

package/es/regex-vis/parser/patterns.d.ts

@@ -0,0 +1,16 @@
+export declare const flag: RegExp;
+export declare const cX: RegExp;
+export declare const xhh: RegExp;
+export declare const uhhhh: RegExp;
+export declare const digit: RegExp;
+export declare const comma: RegExp;
+export declare const lookAround: RegExp;
+export declare const nonCapturing: RegExp;
+export declare const namedCapturing: RegExp;
+export declare const quantifier: RegExp;
+export declare const specialCharacter: RegExp;
+export declare const characterClass: RegExp;
+export declare const unicodeCodePoint: RegExp;
+export declare const unicodeProperty: RegExp;
+export declare const backReference: RegExp;
+export declare const escapeSequences: RegExp;

package/es/regex-vis/parser/patterns.js

@@ -0,0 +1,15 @@
+//#region components/regex-vis/parser/patterns.ts
+var lookAround = /^(\?=|\?!|\?<=|\?<!)/;
+var nonCapturing = /^\?:/;
+var unicodeEscape = String.raw`\\u(?:[0-9A-Fa-f]{4}|\{[0-9A-Fa-f]{1,6}\})`;
+var groupName = `${String.raw`(?:[$_\p{ID_Start}]|${unicodeEscape})`}${String.raw`(?:[$\u200C\u200D\p{ID_Continue}]|${unicodeEscape})`}*`;
+var namedCapturing = new RegExp(`^\\?<(${groupName})>`, "u");
+var quantifier = /^\{(\d+)(,|,(\d+))?\}/;
+var specialCharacter = /[()[|\\.^$?+*]|\{(\d+)(,|,(\d+))?\}/;
+var characterClass = /^\\(?:[dDwWsStrnvf0]|c[A-Za-z]|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})/;
+var unicodeCodePoint = /^\\u\{[0-9A-Fa-f]{1,6}\}/;
+var unicodeProperty = /^\\[pP]\{[^}]+\}/;
+var backReference = new RegExp(`^\\\\(\\d+|k<(${groupName})>)`, "u");
+var escapeSequences = /^\\(?:[0nrtbfv]|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{2}|u\{[0-9A-Fa-f]{1,6}\})/;
+//#endregion
+export { backReference, characterClass, escapeSequences, lookAround, namedCapturing, nonCapturing, quantifier, specialCharacter, unicodeCodePoint, unicodeProperty };

package/es/regex-vis/parser/token.d.ts

@@ -0,0 +1,23 @@
+type Span = {
+    start: number;
+    end: number;
+};
+export declare enum TokenType {
+    RegexBodyStart = 0,
+    RegexBodyEnd = 1,
+    NormalCharacter = 2,
+    GroupStart = 3,
+    GraphEnd = 4,
+    RangeStart = 5,
+    RangeEnd = 6,
+    Choice = 7,
+    CharacterClass = 8,
+    EscapedChar = 9,
+    Assertion = 10,
+    BackReference = 11
+}
+export type Token = {
+    type: TokenType;
+    span: Span;
+};
+export {};

package/es/regex-vis/parser/token.js

@@ -0,0 +1,18 @@
+//#region components/regex-vis/parser/token.ts
+var TokenType = /* @__PURE__ */ function(TokenType) {
+	TokenType[TokenType["RegexBodyStart"] = 0] = "RegexBodyStart";
+	TokenType[TokenType["RegexBodyEnd"] = 1] = "RegexBodyEnd";
+	TokenType[TokenType["NormalCharacter"] = 2] = "NormalCharacter";
+	TokenType[TokenType["GroupStart"] = 3] = "GroupStart";
+	TokenType[TokenType["GraphEnd"] = 4] = "GraphEnd";
+	TokenType[TokenType["RangeStart"] = 5] = "RangeStart";
+	TokenType[TokenType["RangeEnd"] = 6] = "RangeEnd";
+	TokenType[TokenType["Choice"] = 7] = "Choice";
+	TokenType[TokenType["CharacterClass"] = 8] = "CharacterClass";
+	TokenType[TokenType["EscapedChar"] = 9] = "EscapedChar";
+	TokenType[TokenType["Assertion"] = 10] = "Assertion";
+	TokenType[TokenType["BackReference"] = 11] = "BackReference";
+	return TokenType;
+}({});
+//#endregion
+export { TokenType };

package/es/regex-vis/regex-vis.js

@@ -0,0 +1,5 @@
+import regex_vis_vue_vue_type_script_setup_true_lang_default from "./regex-vis.vue_vue_type_script_setup_true_lang.js";
+//#region components/regex-vis/regex-vis.vue
+var regex_vis_default = regex_vis_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { regex_vis_default as default };

package/es/regex-vis/regex-vis.vue.d.ts

@@ -0,0 +1,27 @@
+import type { RegexVisFlag, RegexVisProps, RegexVisSelectInfo, RegexVisSlots } from './types';
+type __VLS_Props = Omit<RegexVisProps, 'modelValue' | 'flags'>;
+type __VLS_Slots = RegexVisSlots;
+type __VLS_ModelProps = {
+    modelValue?: string;
+    'flags'?: RegexVisFlag[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (error: import("./parser").RegexError | undefined) => any;
+    select: (info: RegexVisSelectInfo) => any;
+    "update:modelValue": (value: string) => any;
+    "update:flags": (value: import("./parser").Flag[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onError?: ((error: import("./parser").RegexError | undefined) => any) | undefined;
+    onSelect?: ((info: RegexVisSelectInfo) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:flags"?: ((value: import("./parser").Flag[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};