@blcklab/yuirinx 0.1.1 → 0.1.2

package/dist/esm/languages/javascript.js

@@ -1,232 +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/ecmascript.ts
-var 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"
-];
-var 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"
-];
-var 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 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) {
-    rootRules.push({
-      type: "tag.punctuation",
-      pattern: /<\/?/,
-      push: "jsxTag"
-    });
-  }
-  rootRules.push(
-    {
-      type: "regex",
-      pattern: /\/(?![/*\s])(?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\\\r\n])+\/[dgimsuvy]*/
-    },
-    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" }
-        ]
-      },
-      jsxTag: {
-        rules: [
-          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
-          whitespaceRule,
-          { type: "attribute.value", pattern: /"(?:\\.|[^"\\])*"?/ },
-          { type: "attribute.value", pattern: /'(?:\\.|[^'\\])*'?/ },
-          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
-          { type: "operator", pattern: /=/ },
-          { type: "tag", pattern: /[A-Za-z_$][\w$.-]*/ },
-          punctuationRule
-        ]
-      },
-      jsxExpression: {
-        rules: [
-          { type: "punctuation", pattern: /}/, pop: true },
-          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
-          { include: "root" }
-        ]
-      }
-    }
-  };
-}
-
-// src/languages/javascript.ts
-var javascript = createEcmaGrammar({
+import { createEcmaGrammar } from "./shared/ecmascript.js";
+const javascript = createEcmaGrammar({
   id: "javascript",
   aliases: ["js", "mjs", "cjs"]
 });

package/dist/esm/languages/json.js

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

package/dist/esm/languages/jsx.js

@@ -1,232 +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/ecmascript.ts
-var 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"
-];
-var 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"
-];
-var 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 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) {
-    rootRules.push({
-      type: "tag.punctuation",
-      pattern: /<\/?/,
-      push: "jsxTag"
-    });
-  }
-  rootRules.push(
-    {
-      type: "regex",
-      pattern: /\/(?![/*\s])(?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\\\r\n])+\/[dgimsuvy]*/
-    },
-    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" }
-        ]
-      },
-      jsxTag: {
-        rules: [
-          { type: "tag.punctuation", pattern: /\/?>/, pop: true },
-          whitespaceRule,
-          { type: "attribute.value", pattern: /"(?:\\.|[^"\\])*"?/ },
-          { type: "attribute.value", pattern: /'(?:\\.|[^'\\])*'?/ },
-          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
-          { type: "operator", pattern: /=/ },
-          { type: "tag", pattern: /[A-Za-z_$][\w$.-]*/ },
-          punctuationRule
-        ]
-      },
-      jsxExpression: {
-        rules: [
-          { type: "punctuation", pattern: /}/, pop: true },
-          { type: "punctuation", pattern: /{/, push: "jsxExpression" },
-          { include: "root" }
-        ]
-      }
-    }
-  };
-}
-
-// src/languages/jsx.ts
-var jsx = createEcmaGrammar({
+import { createEcmaGrammar } from "./shared/ecmascript.js";
+const jsx = createEcmaGrammar({
   id: "jsx",
   aliases: ["react"],
   jsx: true

package/dist/esm/languages/kotlin.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/kotlin.ts
-var kotlin = createCLikeGrammar({
+import { createCLikeGrammar } from "./shared/c-family.js";
+const kotlin = createCLikeGrammar({
   id: "kotlin",
   aliases: ["kt", "kts"],
   keywords: [

package/dist/esm/languages/markdown.js

@@ -1,21 +1,37 @@
-// src/languages/shared/helpers.ts
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-
-// src/languages/markdown.ts
-var markdown = {
+import { whitespaceRule } from "./shared/helpers.js";
+const atLineStart = (_match, context) => context.offset === 0 || /[\r\n]/.test(context.source[context.offset - 1] ?? "");
+const markdown = {
   id: "markdown",
   aliases: ["md", "mdown"],
   states: {
     root: {
       rules: [
-        { type: "meta", pattern: /```[^\r\n]*(?:\r?\n|$)/, push: "fence" },
-        { type: "heading", pattern: /#{1,6}[ \t]+[^\r\n]*/ },
+        {
+          type: "meta",
+          pattern: / {0,3}```[^\r\n]*(?:\r?\n|$)/,
+          when: atLineStart,
+          push: "fence"
+        },
+        {
+          type: "heading",
+          pattern: / {0,3}#{1,6}[ \t]+[^\r\n]*/,
+          when: atLineStart
+        },
         {
           type: "heading",
-          pattern: /[^\r\n]+\r?\n(?:===+|---+)[ \t]*(?:\r?\n|$)/
+          pattern: /[^\r\n]+\r?\n {0,3}(?:===+|---+)[ \t]*(?:\r?\n|$)/,
+          when: atLineStart
+        },
+        {
+          type: "quote",
+          pattern: / {0,3}>[ \t]?[^\r\n]*/,
+          when: atLineStart
+        },
+        {
+          type: "list",
+          pattern: / {0,3}(?:[-+*]|\d+[.)])[ \t]+/,
+          when: atLineStart
         },
-        { type: "quote", pattern: />[ \t]?[^\r\n]*/ },
-        { type: "list", pattern: /(?:[-+*]|\d+[.)])[ \t]+/ },
         { type: "important", pattern: /!\[[^\]\r\n]*\]\([^\r\n)]*\)/ },
         { type: "link", pattern: /\[[^\]\r\n]+\]\([^\r\n)]*\)/ },
         { type: "url", pattern: /https?:\/\/[^\s<>()]+/ },
@@ -31,7 +47,12 @@ var markdown = {
     fence: {
       fallbackType: "code",
       rules: [
-        { type: "meta", pattern: /```[ \t]*(?:\r?\n|$)/, pop: true },
+        {
+          type: "meta",
+          pattern: / {0,3}```[ \t]*(?:\r?\n|$)/,
+          when: atLineStart,
+          pop: true
+        },
         { type: "code", pattern: /[^`]+/ },
         { type: "code", pattern: /`/ }
       ]

package/dist/esm/languages/nginx.js

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