@blcklab/yuirinx 0.1.1

package/dist/esm/languages/dart.js

@@ -0,0 +1,177 @@
+// 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/dart.ts
+var dart = createCLikeGrammar({
+  id: "dart",
+  aliases: [],
+  keywords: [
+    "abstract",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "base",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "covariant",
+    "default",
+    "deferred",
+    "do",
+    "dynamic",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "extension",
+    "external",
+    "factory",
+    "false",
+    "final",
+    "finally",
+    "for",
+    "Function",
+    "get",
+    "hide",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "interface",
+    "is",
+    "late",
+    "library",
+    "mixin",
+    "new",
+    "null",
+    "of",
+    "on",
+    "operator",
+    "part",
+    "required",
+    "rethrow",
+    "return",
+    "sealed",
+    "set",
+    "show",
+    "static",
+    "super",
+    "switch",
+    "sync",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "type",
+    "typedef",
+    "var",
+    "void",
+    "when",
+    "while",
+    "with",
+    "yield"
+  ],
+  builtins: [
+    "Object",
+    "String",
+    "int",
+    "double",
+    "num",
+    "bool",
+    "List",
+    "Map",
+    "Set",
+    "Future",
+    "Stream",
+    "Duration",
+    "DateTime",
+    "RegExp",
+    "Exception"
+  ],
+  annotations: true,
+  preprocessor: false
+});
+export {
+  dart
+};

package/dist/esm/languages/dockerfile.js

@@ -0,0 +1,53 @@
+// 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+/ };
+
+// src/languages/dockerfile.ts
+var INSTRUCTIONS = [
+  "ADD",
+  "ARG",
+  "CMD",
+  "COPY",
+  "ENTRYPOINT",
+  "ENV",
+  "EXPOSE",
+  "FROM",
+  "HEALTHCHECK",
+  "LABEL",
+  "MAINTAINER",
+  "ONBUILD",
+  "RUN",
+  "SHELL",
+  "STOPSIGNAL",
+  "USER",
+  "VOLUME",
+  "WORKDIR"
+];
+var dockerfile = {
+  id: "dockerfile",
+  aliases: ["docker"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        { type: "keyword", pattern: words(INSTRUCTIONS, "i") },
+        { type: "variable", pattern: /\$(?:\{[^}\r\n]*}?|[A-Za-z_]\w*)/ },
+        { type: "string", pattern: /"(?:\\.|[^"\\\r\n])*"?/ },
+        { type: "string", pattern: /'(?:\\.|[^'\\\r\n])*'?/ },
+        { type: "operator", pattern: /(?:&&|\|\||\\|=)/ },
+        { type: "punctuation", pattern: /[()[\]{}:,]/ },
+        { type: "constant", pattern: /--[a-z-]+/i },
+        { type: "value", pattern: /[^\s#"'&|\\=()[\]{}:,]+/ },
+        whitespaceRule
+      ]
+    }
+  }
+};
+export {
+  dockerfile
+};

package/dist/esm/languages/go.js

@@ -0,0 +1,158 @@
+// 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/go.ts
+var go = createCLikeGrammar({
+  id: "go",
+  aliases: ["golang"],
+  keywords: [
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var"
+  ],
+  builtins: [
+    "append",
+    "bool",
+    "byte",
+    "cap",
+    "close",
+    "complex",
+    "complex64",
+    "complex128",
+    "copy",
+    "delete",
+    "error",
+    "false",
+    "float32",
+    "float64",
+    "imag",
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "iota",
+    "len",
+    "make",
+    "new",
+    "nil",
+    "panic",
+    "print",
+    "println",
+    "real",
+    "recover",
+    "rune",
+    "string",
+    "true",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr"
+  ],
+  annotations: false,
+  preprocessor: false
+});
+export {
+  go
+};

package/dist/esm/languages/graphql.js

