@sdata/web-vue 4.3.1 → 4.4.1

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

@@ -0,0 +1,155 @@
+export type Regex = {
+    id: string;
+    type: 'regex';
+    body: Node[];
+    flags: Flag[];
+    literal: boolean;
+    escapeBackslash: boolean;
+};
+export type RegexError = {
+    type: 'error';
+    message: string;
+};
+export type Flag = 'd' | 'g' | 'i' | 'm' | 's' | 'u' | 'y';
+export type Quantifier = {
+    kind: '?';
+    min: 0;
+    max: 1;
+    greedy: boolean;
+} | {
+    kind: '*';
+    min: 0;
+    max: typeof Infinity;
+    greedy: boolean;
+} | {
+    kind: '+';
+    min: 1;
+    max: typeof Infinity;
+    greedy: boolean;
+} | {
+    kind: 'custom';
+    min: number;
+    max: number;
+    greedy: boolean;
+};
+export type NodeBase = {
+    id: string;
+    type: string;
+};
+export type StringCharacterNode = {
+    type: 'character';
+    kind: 'string';
+    value: string;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type Range = {
+    id: string;
+    from: string;
+    to: string;
+};
+export type RangesCharacterNode = {
+    type: 'character';
+    kind: 'ranges';
+    raw: string;
+    ranges: Range[];
+    negate: boolean;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type ClassCharacterNode = {
+    type: 'character';
+    kind: 'class';
+    value: string;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type RangesCharacter = {
+    kind: 'ranges';
+    ranges: Range[];
+    negate: boolean;
+};
+export type CharacterNode = StringCharacterNode | RangesCharacterNode | ClassCharacterNode;
+export type GroupKind = 'capturing' | 'nonCapturing' | 'namedCapturing';
+export type Group = {
+    kind: 'nonCapturing';
+} | {
+    kind: 'namedCapturing' | 'capturing';
+    name: string;
+    index: number;
+};
+export type NonCapturingGroupNode = {
+    type: 'group';
+    kind: 'nonCapturing';
+    children: Node[];
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type NamedCapturingGroupNode = {
+    type: 'group';
+    kind: 'namedCapturing';
+    children: Node[];
+    name: string;
+    index: number;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type CapturingGroupNode = {
+    type: 'group';
+    kind: 'capturing';
+    children: Node[];
+    name: string;
+    index: number;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type GroupNode = NonCapturingGroupNode | NamedCapturingGroupNode | CapturingGroupNode;
+export type ChoiceNode = {
+    type: 'choice';
+    branches: Node[][];
+} & NodeBase;
+export type BeginningBoundaryAssertionNode = {
+    type: 'boundaryAssertion';
+    kind: 'beginning';
+} & NodeBase;
+export type EndBoundaryAssertionNode = {
+    type: 'boundaryAssertion';
+    kind: 'end';
+} & NodeBase;
+export type WordBoundaryAssertionNode = {
+    type: 'boundaryAssertion';
+    kind: 'word';
+    negate: boolean;
+} & NodeBase;
+export type LookAround = {
+    kind: 'lookahead' | 'lookbehind';
+    negate: boolean;
+};
+export type LookAroundAssertionNode = {
+    type: 'lookAroundAssertion';
+    kind: 'lookahead' | 'lookbehind';
+    negate: boolean;
+    children: Node[];
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type AssertionNode = BeginningBoundaryAssertionNode | EndBoundaryAssertionNode | WordBoundaryAssertionNode | LookAroundAssertionNode;
+export type BackReferenceNode = {
+    type: 'backReference';
+    ref: string;
+    quantifier: Quantifier | null;
+} & NodeBase;
+export type Content = {
+    kind: 'string' | 'class';
+    value: string;
+} | {
+    kind: 'ranges';
+    ranges: Range[];
+    negate: boolean;
+} | {
+    kind: 'backReference';
+    ref: string;
+} | {
+    kind: 'beginningAssertion' | 'endAssertion';
+} | {
+    kind: 'wordBoundaryAssertion';
+    negate: boolean;
+};
+export type RootNode = {
+    type: 'root';
+} & NodeBase;
+export type Node = CharacterNode | GroupNode | ChoiceNode | RootNode | AssertionNode | BackReferenceNode;
+export type ParentNode = Regex | GroupNode | ChoiceNode | LookAroundAssertionNode;

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

@@ -0,0 +1 @@
+export declare const removeBackslash: (str: string) => string;

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

@@ -0,0 +1,25 @@
+import { escapeSequences } from "./patterns.js";
+//#region components/regex-vis/parser/backslash.ts
+var removeBackslash = (str) => {
+	let result = "";
+	let index = 0;
+	while (index < str.length) {
+		if (str[index] === "\\") {
+			const matches = str.slice(index).match(escapeSequences);
+			if (matches) {
+				result += matches[0];
+				index += matches[0].length;
+			} else {
+				if (index === str.length - 1) throw new Error("Invalid escape sequence");
+				result += str[index + 1];
+				index += 2;
+			}
+			continue;
+		}
+		result += str[index];
+		index++;
+	}
+	return result;
+};
+//#endregion
+export { removeBackslash };

package/es/regex-vis/parser/character-class.d.ts

@@ -0,0 +1,25 @@
+export declare const characterClassTextMap: {
+    '.': string;
+    '\\d': string;
+    '\\D': string;
+    '\\w': string;
+    '\\W': string;
+    '\\s': string;
+    '\\S': string;
+    '\\t': string;
+    '\\r': string;
+    '\\n': string;
+    '\\v': string;
+    '\\f': string;
+    '[\\b]': string;
+    '\\0': string;
+    '\\cH': string;
+    '\\cI': string;
+    '\\cJ': string;
+    '\\cK': string;
+    '\\cL': string;
+    '\\cM': string;
+    '\\xhh': string;
+    '\\uhhhh': string;
+};
+export type CharacterClassKey = keyof typeof characterClassTextMap;

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

@@ -0,0 +1,4 @@
+import type * as AST from './ast';
+import { TokenType } from './token';
+export declare const token: Map<string, TokenType>;
+export declare const lookAround: Map<string, AST.LookAround>;

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

@@ -0,0 +1,28 @@
+import { TokenType } from "./token.js";
+//#region components/regex-vis/parser/dict.ts
+var token = new Map(Object.entries({
+	"(": TokenType.GroupStart,
+	")": TokenType.GraphEnd,
+	"[": TokenType.RangeStart,
+	"|": TokenType.Choice
+}));
+var lookAround = new Map(Object.entries({
+	"?=": {
+		kind: "lookahead",
+		negate: false
+	},
+	"?!": {
+		kind: "lookahead",
+		negate: true
+	},
+	"?<=": {
+		kind: "lookbehind",
+		negate: false
+	},
+	"?<!": {
+		kind: "lookbehind",
+		negate: true
+	}
+}));
+//#endregion
+export { lookAround, token };

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

@@ -0,0 +1,2 @@
+export type * from './ast';
+export { default as parseRegex } from './parse';

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

@@ -0,0 +1,20 @@
+import type { Token } from './token';
+import { TokenType } from './token';
+declare class Lexer {
+    regex: string;
+    index: number;
+    escapeBackslash: boolean;
+    unicodeMode: boolean;
+    constructor(regex: string, escapeBackslash: boolean, unicodeMode?: boolean);
+    get curRegex(): string;
+    read(): Token;
+    token(type: TokenType, size?: number): Token;
+    readBackslash(range?: boolean): Token;
+    readTarget(target: string): boolean;
+    readTargets(targets: string[]): string | null;
+    readByRegex(r: RegExp): RegExpMatchArray | null;
+    readNormalCharacters(): Token | null;
+    readRange(): Token;
+    advance(size: number): number;
+}
+export default Lexer;

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

@@ -0,0 +1,179 @@
+import { backReference, characterClass, escapeSequences, specialCharacter, unicodeCodePoint, unicodeProperty } from "./patterns.js";
+import { TokenType } from "./token.js";
+import { token } from "./dict.js";
+//#region components/regex-vis/parser/lexer.ts
+var Lexer = class {
+	constructor(regex, escapeBackslash, unicodeMode = false) {
+		this.index = 0;
+		this.escapeBackslash = false;
+		this.unicodeMode = false;
+		this.regex = regex;
+		this.escapeBackslash = escapeBackslash;
+		this.unicodeMode = unicodeMode;
+	}
+	get curRegex() {
+		return this.regex.slice(this.index);
+	}
+	read() {
+		const normalCharacters = this.readNormalCharacters();
+		if (normalCharacters) return normalCharacters;
+		const char = this.curRegex[0];
+		switch (char) {
+			case "\\": return this.readBackslash();
+			case ".": return this.token(TokenType.CharacterClass);
+			case "^":
+			case "$": return this.token(TokenType.Assertion);
+			case void 0: return this.token(TokenType.RegexBodyEnd);
+			default: {
+				const type = token.get(char);
+				if (type) return this.token(type);
+				return this.token(TokenType.NormalCharacter);
+			}
+		}
+	}
+	token(type, size = 1) {
+		return {
+			type,
+			span: {
+				start: this.index,
+				end: this.advance(size)
+			}
+		};
+	}
+	readBackslash(range = false) {
+		let start = this.index;
+		if (this.escapeBackslash) {
+			if (this.readByRegex(escapeSequences)) return {
+				type: TokenType.CharacterClass,
+				span: {
+					start,
+					end: this.index
+				}
+			};
+			if (this.curRegex[1] !== "\\") return {
+				type: TokenType.EscapedChar,
+				span: {
+					start,
+					end: this.advance(2)
+				}
+			};
+			this.advance(1);
+			start++;
+		}
+		if (this.readByRegex(characterClass)) return {
+			type: TokenType.CharacterClass,
+			span: {
+				start,
+				end: this.index
+			}
+		};
+		if (this.unicodeMode) {
+			if (this.readByRegex(unicodeCodePoint) || this.readByRegex(unicodeProperty)) return {
+				type: TokenType.CharacterClass,
+				span: {
+					start,
+					end: this.index
+				}
+			};
+		}
+		if (range) {
+			if (this.curRegex[1] === "b") return {
+				type: TokenType.CharacterClass,
+				span: {
+					start,
+					end: this.advance(2)
+				}
+			};
+		} else {
+			const curRegex = this.curRegex;
+			if (curRegex[1] === "b" || curRegex[1] === "B") return {
+				type: TokenType.Assertion,
+				span: {
+					start,
+					end: this.advance(2)
+				}
+			};
+			if (this.readByRegex(backReference)) return {
+				type: TokenType.BackReference,
+				span: {
+					start,
+					end: this.index
+				}
+			};
+		}
+		return {
+			type: TokenType.EscapedChar,
+			span: {
+				start,
+				end: this.advance(2)
+			}
+		};
+	}
+	readTarget(target) {
+		if (target === this.regex[this.index]) {
+			this.advance(1);
+			return true;
+		}
+		return false;
+	}
+	readTargets(targets) {
+		const char = this.regex[this.index];
+		const index = targets.indexOf(char);
+		if (index !== -1) {
+			this.advance(1);
+			return targets[index];
+		}
+		return null;
+	}
+	readByRegex(r) {
+		const matches = this.regex.slice(this.index).match(r);
+		if (matches) this.advance(matches[0].length);
+		return matches;
+	}
+	readNormalCharacters() {
+		const start = this.index;
+		const curRegex = this.curRegex;
+		if (curRegex === "") return null;
+		const matches = curRegex.match(specialCharacter);
+		if (matches) {
+			if (matches.index) return {
+				type: TokenType.NormalCharacter,
+				span: {
+					start,
+					end: this.advance(matches.index)
+				}
+			};
+			return null;
+		}
+		return {
+			type: TokenType.NormalCharacter,
+			span: {
+				start,
+				end: this.advance(curRegex.length)
+			}
+		};
+	}
+	readRange() {
+		const start = this.index;
+		if (this.readTarget("]")) return {
+			type: TokenType.RangeEnd,
+			span: {
+				start,
+				end: this.index
+			}
+		};
+		if (this.curRegex[0] === "\\") return this.readBackslash(true);
+		return {
+			type: TokenType.NormalCharacter,
+			span: {
+				start,
+				end: this.advance(1)
+			}
+		};
+	}
+	advance(size) {
+		return this.index += size;
+	}
+};
+//#endregion
+export { Lexer as default };

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

@@ -0,0 +1,3 @@
+import type { Options } from './parser';
+declare function parse(regex: string, options?: Options): import("./ast").Regex | import("./ast").RegexError;
+export default parse;

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

@@ -0,0 +1,7 @@
+import { Parser } from "./parser.js";
+//#region components/regex-vis/parser/parse.ts
+function parse(regex, options = {}) {
+	return new Parser(regex, options).parse();
+}
+//#endregion
+export { parse as default };

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

@@ -0,0 +1,28 @@
+import type * as AST from './ast';
+import Lexer from './lexer';
+export type Options = {
+    escapeBackslash?: boolean;
+    flags?: AST.Flag[];
+    idGenerator?: (size?: number) => string;
+};
+export declare class Parser {
+    regex: string;
+    escapeBackslash: boolean;
+    literal: boolean;
+    flags: AST.Flag[];
+    message: string;
+    lexer: Lexer;
+    groupIndex: number;
+    idGenerator: (size?: number) => string;
+    constructor(regex: string, { idGenerator, escapeBackslash, flags }?: Options);
+    parse(): AST.Regex | AST.RegexError;
+    id(): string;
+    get unicodeMode(): boolean;
+    parseNodes(): AST.Node[];
+    parseQuantifier(): AST.Quantifier | null;
+    parseRanges(rangeStart: number): AST.Node;
+    parseGroup(): AST.Node;
+    parseLookAround(lookAround: AST.LookAround): AST.Node;
+    validate(): boolean;
+    validateAsLiteral(): boolean;
+}