@blcklab/yuirinx 0.1.1

package/dist/esm/languages/tsx.js

@@ -0,0 +1,237 @@
+// 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/tsx.ts
+var tsx = createEcmaGrammar({
+  id: "tsx",
+  aliases: ["typescriptreact"],
+  typescript: true,
+  jsx: true
+});
+export {
+  tsx
+};

package/dist/esm/languages/typescript.js

@@ -0,0 +1,236 @@
+// 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/typescript.ts
+var typescript = createEcmaGrammar({
+  id: "typescript",
+  aliases: ["ts", "mts", "cts"],
+  typescript: true
+});
+export {
+  typescript
+};

package/dist/esm/languages/vue.js

@@ -0,0 +1,47 @@
+// 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/vue.ts
+var vue = createMarkupGrammar({ id: "vue" });
+export {
+  vue
+};

package/dist/esm/languages/xml.js

@@ -0,0 +1,50 @@
+// 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/xml.ts
+var xml = createMarkupGrammar({
+  id: "xml",
+  aliases: ["xhtml", "svg"]
+});
+export {
+  xml
+};

package/dist/esm/languages/yaml.js

@@ -0,0 +1,38 @@
+// src/languages/shared/helpers.ts
+var whitespaceRule = { type: "plain", pattern: /\s+/ };
+
+// src/languages/yaml.ts
+var yaml = {
+  id: "yaml",
+  aliases: ["yml"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        { type: "meta", pattern: /(?:---|\.\.\.)(?=\s|$)/ },
+        { type: "string", pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/ },
+        { type: "string", pattern: /'(?:''|[^'\r\n])*'?/ },
+        {
+          type: "property",
+          pattern: /(?:[A-Za-z_][\w .-]*|"[^"\r\n]+"|'[^'\r\n]+')(?=\s*:)/
+        },
+        { type: "important", pattern: /![A-Za-z_][\w:.-]*/ },
+        { type: "constant", pattern: /[&*][A-Za-z_][\w.-]*/ },
+        { type: "boolean", pattern: /\b(?:true|false|yes|no|on|off)\b/i },
+        { type: "null", pattern: /(?:\bnull\b|~)/i },
+        {
+          type: "number",
+          pattern: /[-+]?\b(?:0x[\da-f]+|0o[0-7]+|\d+(?:\.\d+)?(?:e[-+]?\d+)?)\b/i
+        },
+        { type: "list", pattern: /-(?=\s)/ },
+        { type: "operator", pattern: /[?:|>]/ },
+        { type: "punctuation", pattern: /[{}[\],]/ },
+        { type: "string", pattern: /[^\s:{}[\],#&*!|>'"%@`-][^\r\n:#]*/ },
+        whitespaceRule
+      ]
+    }
+  }
+};
+export {
+  yaml
+};