@blcklab/yuirinx 0.1.1

package/dist/esm/languages/javascript.js

@@ -0,0 +1,235 @@
+// 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({
+  id: "javascript",
+  aliases: ["js", "mjs", "cjs"]
+});
+export {
+  javascript
+};

package/dist/esm/languages/json.js

@@ -0,0 +1,33 @@
+// src/languages/shared/helpers.ts
+var whitespaceRule = { type: "plain", pattern: /\s+/ };
+
+// src/languages/json.ts
+var json = {
+  id: "json",
+  aliases: ["jsonc"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*/ },
+        {
+          type: (match) => {
+            const remainder = match.input.slice(match.index + match[0].length);
+            return /^\s*:/.test(remainder) ? "property" : "string";
+          },
+          pattern: /"(?:\\[\s\S]|[^"\\])*"?/
+        },
+        {
+          type: "number",
+          pattern: /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/
+        },
+        { type: "boolean", pattern: /\b(?:true|false)\b/ },
+        { type: "null", pattern: /\bnull\b/ },
+        { type: "punctuation", pattern: /[{}[\],:]/ },
+        whitespaceRule
+      ]
+    }
+  }
+};
+export {
+  json
+};

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

package/dist/esm/languages/kotlin.js

@@ -0,0 +1,184 @@
+// 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({
+  id: "kotlin",
+  aliases: ["kt", "kts"],
+  keywords: [
+    "as",
+    "break",
+    "class",
+    "continue",
+    "do",
+    "else",
+    "false",
+    "for",
+    "fun",
+    "if",
+    "in",
+    "interface",
+    "is",
+    "null",
+    "object",
+    "package",
+    "return",
+    "super",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typealias",
+    "typeof",
+    "val",
+    "var",
+    "when",
+    "while",
+    "by",
+    "catch",
+    "constructor",
+    "delegate",
+    "dynamic",
+    "field",
+    "file",
+    "finally",
+    "get",
+    "import",
+    "init",
+    "param",
+    "property",
+    "receiver",
+    "set",
+    "setparam",
+    "where",
+    "actual",
+    "abstract",
+    "annotation",
+    "companion",
+    "const",
+    "crossinline",
+    "data",
+    "enum",
+    "expect",
+    "external",
+    "final",
+    "infix",
+    "inline",
+    "inner",
+    "internal",
+    "lateinit",
+    "noinline",
+    "open",
+    "operator",
+    "out",
+    "override",
+    "private",
+    "protected",
+    "public",
+    "reified",
+    "sealed",
+    "suspend",
+    "tailrec",
+    "vararg"
+  ],
+  builtins: [
+    "Any",
+    "Unit",
+    "Nothing",
+    "String",
+    "Int",
+    "Long",
+    "Double",
+    "Float",
+    "Boolean",
+    "List",
+    "MutableList",
+    "Map",
+    "MutableMap",
+    "Set",
+    "Sequence",
+    "Result"
+  ],
+  annotations: true,
+  preprocessor: false
+});
+export {
+  kotlin
+};