@atscript/core 0.0.17 → 0.0.19

package/dist/index.cjs

@@ -334,11 +334,11 @@ var Token = class Token {
 		* All the import tokens must be marked with this flag
 		*/ _define_property$12(this, "imported", void 0);
 		/**
-		* All the props must be marked with this flag
-		*/ _define_property$12(this, "isProp", void 0);
-		/**
 		* Refs chained via . or ["propName"] are marked with this flag
 		*/ _define_property$12(this, "isChain", void 0);
+		/**
+		* Prop patterns ([*] or [regexp]) are storing patterns here
+		*/ _define_property$12(this, "pattern", void 0);
 		_define_property$12(this, "parentNode", void 0);
 		/**
 		* Only for annotation arguments: reference to their annotation token
@@ -509,6 +509,9 @@ var SemanticPropNode = class extends SemanticNode {
 		const token = this.token("identifier");
 		if (token && token.type === "text" && token.multiline) doc.registerMessage(token, "Unexpected end of string");
 	}
+	get isPattern() {
+		return !!this.token("identifier")?.pattern;
+	}
 	get nestedProps() {
 		if (this.definition && isStructure(this.definition)) return this.definition.props;
 	}
@@ -966,7 +969,10 @@ async function findConfigFileName(d) {
 async function loadTsConfig(configFile, forceFormat) {
 	const file = await bundleTsConfig(configFile, forceFormat);
 	try {
-		return (await import((0, node_url.pathToFileURL)(file).href)).default;
+		return (await import(
+			/* @vite-ignore */
+			(0, node_url.pathToFileURL)(file).href
+)).default;
 	} catch (error) {
 		console.error("Could not load config file", file, error);
 		return {};
@@ -977,7 +983,10 @@ async function loadTsConfig(configFile, forceFormat) {
 async function loadConfig(configPath, forceFormat) {
 	const ext = node_path.default.extname(configPath);
 	try {
-		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext)) return forceFormat ? await loadTsConfig(node_path.default.resolve(configPath), forceFormat) : (await import((0, node_url.pathToFileURL)(configPath).href)).default;
+		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext)) return forceFormat ? await loadTsConfig(node_path.default.resolve(configPath), forceFormat) : (await import(
+			/* @vite-ignore */
+			(0, node_url.pathToFileURL)(configPath).href
+)).default;
 else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) {
 			const rawConfigPath = node_path.default.resolve(configPath);
 			return await loadTsConfig(rawConfigPath, forceFormat);
@@ -1088,9 +1097,6 @@ var NodeIterator = class NodeIterator {
 		this.$ = this.nodes[this.i];
 		return this;
 	}
-	/** @deprecated */ killNextNode(n = 1) {
-		this.nodes.splice(this.i + 1, n);
-	}
 	next(skip) {
 		return this.fork().move().skip(skip);
 	}
@@ -1270,8 +1276,8 @@ const IdentifierToken = new __prostojs_parser.BasicNode({
 //#region packages/core/src/tokenizer/tokens/number.token.ts
 const NumberToken = new __prostojs_parser.BasicNode({
 	icon: "N",
-	tokens: [RegExp("\\d[\\p{ID_Continue}$]*", "u"), RegExp("[^\\p{ID_Continue}$]", "u")],
-	tokenOE: "consume-eject"
+	tokens: [/[-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/u, /[^\d]/u],
+	tokenOE: "-eject"
 }).mapContent("text", "join-clear").onMatch((context) => {
 	context.customData.type = "number";
 });
@@ -1279,7 +1285,7 @@ const NumberToken = new __prostojs_parser.BasicNode({
 //#endregion
 //#region packages/core/src/tokenizer/tokens/punctuation.token.ts
 const PunctuationToken = new __prostojs_parser.BasicNode({
-	tokens: [RegExp("(?<text>[\\n!&+,\\-./:;=?|])", "u"), ""],
+	tokens: [RegExp("(?<text>[\\n!&+,./:;=?|])", "u"), ""],
 	tokenOE: "omit-omit",
 	icon: "..."
 }).onMatch((context) => {
@@ -1299,6 +1305,19 @@ const TextToken = new __prostojs_parser.BasicNode({
 	context.customData.multiline = context.customData.end === "\n";
 });
 
+//#endregion
+//#region packages/core/src/tokenizer/tokens/regexp.token.ts
+const REGEXP_LITERAL_RE = /\/(?![/*])(?:\\.|\[.*?]|[^/\\\n\r[])*\/[dgimsuy]*/;
+const RegExpToken = new __prostojs_parser.BasicNode({
+	label: "regexp",
+	icon: "RG",
+	tokens: [REGEXP_LITERAL_RE, ""],
+	tokenOE: "omit-omit"
+}).onMatch((ctx) => {
+	ctx.customData.type = "regexp";
+	ctx.customData.text = ctx.matched[0];
+});
+
 //#endregion
 //#region packages/core/src/tokenizer/tokens/index.ts
 const tokens = {
@@ -1311,6 +1330,7 @@ const tokens = {
 	identifier: IdentifierToken,
 	number: NumberToken,
 	text: TextToken,
+	regexp: RegExpToken,
 	root: undefined
 };
 const root = new __prostojs_parser.BasicNode({
@@ -1318,7 +1338,7 @@ const root = new __prostojs_parser.BasicNode({
 	skipToken: /\s/u
 }).addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
 tokens.root = root;
-BlockToken.addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
+BlockToken.addRecognizes(tokens.regexp, ...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
 const mapContent = (content) => content.map((item) => {
 	if (typeof item === "string") return {
 		type: "unknown",
@@ -1353,6 +1373,7 @@ function $token(name, text$2) {
 			node: name,
 			text: text$2
 		}],
+		contains: undefined,
 		isGlobal: false,
 		empty: false,
 		wrapper: undefined,
@@ -1387,6 +1408,16 @@ function $token(name, text$2) {
 						ni.unexpected(false, `Expected empty block`);
 						return opts.optional;
 					}
+					if (opts.contains) {
+						if (!ni.$.children?.length) {
+							ni.unexpected(false, `Expected ${opts.contains.map((v) => v.text).join(", ")}`);
+							return opts.optional;
+						}
+						if (ni.$.children[0].type !== opts.contains[0].node || ni.$.children[0].text !== opts.contains[0].text) {
+							ni.unexpected(false, `Expected ${opts.contains.map((v) => v.text).join(", ")}`);
+							return opts.optional;
+						}
+					}
 					if (opts.saveAs) target.node.saveToken(new Token(ni.$), opts.saveAs);
 					ni.accepted();
 					if (opts.wrapper) {
@@ -1421,6 +1452,10 @@ else return true;
 			opts.empty = true;
 			return this;
 		},
+		contains(t) {
+			opts.contains = t.expect;
+			return this;
+		},
 		skip(...p) {
 			opts.skip = p;
 			return this;
@@ -1825,6 +1860,52 @@ function unwrap(attr) {
 		}
 	};
 }
+function propName() {
+	return { handler(ni, target) {
+		switch (ni.$?.type) {
+			case "identifier":
+			case "text":
+				target.node.saveToken(new Token(ni.$), "identifier");
+				ni.accepted();
+				ni.move();
+				ni.skip(["\n"]);
+				return true;
+			case "block":
+				const childrenLength = ni.$.children?.length || 0;
+				const firstText = ni.$.children?.[0]?.text;
+				if (ni.$.text === "[" && ni.$.children?.[0]?.type === "unknown" && childrenLength === 1 && ni.$.children[0].text === "*" || ni.$.text === "[" && ni.$.children?.[0]?.type === "regexp" && childrenLength === 1) {
+					const t = new Token({
+						...ni.$,
+						...ni.$.children[0]
+					});
+					try {
+						t.pattern = firstText === "*" ? /./ : parseRegExpLiteral(firstText);
+					} catch (e) {
+						ni.unexpected(false, e.message);
+						return false;
+					}
+					target.node.saveToken(t, "identifier");
+					ni.accepted();
+					ni.move();
+					ni.skip(["\n"]);
+					return true;
+				}
+				if (ni.$.text === "[" && !childrenLength) ni.unexpected(false, "Wildcard \"*\" or a Regular Expression expected");
+				if (ni.$.text === "[" && childrenLength > 1) ni.unexpected(false, firstText?.startsWith("/") ? "Invalid Regular Expression" : "To many arguments in prop pattern []");
+else ni.unexpected(false, "Unexpected identifier at property name");
+				return false;
+			default:
+				ni.unexpected(false, "Unexpected identifier at property name");
+				return false;
+		}
+	} };
+}
+function parseRegExpLiteral(literal) {
+	const match = literal.match(/^\/(.+)\/([dgimsuy]*)$/);
+	if (!match) throw new Error(`Invalid regexp literal: ${literal}`);
+	const [, pattern, flags] = match;
+	return new RegExp(pattern.replace(/\\\//g, "/"), flags);
+}
 
 //#endregion
 //#region packages/core/src/parser/pipes/pipes.ts
@@ -1832,9 +1913,9 @@ const ref = $pipe("ref", [refWithChain()]);
 const constText = defineValuePipe("const", "text", false);
 const constNumber = defineValuePipe("const", "number", false);
 const allowedValuesPipeArray = [
+	constNumber,
 	ref,
-	constText,
-	constNumber
+	constText
 ];
 const tuplePipeArray = [
 	block("[]").saveAs("identifier"),
@@ -1860,7 +1941,7 @@ const type = $pipe("type", [
 ]).skip("\n", ";");
 const props = $pipe("prop", [
 	annotations(),
-	identifier().or(text()).saveAs("identifier").skip("\n"),
+	propName(),
 	pun("?").saveAs("optional").optional().skip("\n"),
 	pun(":").skip("\n"),
 	definition(allowedValuesPipeArray).separatedBy("&", "|").skip("\n").respectPriority(),
@@ -1902,6 +1983,16 @@ const pipes = {
 	tuple
 };
 
+//#endregion
+//#region packages/core/src/parser/types.ts
+var TSeverity = /*#__PURE__*/ function(TSeverity$1) {
+	TSeverity$1[TSeverity$1["Error"] = 1] = "Error";
+	TSeverity$1[TSeverity$1["Warning"] = 2] = "Warning";
+	TSeverity$1[TSeverity$1["Info"] = 3] = "Info";
+	TSeverity$1[TSeverity$1["Hint"] = 4] = "Hint";
+	return TSeverity$1;
+}({});
+
 //#endregion
 //#region packages/core/src/token-index/blocks-index.ts
 function _define_property$5(obj, key, value) {
@@ -2448,6 +2539,63 @@ else if (isStructure(def) || isInterface(def) || isPrimitive(def)) def = def.pro
 		for (const [key, token] of Array.from(this.registry.definitions.entries())) if (!refSet.has(key) && !this.exports.has(key)) tokens$1.push(token);
 		return tokens$1;
 	}
+	renderDiagMessage(m, addSourceLinses = false, colors = false) {
+		const c = {
+			red: colors ? "\x1B[31m" : "",
+			blue: colors ? "\x1B[34m" : "",
+			cyan: colors ? "\x1B[36m" : "",
+			yellow: colors ? "\x1B[33m" : "",
+			dim: colors ? "\x1B[2m" : "",
+			reset: colors ? "\x1B[0m" : ""
+		};
+		let sc = "";
+		let banner = "[atscript]";
+		switch (m.severity) {
+			case TSeverity.Error:
+				sc = c.red;
+				banner += "[Error]";
+				break;
+			case TSeverity.Warning:
+				sc = c.yellow;
+				banner += "[Warning]";
+				break;
+			case TSeverity.Info:
+				sc = "";
+				banner += "[Info]";
+				break;
+			case TSeverity.Hint:
+				sc = c.dim;
+				banner += "[Hint]";
+				break;
+			default: sc = "";
+		}
+		const n = m.range.start.line + 1;
+		let out = `\n${sc}${banner} ${m.message}${c.reset}` + `\nin ${c.blue}${this.id}:${n}:${m.range.start.character + 1}${c.reset}`;
+		if (addSourceLinses) {
+			const lines = this.text.split("\n");
+			const renderLines = [
+				{
+					l: lines[n - 3],
+					i: n - 3
+				},
+				{
+					l: lines[n - 2],
+					i: n - 2
+				},
+				{
+					l: lines[n - 1],
+					i: n - 1
+				}
+			].filter(Boolean);
+			const nl = String(n).length + 1;
+			for (const { l, i } of renderLines) {
+				const prefix = `${c.dim + c.cyan}${("0" + i).slice(-nl)} | ${c.reset}`;
+				out += `\n${prefix}${l}${c.reset}`;
+			}
+			out += `\n${" ".repeat(nl + 3 + m.range.start.character)}${c.red}${"^".repeat(m.range.end.character - m.range.start.character)}${c.reset}`;
+		}
+		return out + "\n";
+	}
 	getDiagMessages() {
 		if (!this._allMessages) {
 			this._allMessages = [

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 interface TLexicalToken {
-    type: 'annotation' | 'comment' | 'punctuation' | 'identifier' | 'text' | 'number' | 'block' | 'unknown';
+    type: 'annotation' | 'comment' | 'punctuation' | 'identifier' | 'text' | 'number' | 'block' | 'unknown' | 'regexp';
     text: string;
     children?: TLexicalToken[];
     startOffset?: number;
@@ -24,7 +24,7 @@ declare class Token {
     toString(): string;
     clone(replace: Partial<TLexicalToken>): Token;
     get text(): string;
-    get type(): "number" | "annotation" | "comment" | "punctuation" | "identifier" | "text" | "block" | "unknown";
+    get type(): "number" | "annotation" | "comment" | "punctuation" | "identifier" | "text" | "block" | "unknown" | "regexp";
     get range(): {
         start: {
             line: number;
@@ -37,18 +37,48 @@ declare class Token {
     };
     get children(): TLexicalToken[];
     get hasChildren(): boolean;
+    /**
+     * This is truth if the text token was ended with a newline character
+     */
     get multiline(): boolean | undefined;
+    /**
+     * Set this to file path (e.g. "./src/file.as") for path token in import statement
+     */
     fromPath?: string;
+    /**
+     * All definitions that exported must be marked with this flag
+     */
     exported?: boolean;
+    /**
+     * All the definitions must be marked with this flag
+     */
     isDefinition?: boolean;
+    /**
+     * All the references must be marked with this flag
+     */
     isReference?: boolean;
+    /**
+     * All the import tokens must be marked with this flag
+     */
     imported?: boolean;
-    isProp?: boolean;
+    /**
+     * Refs chained via . or ["propName"] are marked with this flag
+     */
     isChain?: boolean;
+    /**
+     * Prop patterns ([*] or [regexp]) are storing patterns here
+     */
+    pattern?: RegExp;
     parentNode?: SemanticNode;
     get isAnnotation(): boolean;
+    /**
+     * Only for annotation arguments: reference to their annotation token
+     */
     annotationRef?: Token;
     index?: number;
+    /**
+     * Block type
+     */
     blockType?: 'structure' | 'type' | 'import';
 }
 
@@ -62,9 +92,18 @@ declare class AtscriptRepo {
     readonly sharedConfig?: TAtscriptConfigInput | undefined;
     constructor(root?: string, sharedConfig?: TAtscriptConfigInput | undefined);
     protected configFormat?: 'esm' | 'cjs';
+    /**
+     * Configs cache
+     */
     protected readonly configs: Map<string, Promise<TPluginManagers>>;
+    /**
+     * .as Documents cache
+     */
     protected readonly atscripts: Map<string, Promise<AtscriptDoc>>;
     sharedPluginManager: TPluginManagers | undefined;
+    /**
+     * cache for raw content of config files
+     */
     protected configFiles: Map<string, Promise<Partial<TAtscriptConfigInput & TAtscriptConfigOutput>>>;
     getSharedPluginManager(): PluginManager | undefined;
     getPrimitivesTags(): Promise<Set<string> | undefined>;
@@ -92,7 +131,7 @@ declare class AtscriptRepo {
     checkImport(atscript: AtscriptDoc, from: Token, imports: Token[]): Promise<AtscriptDoc | undefined>;
 }
 
-type TPunctuation = '\n' | '&' | '+' | ',' | '\\' | '-' | '.' | '/' | ':' | '=' | '?' | '|' | ';';
+type TPunctuation = '\n' | '&' | '+' | ',' | '\\' | '.' | '/' | ':' | '=' | '?' | '|' | ';';
 
 declare enum TSeverity {
     Error = 1,
@@ -219,6 +258,7 @@ interface TPrimitiveTypeArray {
 interface TPrimitiveTypeObject {
     kind: 'object';
     props: Record<string, TPrimitiveTypeDef>;
+    propsPatterns: Record<string, TPrimitiveTypeDef>;
     optional?: boolean;
 }
 type TPrimitiveTypeFinal = 'string' | 'number' | 'boolean' | 'void' | 'null';
@@ -245,9 +285,28 @@ declare class SemanticPrimitiveNode extends SemanticNode {
     toString(level?: number, prefix?: string): string;
 }
 
+/**
+ * Interface for a token index system that allows adding tokens and querying the most nested token at a specific position.
+ */
 interface ITokensIndex {
+    /**
+     * Adds a new token to the index.
+     * @param token - The token to add.
+     */
     add: (token: Token) => void;
+    /**
+     * Finds token at a specific position.
+     * @param line - The line number of the position.
+     * @param character - The character number of the position.
+     * @returns The token at the given position, or `undefined` if no token is found.
+     */
     at: (line: number, character: number) => Token | undefined;
+    /**
+     * Finds token before specific position.
+     * @param line - The line number of the position.
+     * @param character - The character number of the position.
+     * @returns The token at the given position, or `undefined` if no token is found.
+     */
     before: (line: number, character: number) => Token | undefined;
 }
 
@@ -266,17 +325,44 @@ declare class AtscriptDoc {
     readonly registry: IdRegistry;
     semanticMessages: TMessages;
     messages: TMessages;
+    /**
+     * All the non-blocks tokens, that could be referred
+     */
     tokensIndex: ITokensIndex;
+    /**
+     * All the block-tokens
+     */
     blocksIndex: ITokensIndex;
+    /**
+     * Imports map by URI, contains from Token and imports[] tokens
+     */
     imports: Map<string, {
         from: Token;
         imports: Token[];
     }>;
+    /**
+     * Map of imported definitions by type/interface identifier
+     */
     importedDefs: Map<string, Token>;
+    /**
+     * Exported nodes by identifier
+     */
     readonly exports: Map<string, SemanticNode>;
+    /**
+     * Set of documents that this document depend on
+     */
     readonly dependencies: Set<AtscriptDoc>;
+    /**
+     * Set of documents that depend on this document
+     */
     readonly dependants: Set<AtscriptDoc>;
+    /**
+     * List of tokens that refer to some type or interface
+     */
     referred: Token[];
+    /**
+     * Map of dependencies (documents) by URI
+     */
     readonly dependenciesMap: Map<string, AtscriptDoc>;
     get primitives(): SemanticPrimitiveNode[];
     render(format: TAtscriptRenderFormat): Promise<TOutputWithSource[] | undefined>;
@@ -291,6 +377,27 @@ declare class AtscriptDoc {
     resolvedAnnotations: Token[];
     annotations: TAnnotationTokens[];
     registerAnnotation(annotationTokens: TAnnotationTokens): void;
+    /**
+     * Recursively resolves a type reference (and any property chain) to find the final underlying definition.
+     *
+     * This method performs a **multi-step** resolution:
+     *  1. Locates the declaration owner of the type (via `getDeclarationOwnerNode`).
+     *  2. Follows references, type aliases, or nested property chains:
+     *     - For “Ref” nodes, it uses the identifier to look up the next type.
+     *     - For “Type” nodes, it calls `getDefinition()` to move to the underlying structure.
+     *     - For property chains (`chain`), it navigates nested properties or nested types,
+     *       resolving each level until the final type is reached.
+     *
+     * @param {string} name - The name of the type or identifier to resolve.
+     * @param {Array<string | Token>} [chain=[]] - An optional chain of properties or tokens, each of which
+     *  refines the path to the final type (e.g., for `SomeType.prop1.prop2`, `chain` might be `[ "prop1", "prop2" ]`).
+     * @returns {Object | undefined} An object containing:
+     *   - `doc`: The `AtscriptDoc` where the final definition is located.
+     *   - `node`: The last encountered `SemanticNode` before reaching the final underlying definition (often a `Prop` node).
+     *   - `def`: The final resolved `SemanticNode`.
+     *
+     * If the type cannot be resolved or does not exist, returns `undefined`.
+     */
     unwindType(name: string, chain?: string[] | Token[], watchCb?: (def: SemanticNode) => void, _tracked?: Set<SemanticNode>): {
         doc: AtscriptDoc;
         node?: SemanticNode;
@@ -307,6 +414,22 @@ declare class AtscriptDoc {
         range: Token['range'];
         token: Token;
     }> | undefined;
+    /**
+     * Retrieves the definition (i.e., the “go to definition” target) for a given token.
+     *
+     * This method provides a **single-step** resolution of the defining token:
+     *  - If the token is defined in the same document, returns that definition.
+     *  - If the token is imported, follows the import to return the defining token from the relevant document.
+     *  - If the token is a reference to a locally defined identifier, retrieves the local definition.
+     *
+     * @param {Token} token - The token for which to locate the definition.
+     * @returns {Object | undefined} An object containing:
+     *   - `uri`: The file path (URI) of the document where the definition is found.
+     *   - `doc`: The `AtscriptDoc` instance that owns the definition (if found).
+     *   - `token`: The defining token itself (if found).
+     *
+     * If no definition is found, returns `undefined`.
+     */
     getDefinitionFor(token: Token): {
         uri: string;
         doc?: AtscriptDoc;
@@ -351,6 +474,25 @@ declare class AtscriptDoc {
         block: Token;
     }): void;
     registerDefinition(token?: Token, asImport?: boolean): void;
+    /**
+     * Finds the owning document and semantic node responsible for declaring a given identifier.
+     *
+     * This method checks:
+     * 1. Whether the identifier is a known primitive (from this document’s config).
+     * 2. If there's a local definition in this document's registry.
+     *    - If the definition is imported, it resolves the `fromPath`, locates the correct `AtscriptDoc`
+     *      in the dependency map, and recursively tries to get the declaration owner there.
+     *    - If the definition is local (not imported), it returns the current document (`this`) along with
+     *      the parent node that owns the definition and the token itself.
+     *
+     * @param {string} identifier - The name/identifier whose declaring node should be found.
+     * @returns {{ doc: AtscriptDoc; node?: SemanticNode; token?: Token } | undefined} An object containing:
+     *  - `doc`: The `AtscriptDoc` in which the identifier was ultimately declared.
+     *  - `node`: The parent `SemanticNode` that defines or owns the declaration (if applicable).
+     *  - `token`: The specific token for the declaration (if applicable).
+     *
+     * If no declaration is found, returns `undefined`.
+     */
     getDeclarationOwnerNode(identifier: string): {
         doc: AtscriptDoc;
         node?: SemanticNode;
@@ -362,9 +504,22 @@ declare class AtscriptDoc {
     private _allMessages;
     clearMessages(): void;
     getUnusedTokens(): Token[];
+    renderDiagMessage(m: TMessages[number], addSourceLinses?: boolean, colors?: boolean): string;
     getDiagMessages(): TMessages;
     mergeIntersection(node: SemanticNode): SemanticNode;
     mergeDefs(_left: SemanticNode, _right: SemanticNode): [SemanticNode] | [SemanticNode, SemanticNode];
+    /**
+     * Merges two arrays of annotation tokens, ensuring that annotations from the
+     * `right` array take precedence over those from the `left` array.
+     *
+     * - Annotations from `right` are always included.
+     * - Annotations from `left` are included only if they are not already present in `right`.
+     * - This ensures that if an annotation exists in both arrays, the one from `right` is kept.
+     *
+     * @param left - An optional array of annotation tokens to merge (lower priority).
+     * @param right - An optional array of annotation tokens to merge (higher priority).
+     * @returns A merged array of annotation tokens, preserving order while preventing duplicates.
+     */
     mergeNodesAnnotations(left?: TAnnotationTokens[], right?: TAnnotationTokens[]): TAnnotationTokens[];
 }
 
@@ -445,6 +600,7 @@ declare class SemanticRefNode extends SemanticNode {
 declare class SemanticPropNode extends SemanticNode {
     constructor();
     registerAtDocument(doc: AtscriptDoc): void;
+    get isPattern(): boolean;
     get nestedProps(): Map<string, SemanticPropNode> | undefined;
     get nestedType(): SemanticRefNode | undefined;
 }
@@ -458,6 +614,9 @@ declare class SemanticInterfaceNode extends SemanticNode {
 declare class SemanticStructureNode extends SemanticGroup {
     constructor();
     readonly props: Map<string, SemanticPropNode>;
+    /**
+     * Shortcut to set props, used as utility
+     */
     setProps(props: SemanticPropNode[]): void;
     registerAtDocument(doc: AtscriptDoc): void;
     addVirtualProp(opts: {
@@ -522,8 +681,14 @@ interface TAnnotationsTree {
     [key: string]: AnnotationSpec | TAnnotationsTree;
 }
 
+/**
+ * Defines the configuration for the Intertation parser
+ */
 declare function defineConfig(config: TAtscriptConfig): TAtscriptConfig;
 
+/**
+ * Resolves nearest config file
+ */
 declare function resolveConfigFile(docUri: string, _root?: string): Promise<string | undefined>;
 declare function loadTsConfig(configFile: string, forceFormat?: 'cjs' | 'esm'): Promise<TAtscriptConfig>;
 declare function loadConfig(configPath: string, forceFormat?: 'cjs' | 'esm'): Promise<TAtscriptConfig>;

package/dist/index.mjs

@@ -310,11 +310,11 @@ var Token = class Token {
 		* All the import tokens must be marked with this flag
 		*/ _define_property$12(this, "imported", void 0);
 		/**
-		* All the props must be marked with this flag
-		*/ _define_property$12(this, "isProp", void 0);
-		/**
 		* Refs chained via . or ["propName"] are marked with this flag
 		*/ _define_property$12(this, "isChain", void 0);
+		/**
+		* Prop patterns ([*] or [regexp]) are storing patterns here
+		*/ _define_property$12(this, "pattern", void 0);
 		_define_property$12(this, "parentNode", void 0);
 		/**
 		* Only for annotation arguments: reference to their annotation token
@@ -485,6 +485,9 @@ var SemanticPropNode = class extends SemanticNode {
 		const token = this.token("identifier");
 		if (token && token.type === "text" && token.multiline) doc.registerMessage(token, "Unexpected end of string");
 	}
+	get isPattern() {
+		return !!this.token("identifier")?.pattern;
+	}
 	get nestedProps() {
 		if (this.definition && isStructure(this.definition)) return this.definition.props;
 	}
@@ -942,7 +945,10 @@ async function findConfigFileName(d) {
 async function loadTsConfig(configFile, forceFormat) {
 	const file = await bundleTsConfig(configFile, forceFormat);
 	try {
-		return (await import(pathToFileURL(file).href)).default;
+		return (await import(
+			/* @vite-ignore */
+			pathToFileURL(file).href
+)).default;
 	} catch (error) {
 		console.error("Could not load config file", file, error);
 		return {};
@@ -953,7 +959,10 @@ async function loadTsConfig(configFile, forceFormat) {
 async function loadConfig(configPath, forceFormat) {
 	const ext = path.extname(configPath);
 	try {
-		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext)) return forceFormat ? await loadTsConfig(path.resolve(configPath), forceFormat) : (await import(pathToFileURL(configPath).href)).default;
+		if (SUPPORTED_JS_CONFIG_FORMATS.includes(ext)) return forceFormat ? await loadTsConfig(path.resolve(configPath), forceFormat) : (await import(
+			/* @vite-ignore */
+			pathToFileURL(configPath).href
+)).default;
 else if (SUPPORTED_TS_CONFIG_FORMATS.includes(ext)) {
 			const rawConfigPath = path.resolve(configPath);
 			return await loadTsConfig(rawConfigPath, forceFormat);
@@ -1064,9 +1073,6 @@ var NodeIterator = class NodeIterator {
 		this.$ = this.nodes[this.i];
 		return this;
 	}
-	/** @deprecated */ killNextNode(n = 1) {
-		this.nodes.splice(this.i + 1, n);
-	}
 	next(skip) {
 		return this.fork().move().skip(skip);
 	}
@@ -1246,8 +1252,8 @@ const IdentifierToken = new BasicNode({
 //#region packages/core/src/tokenizer/tokens/number.token.ts
 const NumberToken = new BasicNode({
 	icon: "N",
-	tokens: [RegExp("\\d[\\p{ID_Continue}$]*", "u"), RegExp("[^\\p{ID_Continue}$]", "u")],
-	tokenOE: "consume-eject"
+	tokens: [/[-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/u, /[^\d]/u],
+	tokenOE: "-eject"
 }).mapContent("text", "join-clear").onMatch((context) => {
 	context.customData.type = "number";
 });
@@ -1255,7 +1261,7 @@ const NumberToken = new BasicNode({
 //#endregion
 //#region packages/core/src/tokenizer/tokens/punctuation.token.ts
 const PunctuationToken = new BasicNode({
-	tokens: [RegExp("(?<text>[\\n!&+,\\-./:;=?|])", "u"), ""],
+	tokens: [RegExp("(?<text>[\\n!&+,./:;=?|])", "u"), ""],
 	tokenOE: "omit-omit",
 	icon: "..."
 }).onMatch((context) => {
@@ -1275,6 +1281,19 @@ const TextToken = new BasicNode({
 	context.customData.multiline = context.customData.end === "\n";
 });
 
+//#endregion
+//#region packages/core/src/tokenizer/tokens/regexp.token.ts
+const REGEXP_LITERAL_RE = /\/(?![/*])(?:\\.|\[.*?]|[^/\\\n\r[])*\/[dgimsuy]*/;
+const RegExpToken = new BasicNode({
+	label: "regexp",
+	icon: "RG",
+	tokens: [REGEXP_LITERAL_RE, ""],
+	tokenOE: "omit-omit"
+}).onMatch((ctx) => {
+	ctx.customData.type = "regexp";
+	ctx.customData.text = ctx.matched[0];
+});
+
 //#endregion
 //#region packages/core/src/tokenizer/tokens/index.ts
 const tokens = {
@@ -1287,6 +1306,7 @@ const tokens = {
 	identifier: IdentifierToken,
 	number: NumberToken,
 	text: TextToken,
+	regexp: RegExpToken,
 	root: undefined
 };
 const root = new BasicNode({
@@ -1294,7 +1314,7 @@ const root = new BasicNode({
 	skipToken: /\s/u
 }).addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
 tokens.root = root;
-BlockToken.addRecognizes(...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
+BlockToken.addRecognizes(tokens.regexp, ...tokens.comments, tokens.block, tokens.aIdentifier, tokens.identifier, tokens.text, tokens.number, tokens.punctuation);
 const mapContent = (content) => content.map((item) => {
 	if (typeof item === "string") return {
 		type: "unknown",
@@ -1329,6 +1349,7 @@ function $token(name, text$2) {
 			node: name,
 			text: text$2
 		}],
+		contains: undefined,
 		isGlobal: false,
 		empty: false,
 		wrapper: undefined,
@@ -1363,6 +1384,16 @@ function $token(name, text$2) {
 						ni.unexpected(false, `Expected empty block`);
 						return opts.optional;
 					}
+					if (opts.contains) {
+						if (!ni.$.children?.length) {
+							ni.unexpected(false, `Expected ${opts.contains.map((v) => v.text).join(", ")}`);
+							return opts.optional;
+						}
+						if (ni.$.children[0].type !== opts.contains[0].node || ni.$.children[0].text !== opts.contains[0].text) {
+							ni.unexpected(false, `Expected ${opts.contains.map((v) => v.text).join(", ")}`);
+							return opts.optional;
+						}
+					}
 					if (opts.saveAs) target.node.saveToken(new Token(ni.$), opts.saveAs);
 					ni.accepted();
 					if (opts.wrapper) {
@@ -1397,6 +1428,10 @@ else return true;
 			opts.empty = true;
 			return this;
 		},
+		contains(t) {
+			opts.contains = t.expect;
+			return this;
+		},
 		skip(...p) {
 			opts.skip = p;
 			return this;
@@ -1801,6 +1836,52 @@ function unwrap(attr) {
 		}
 	};
 }
+function propName() {
+	return { handler(ni, target) {
+		switch (ni.$?.type) {
+			case "identifier":
+			case "text":
+				target.node.saveToken(new Token(ni.$), "identifier");
+				ni.accepted();
+				ni.move();
+				ni.skip(["\n"]);
+				return true;
+			case "block":
+				const childrenLength = ni.$.children?.length || 0;
+				const firstText = ni.$.children?.[0]?.text;
+				if (ni.$.text === "[" && ni.$.children?.[0]?.type === "unknown" && childrenLength === 1 && ni.$.children[0].text === "*" || ni.$.text === "[" && ni.$.children?.[0]?.type === "regexp" && childrenLength === 1) {
+					const t = new Token({
+						...ni.$,
+						...ni.$.children[0]
+					});
+					try {
+						t.pattern = firstText === "*" ? /./ : parseRegExpLiteral(firstText);
+					} catch (e) {
+						ni.unexpected(false, e.message);
+						return false;
+					}
+					target.node.saveToken(t, "identifier");
+					ni.accepted();
+					ni.move();
+					ni.skip(["\n"]);
+					return true;
+				}
+				if (ni.$.text === "[" && !childrenLength) ni.unexpected(false, "Wildcard \"*\" or a Regular Expression expected");
+				if (ni.$.text === "[" && childrenLength > 1) ni.unexpected(false, firstText?.startsWith("/") ? "Invalid Regular Expression" : "To many arguments in prop pattern []");
+else ni.unexpected(false, "Unexpected identifier at property name");
+				return false;
+			default:
+				ni.unexpected(false, "Unexpected identifier at property name");
+				return false;
+		}
+	} };
+}
+function parseRegExpLiteral(literal) {
+	const match = literal.match(/^\/(.+)\/([dgimsuy]*)$/);
+	if (!match) throw new Error(`Invalid regexp literal: ${literal}`);
+	const [, pattern, flags] = match;
+	return new RegExp(pattern.replace(/\\\//g, "/"), flags);
+}
 
 //#endregion
 //#region packages/core/src/parser/pipes/pipes.ts
@@ -1808,9 +1889,9 @@ const ref = $pipe("ref", [refWithChain()]);
 const constText = defineValuePipe("const", "text", false);
 const constNumber = defineValuePipe("const", "number", false);
 const allowedValuesPipeArray = [
+	constNumber,
 	ref,
-	constText,
-	constNumber
+	constText
 ];
 const tuplePipeArray = [
 	block("[]").saveAs("identifier"),
@@ -1836,7 +1917,7 @@ const type = $pipe("type", [
 ]).skip("\n", ";");
 const props = $pipe("prop", [
 	annotations(),
-	identifier().or(text()).saveAs("identifier").skip("\n"),
+	propName(),
 	pun("?").saveAs("optional").optional().skip("\n"),
 	pun(":").skip("\n"),
 	definition(allowedValuesPipeArray).separatedBy("&", "|").skip("\n").respectPriority(),
@@ -1878,6 +1959,16 @@ const pipes = {
 	tuple
 };
 
+//#endregion
+//#region packages/core/src/parser/types.ts
+var TSeverity = /*#__PURE__*/ function(TSeverity$1) {
+	TSeverity$1[TSeverity$1["Error"] = 1] = "Error";
+	TSeverity$1[TSeverity$1["Warning"] = 2] = "Warning";
+	TSeverity$1[TSeverity$1["Info"] = 3] = "Info";
+	TSeverity$1[TSeverity$1["Hint"] = 4] = "Hint";
+	return TSeverity$1;
+}({});
+
 //#endregion
 //#region packages/core/src/token-index/blocks-index.ts
 function _define_property$5(obj, key, value) {
@@ -2424,6 +2515,63 @@ else if (isStructure(def) || isInterface(def) || isPrimitive(def)) def = def.pro
 		for (const [key, token] of Array.from(this.registry.definitions.entries())) if (!refSet.has(key) && !this.exports.has(key)) tokens$1.push(token);
 		return tokens$1;
 	}
+	renderDiagMessage(m, addSourceLinses = false, colors = false) {
+		const c = {
+			red: colors ? "\x1B[31m" : "",
+			blue: colors ? "\x1B[34m" : "",
+			cyan: colors ? "\x1B[36m" : "",
+			yellow: colors ? "\x1B[33m" : "",
+			dim: colors ? "\x1B[2m" : "",
+			reset: colors ? "\x1B[0m" : ""
+		};
+		let sc = "";
+		let banner = "[atscript]";
+		switch (m.severity) {
+			case TSeverity.Error:
+				sc = c.red;
+				banner += "[Error]";
+				break;
+			case TSeverity.Warning:
+				sc = c.yellow;
+				banner += "[Warning]";
+				break;
+			case TSeverity.Info:
+				sc = "";
+				banner += "[Info]";
+				break;
+			case TSeverity.Hint:
+				sc = c.dim;
+				banner += "[Hint]";
+				break;
+			default: sc = "";
+		}
+		const n = m.range.start.line + 1;
+		let out = `\n${sc}${banner} ${m.message}${c.reset}` + `\nin ${c.blue}${this.id}:${n}:${m.range.start.character + 1}${c.reset}`;
+		if (addSourceLinses) {
+			const lines = this.text.split("\n");
+			const renderLines = [
+				{
+					l: lines[n - 3],
+					i: n - 3
+				},
+				{
+					l: lines[n - 2],
+					i: n - 2
+				},
+				{
+					l: lines[n - 1],
+					i: n - 1
+				}
+			].filter(Boolean);
+			const nl = String(n).length + 1;
+			for (const { l, i } of renderLines) {
+				const prefix = `${c.dim + c.cyan}${("0" + i).slice(-nl)} | ${c.reset}`;
+				out += `\n${prefix}${l}${c.reset}`;
+			}
+			out += `\n${" ".repeat(nl + 3 + m.range.start.character)}${c.red}${"^".repeat(m.range.end.character - m.range.start.character)}${c.reset}`;
+		}
+		return out + "\n";
+	}
 	getDiagMessages() {
 		if (!this._allMessages) {
 			this._allMessages = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/core",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Core library for Atscript parsing and file generation.",
   "type": "module",
   "main": "dist/index.mjs",
@@ -42,7 +42,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
-    "vitest": "^3.0.0"
+    "vitest": "3.2.4"
   },
   "scripts": {
     "pub": "pnpm publish --access public",