@@ -0,0 +1,64 @@
+// 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 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/
+};
+
+// src/languages/graphql.ts
+var KEYWORDS = [
+  "directive",
+  "enum",
+  "extend",
+  "fragment",
+  "implements",
+  "input",
+  "interface",
+  "mutation",
+  "on",
+  "query",
+  "repeatable",
+  "scalar",
+  "schema",
+  "subscription",
+  "type",
+  "union"
+];
+var graphql = {
+  id: "graphql",
+  aliases: ["gql"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        { type: "string", pattern: /"""[\s\S]*?(?:"""|$)/ },
+        { type: "string", pattern: /"(?:\\.|[^"\\\r\n])*"?/ },
+        { type: "variable", pattern: /\$[A-Za-z_]\w*/ },
+        { type: "decorator", pattern: /@[A-Za-z_]\w*/ },
+        numberRule,
+        { type: "boolean", pattern: /\b(?:true|false)\b/ },
+        { type: "null", pattern: /\bnull\b/ },
+        { type: "keyword", pattern: words(KEYWORDS) },
+        { type: "type", pattern: /\b[A-Z][A-Za-z\d_]*\b/ },
+        { type: "property", pattern: /\b[A-Za-z_]\w*(?=\s*:)/ },
+        { type: "variable", pattern: /\b[A-Za-z_]\w*\b/ },
+        { type: "operator", pattern: /[!|=&]/ },
+        punctuationRule,
+        whitespaceRule
+      ]
+    }
+  }
+};
+export {
+  graphql
+};

package/dist/esm/languages/html.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/html.ts
+var html = createMarkupGrammar({ id: "html", aliases: ["htm"] });
+export {
+  html
+};

package/dist/esm/languages/ini.js

@@ -0,0 +1,27 @@
+// src/languages/shared/helpers.ts
+var whitespaceRule = { type: "plain", pattern: /\s+/ };
+
+// src/languages/ini.ts
+var ini = {
+  id: "ini",
+  aliases: ["dotenv", "properties"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /[;#][^\r\n]*/ },
+        { type: "heading", pattern: /\[[^\]\r\n]+\]/ },
+        { type: "property", pattern: /[A-Za-z_][\w.-]*(?=\s*[=:])/ },
+        { type: "string", pattern: /"(?:\\.|[^"\\\r\n])*"?/ },
+        { type: "string", pattern: /'(?:\\.|[^'\\\r\n])*'?/ },
+        { type: "boolean", pattern: /\b(?:true|false|yes|no|on|off)\b/i },
+        { type: "number", pattern: /[-+]?\b\d+(?:\.\d+)?\b/ },
+        { type: "operator", pattern: /[=:]/ },
+        whitespaceRule,
+        { type: "value", pattern: /[^\s;#=:]+/ }
+      ]
+    }
+  }
+};
+export {
+  ini
+};

package/dist/esm/languages/java.js

@@ -0,0 +1,175 @@
+// 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/java.ts
+var java = createCLikeGrammar({
+  id: "java",
+  aliases: [],
+  keywords: [
+    "abstract",
+    "assert",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "exports",
+    "extends",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "instanceof",
+    "int",
+    "interface",
+    "long",
+    "module",
+    "native",
+    "new",
+    "non-sealed",
+    "open",
+    "opens",
+    "package",
+    "permits",
+    "private",
+    "protected",
+    "provides",
+    "public",
+    "record",
+    "requires",
+    "return",
+    "sealed",
+    "short",
+    "static",
+    "strictfp",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "to",
+    "transient",
+    "transitive",
+    "try",
+    "uses",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield"
+  ],
+  builtins: [
+    "String",
+    "Object",
+    "System",
+    "Math",
+    "Integer",
+    "Long",
+    "Double",
+    "Boolean",
+    "List",
+    "Map",
+    "Set",
+    "Optional",
+    "Stream",
+    "Exception",
+    "RuntimeException"
+  ],
+  annotations: true,
+  preprocessor: false
+});
+export {
+  java
+};