@blcklab/yuirinx 0.1.1 → 0.1.2

package/dist/esm/languages/shared/ecmascript.js

@@ -0,0 +1,261 @@
+import {
+  blockCommentRule,
+  cLineCommentRule,
+  doubleStringRule,
+  numberRule,
+  operatorRule,
+  punctuationRule,
+  singleStringRule,
+  whitespaceRule,
+  words
+} from "./helpers.js";
+const JS_KEYWORDS = [
+  "as",
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "get",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "of",
+  "return",
+  "set",
+  "static",
+  "switch",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+];
+const TS_KEYWORDS = [
+  "abstract",
+  "any",
+  "asserts",
+  "bigint",
+  "boolean",
+  "declare",
+  "enum",
+  "implements",
+  "infer",
+  "interface",
+  "is",
+  "keyof",
+  "module",
+  "namespace",
+  "never",
+  "number",
+  "object",
+  "override",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "require",
+  "satisfies",
+  "string",
+  "symbol",
+  "type",
+  "undefined",
+  "unique",
+  "unknown",
+  "using"
+];
+const BUILTINS = [
+  "Array",
+  "BigInt",
+  "Boolean",
+  "Date",
+  "Error",
+  "JSON",
+  "Map",
+  "Math",
+  "Number",
+  "Object",
+  "Promise",
+  "Proxy",
+  "Reflect",
+  "RegExp",
+  "Set",
+  "String",
+  "Symbol",
+  "WeakMap",
+  "WeakSet",
+  "console",
+  "document",
+  "globalThis",
+  "process",
+  "window"
+];
+function canStartRegex(source, offset) {
+  const before = source.slice(0, offset).trimEnd();
+  if (!before) return true;
+  const previous = before[before.length - 1] ?? "";
+  if (/[([{,:;=!?&|+\-*%^~<>]/.test(previous)) return true;
+  const word = /[A-Za-z_$][\w$]*$/.exec(before)?.[0];
+  return Boolean(
+    word && /^(?:await|case|delete|do|else|in|instanceof|new|of|return|throw|typeof|void|yield)$/.test(
+      word
+    )
+  );
+}
+function createEcmaGrammar(options) {
+  const keywordValues = options.typescript ? [...JS_KEYWORDS, ...TS_KEYWORDS] : JS_KEYWORDS;
+  const rootRules = [
+    cLineCommentRule,
+    blockCommentRule,
+    doubleStringRule,
+    singleStringRule,
+    { type: "string", pattern: /`/, push: "template" }
+  ];
+  if (options.jsx) {
+    if (options.typescript) {
+      rootRules.push({
+        type: "operator",
+        pattern: /<(?=[A-Za-z_$][\w$]*(?:\s+extends\s+[^>]+)?,?>\s*\()/
+      });
+    }
+    rootRules.push({
+      type: "tag.punctuation",
+      pattern: /<(?=[A-Za-z_$>])/,
+      push: "jsxTagName"
+    });
+  }
+  rootRules.push(
+    {
+      type: "regex",
+      pattern: /\/(?![/*\s])(?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\\\r\n])+\/[dgimsuvy]*/,
+      when: (_match, context) => canStartRegex(context.source, context.offset)
+    },
+    numberRule,
+    { type: "boolean", pattern: /\b(?:true|false)\b/ },
+    { type: "null", pattern: /\b(?:null|undefined)\b/ },
+    { type: "keyword", pattern: words(keywordValues) },
+    { type: "builtin", pattern: words(BUILTINS) },
+    { type: "decorator", pattern: /@[A-Za-z_$][\w$]*/ },
+    { type: "function.call", pattern: /\b[A-Za-z_$][\w$]*(?=\s*\()/ },
+    {
+      type: "type",
+      pattern: /\b[A-Z][A-Za-z\d_$]*(?=\s*(?:<|\[|\||&|[,)>]|$))/
+    },
+    { type: "property", pattern: /\b[A-Za-z_$][\w$]*(?=\s*:)/ },
+    { type: "constant", pattern: /\b[A-Z][A-Z\d_]{2,}\b/ },
+    { type: "variable", pattern: /\b[A-Za-z_$][\w$]*\b/ },
+    operatorRule,
+    punctuationRule,
+    whitespaceRule
+  );
+  return {
+    id: options.id,
+    aliases: options.aliases,
+    states: {
+      root: { rules: rootRules },
+      template: {
+        fallbackType: "string",
+        rules: [
+          { type: "string", pattern: /`/, pop: true },
+          { type: "string.escape", pattern: /\\[\s\S]/ },
+          {
+            type: "string.interpolation",
+            pattern: /\$\{/,
+            push: "templateExpression"
+          },
+          { type: "string", pattern: /[^\\`$]+/ },
+          { type: "string", pattern: /[$\\]/ }
+        ]
+      },
+      templateExpression: {
+        rules: [
+          { type: "string.interpolation", pattern: /}/, pop: true },
+          { type: "punctuation", pattern: /{/, push: "templateExpression" },
+          { include: "root" }
+        ]
+      },
+      jsxTagName: {
+        rules: [
+          { type: "tag.punctuation", pattern: />/, next: "jsxChildren" },
+          { type: "tag.punctuation", pattern: /\/>/, pop: true },
+          whitespaceRule,
+          {
+            type: "tag",
+            pattern: /[A-Za-z_$][\w$.-]*/,
+            next: "jsxAttributes"
+          },
+          punctuationRule
+        ]
+      },
+      jsxAttributes: {
+        rules: [
+          { type: "tag.punctuation", pattern: /\/>/, pop: true },
+          { type: "tag.punctuation", pattern: />/, next: "jsxChildren" },
+          whitespaceRule,
+          { type: "attribute.value", pattern: /"(?:\\.|[^"\\])*"?/ },
+          { type: "attribute.value", pattern: /'(?:\\.|[^'\\])*'?/ },
+          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
+          { type: "operator", pattern: /=/ },
+          { type: "attribute", pattern: /[A-Za-z_$][\w$.-]*/ },
+          punctuationRule
+        ]
+      },
+      jsxChildren: {
+        fallbackType: "plain",
+        rules: [
+          {
+            type: "tag.punctuation",
+            pattern: /<\/(?=[A-Za-z_$>])/,
+            push: "jsxClosingTag"
+          },
+          {
+            type: "tag.punctuation",
+            pattern: /<(?=[A-Za-z_$>])/,
+            push: "jsxTagName"
+          },
+          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
+          { type: "plain", pattern: /[^<{]+/ },
+          { type: "plain", pattern: /[<{]/ }
+        ]
+      },
+      jsxClosingTag: {
+        rules: [
+          { type: "tag.punctuation", pattern: />/, pop: 2 },
+          whitespaceRule,
+          { type: "tag", pattern: /[A-Za-z_$][\w$.-]*/ },
+          punctuationRule
+        ]
+      },
+      jsxExpression: {
+        rules: [
+          { type: "punctuation", pattern: /}/, pop: true },
+          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
+          { include: "root" }
+        ]
+      }
+    }
+  };
+}
+export {
+  createEcmaGrammar
+};

package/dist/esm/languages/shared/helpers.js

@@ -0,0 +1,52 @@
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function words(values, flags = "") {
+  return new RegExp(`\\b(?:${values.map(escapeRegex).join("|")})\\b`, flags);
+}
+const whitespaceRule = { type: "plain", pattern: /\s+/ };
+const punctuationRule = {
+  type: "punctuation",
+  pattern: /[()[\]{}.,;:]/
+};
+const operatorRule = {
+  type: "operator",
+  pattern: /(?:===|!==|>>>|<<=|>>=|=>|==|!=|<=|>=|&&|\|\||\?\?|\?\.|\+\+|--|\+=|-=|\*=|\/=|%=|\*\*|<<|>>|[+\-*/%=&|!<>^~?])/
+};
+const numberRule = {
+  type: "number",
+  pattern: /\b(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[bB][01](?:_?[01])*|0[oO][0-7](?:_?[0-7])*|\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?)\b/
+};
+const doubleStringRule = {
+  type: "string",
+  pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/
+};
+const singleStringRule = {
+  type: "string",
+  pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/
+};
+const cLineCommentRule = {
+  type: "comment",
+  pattern: /\/\/[^\r\n]*/
+};
+const hashCommentRule = {
+  type: "comment",
+  pattern: /#[^\r\n]*/
+};
+const blockCommentRule = {
+  type: (match) => match[0].startsWith("/**") ? "comment.documentation" : "comment",
+  pattern: /\/\*[\s\S]*?(?:\*\/|$)/
+};
+export {
+  blockCommentRule,
+  cLineCommentRule,
+  doubleStringRule,
+  escapeRegex,
+  hashCommentRule,
+  numberRule,
+  operatorRule,
+  punctuationRule,
+  singleStringRule,
+  whitespaceRule,
+  words
+};

package/dist/esm/languages/shared/markup.js

@@ -0,0 +1,41 @@
+import { whitespaceRule } from "./helpers.js";
+function createMarkupGrammar(options) {
+  return {
+    id: options.id,
+    ...options.aliases ? { aliases: options.aliases } : {},
+    states: {
+      root: {
+        rules: [
+          { type: "comment", pattern: /<!--[\s\S]*?(?:-->|$)/ },
+          { type: "meta", pattern: /<!DOCTYPE[^>]*>?/i },
+          { type: "meta", pattern: /<\?[\s\S]*?(?:\?>|$)/ },
+          { type: "tag.punctuation", pattern: /<\/?/, push: "tagName" },
+          { type: "constant", pattern: /&(?:#\d+|#x[\da-f]+|[a-z][\w-]*);/i },
+          { type: "plain", pattern: /[^<&]+/ },
+          { type: "plain", pattern: /[<&]/ }
+        ]
+      },
+      tagName: {
+        rules: [
+          whitespaceRule,
+          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
+          { type: "tag", pattern: /[A-Za-z_][\w:.-]*/, next: "tag" }
+        ]
+      },
+      tag: {
+        rules: [
+          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
+          whitespaceRule,
+          { type: "attribute.value", pattern: /"(?:&[^;\s]+;|[^"&])*"?/ },
+          { type: "attribute.value", pattern: /'(?:&[^;\s]+;|[^'&])*'?/ },
+          { type: "punctuation", pattern: /[{[]/ },
+          { type: "operator", pattern: /=/ },
+          { type: "attribute", pattern: /[@:#A-Za-z_][\w:.-]*/ }
+        ]
+      }
+    }
+  };
+}
+export {
+  createMarkupGrammar
+};

package/dist/esm/languages/shell.js

@@ -1,118 +1,4 @@
-// src/languages/shared/helpers.ts
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function words(values, flags = "") {
-  return new RegExp(`\\b(?:${values.map(escapeRegex).join("|")})\\b`, flags);
-}
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-var doubleStringRule = {
-  type: "string",
-  pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/
-};
-var singleStringRule = {
-  type: "string",
-  pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/
-};
-
-// src/languages/bash.ts
-var KEYWORDS = [
-  "case",
-  "coproc",
-  "do",
-  "done",
-  "elif",
-  "else",
-  "esac",
-  "fi",
-  "for",
-  "function",
-  "if",
-  "in",
-  "select",
-  "then",
-  "time",
-  "until",
-  "while"
-];
-var BUILTINS = [
-  "alias",
-  "bg",
-  "bind",
-  "break",
-  "builtin",
-  "cd",
-  "command",
-  "continue",
-  "declare",
-  "dirs",
-  "disown",
-  "echo",
-  "enable",
-  "eval",
-  "exec",
-  "exit",
-  "export",
-  "fc",
-  "fg",
-  "getopts",
-  "hash",
-  "help",
-  "history",
-  "jobs",
-  "kill",
-  "let",
-  "local",
-  "logout",
-  "mapfile",
-  "printf",
-  "pwd",
-  "read",
-  "readonly",
-  "return",
-  "set",
-  "shift",
-  "source",
-  "test",
-  "trap",
-  "type",
-  "typeset",
-  "ulimit",
-  "umask",
-  "unalias",
-  "unset",
-  "wait"
-];
-var bash = {
-  id: "bash",
-  aliases: ["sh", "shell", "zsh"],
-  states: {
-    root: {
-      rules: [
-        { type: "meta", pattern: /#![^\r\n]*/ },
-        { type: "comment", pattern: /#[^\r\n]*/ },
-        doubleStringRule,
-        singleStringRule,
-        { type: "string", pattern: /`(?:\\.|[^`\\])*`?/ },
-        {
-          type: "variable",
-          pattern: /\$(?:\{[^}\r\n]*}?|[A-Za-z_][\w]*|\d+|[?#!@$*-])/
-        },
-        { type: "keyword", pattern: words(KEYWORDS) },
-        { type: "builtin", pattern: words(BUILTINS) },
-        { type: "number", pattern: /\b\d+\b/ },
-        {
-          type: "operator",
-          pattern: /(?:&&|\|\||<<-?|>>?|;;|;&|;;&|[|&;<>!=])/
-        },
-        { type: "punctuation", pattern: /[()[\]{}]/ },
-        { type: "function.call", pattern: /\b[A-Za-z_][\w.-]*(?=\s)/ },
-        { type: "variable", pattern: /\b[A-Za-z_][\w.-]*\b/ },
-        whitespaceRule
-      ]
-    }
-  }
-};
+import { bash } from "./bash.js";
 export {
   bash as shell
 };

package/dist/esm/languages/sql.js

@@ -1,34 +1,13 @@
-// src/languages/shared/helpers.ts
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function words(values, flags = "") {
-  return new RegExp(`\\b(?:${values.map(escapeRegex).join("|")})\\b`, flags);
-}
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-var punctuationRule = {
-  type: "punctuation",
-  pattern: /[()[\]{}.,;:]/
-};
-var operatorRule = {
-  type: "operator",
-  pattern: /(?:===|!==|>>>|<<=|>>=|=>|==|!=|<=|>=|&&|\|\||\?\?|\?\.|\+\+|--|\+=|-=|\*=|\/=|%=|\*\*|<<|>>|[+\-*/%=&|!<>^~?])+/
-};
-var numberRule = {
-  type: "number",
-  pattern: /\b(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[bB][01](?:_?[01])*|0[oO][0-7](?:_?[0-7])*|\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?)\b/
-};
-var doubleStringRule = {
-  type: "string",
-  pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/
-};
-var singleStringRule = {
-  type: "string",
-  pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/
-};
-
-// src/languages/sql.ts
-var KEYWORDS = [
+import {
+  doubleStringRule,
+  numberRule,
+  operatorRule,
+  punctuationRule,
+  singleStringRule,
+  whitespaceRule,
+  words
+} from "./shared/helpers.js";
+const KEYWORDS = [
   "add",
   "all",
   "alter",
@@ -93,7 +72,7 @@ var KEYWORDS = [
   "where",
   "with"
 ];
-var sql = {
+const sql = {
   id: "sql",
   states: {
     root: {

package/dist/esm/languages/svelte.js

@@ -1,47 +1,5 @@
-// src/languages/shared/helpers.ts
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-
-// src/languages/shared/markup.ts
-function createMarkupGrammar(options) {
-  return {
-    id: options.id,
-    ...options.aliases ? { aliases: options.aliases } : {},
-    states: {
-      root: {
-        rules: [
-          { type: "comment", pattern: /<!--[\s\S]*?(?:-->|$)/ },
-          { type: "meta", pattern: /<!DOCTYPE[^>]*>?/i },
-          { type: "meta", pattern: /<\?[\s\S]*?(?:\?>|$)/ },
-          { type: "tag.punctuation", pattern: /<\/?/, push: "tagName" },
-          { type: "constant", pattern: /&(?:#\d+|#x[\da-f]+|[a-z][\w-]*);/i },
-          { type: "plain", pattern: /[^<&]+/ },
-          { type: "plain", pattern: /[<&]/ }
-        ]
-      },
-      tagName: {
-        rules: [
-          whitespaceRule,
-          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
-          { type: "tag", pattern: /[A-Za-z_][\w:.-]*/, next: "tag" }
-        ]
-      },
-      tag: {
-        rules: [
-          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
-          whitespaceRule,
-          { type: "attribute.value", pattern: /"(?:&[^;\s]+;|[^"&])*"?/ },
-          { type: "attribute.value", pattern: /'(?:&[^;\s]+;|[^'&])*'?/ },
-          { type: "punctuation", pattern: /[{[]/ },
-          { type: "operator", pattern: /=/ },
-          { type: "attribute", pattern: /[@:#A-Za-z_][\w:.-]*/ }
-        ]
-      }
-    }
-  };
-}
-
-// src/languages/svelte.ts
-var svelte = createMarkupGrammar({ id: "svelte" });
+import { createMarkupGrammar } from "./shared/markup.js";
+const svelte = createMarkupGrammar({ id: "svelte" });
 export {
   svelte
 };

package/dist/esm/languages/swift.js

@@ -1,85 +1,5 @@
-// src/languages/shared/helpers.ts
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function words(values, flags = "") {
-  return new RegExp(`\\b(?:${values.map(escapeRegex).join("|")})\\b`, flags);
-}
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-var punctuationRule = {
-  type: "punctuation",
-  pattern: /[()[\]{}.,;:]/
-};
-var operatorRule = {
-  type: "operator",
-  pattern: /(?:===|!==|>>>|<<=|>>=|=>|==|!=|<=|>=|&&|\|\||\?\?|\?\.|\+\+|--|\+=|-=|\*=|\/=|%=|\*\*|<<|>>|[+\-*/%=&|!<>^~?])+/
-};
-var numberRule = {
-  type: "number",
-  pattern: /\b(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[bB][01](?:_?[01])*|0[oO][0-7](?:_?[0-7])*|\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?)\b/
-};
-var doubleStringRule = {
-  type: "string",
-  pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/
-};
-var singleStringRule = {
-  type: "string",
-  pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/
-};
-var cLineCommentRule = {
-  type: "comment",
-  pattern: /\/\/[^\r\n]*/
-};
-var blockCommentRule = {
-  type: (match) => match[0].startsWith("/**") ? "comment.documentation" : "comment",
-  pattern: /\/\*[\s\S]*?(?:\*\/|$)/
-};
-
-// src/languages/shared/c-family.ts
-function createCLikeGrammar(options) {
-  const rules = [
-    cLineCommentRule,
-    blockCommentRule,
-    ...options.extraRules ?? [],
-    doubleStringRule,
-    singleStringRule
-  ];
-  if (options.preprocessor) {
-    rules.push({ type: "meta", pattern: /#[ \t]*[A-Za-z_]\w*[^\r\n]*/ });
-  }
-  if (options.annotations) {
-    rules.push({
-      type: "annotation",
-      pattern: /@[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*/
-    });
-  }
-  rules.push(
-    numberRule,
-    { type: "boolean", pattern: /\b(?:true|false)\b/ },
-    { type: "null", pattern: /\b(?:null|nullptr|nil)\b/ },
-    { type: "keyword", pattern: words(options.keywords) }
-  );
-  if (options.builtins?.length) {
-    rules.push({ type: "builtin", pattern: words(options.builtins) });
-  }
-  rules.push(
-    { type: "function.call", pattern: /\b[A-Za-z_]\w*(?=\s*\()/ },
-    { type: "type", pattern: /\b[A-Z][A-Za-z\d_]*\b/ },
-    { type: "constant", pattern: /\b[A-Z][A-Z\d_]{2,}\b/ },
-    { type: "variable", pattern: /\b[A-Za-z_]\w*\b/ },
-    operatorRule,
-    punctuationRule,
-    whitespaceRule
-  );
-  return {
-    id: options.id,
-    ...options.aliases ? { aliases: options.aliases } : {},
-    states: { root: { rules } }
-  };
-}
-
-// src/languages/swift.ts
-var swift = createCLikeGrammar({
+import { createCLikeGrammar } from "./shared/c-family.js";
+const swift = createCLikeGrammar({
   id: "swift",
   aliases: [],
   keywords: [

package/dist/esm/languages/toml.js

@@ -1,8 +1,5 @@
-// src/languages/shared/helpers.ts
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-
-// src/languages/toml.ts
-var toml = {
+import { whitespaceRule } from "./shared/helpers.js";
+const toml = {
   id: "toml",
   states: {
     root: {