@blcklab/yuirinx 0.1.1

package/dist/esm/languages/scss.js

@@ -0,0 +1,71 @@
+// src/languages/shared/helpers.ts
+var whitespaceRule = { type: "plain", pattern: /\s+/ };
+var punctuationRule = {
+  type: "punctuation",
+  pattern: /[()[\]{}.,;:]/
+};
+var operatorRule = {
+  type: "operator",
+  pattern: /(?:===|!==|>>>|<<=|>>=|=>|==|!=|<=|>=|&&|\|\||\?\?|\?\.|\+\+|--|\+=|-=|\*=|\/=|%=|\*\*|<<|>>|[+\-*/%=&|!<>^~?])+/
+};
+var doubleStringRule = {
+  type: "string",
+  pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/
+};
+var singleStringRule = {
+  type: "string",
+  pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/
+};
+var blockCommentRule = {
+  type: (match) => match[0].startsWith("/**") ? "comment.documentation" : "comment",
+  pattern: /\/\*[\s\S]*?(?:\*\/|$)/
+};
+
+// src/languages/shared/css.ts
+function createCssGrammar(options) {
+  const rules = [
+    blockCommentRule,
+    ...options.scss ? [{ type: "comment", pattern: /\/\/[^\r\n]*/ }] : [],
+    doubleStringRule,
+    singleStringRule,
+    { type: "important", pattern: /!important\b/i },
+    { type: "at-rule", pattern: /@[a-z-]+\b/i },
+    { type: "constant", pattern: /#[\da-f]{3,8}\b/i },
+    { type: "variable", pattern: /(?:\$|--)[\w-]+/ },
+    { type: "number", pattern: /(?:\b\d*\.\d+|\b\d+)(?:e[+-]?\d+)?/i },
+    {
+      type: "unit",
+      pattern: /(?:%|px|r?em|vh|vw|vmin|vmax|ch|ex|cm|mm|in|pt|pc|s|ms|deg|rad|turn)\b/i
+    },
+    {
+      type: "selector",
+      pattern: /(?:[.#][\w-]+|::?[\w-]+|\[[^\]\r\n]+\])(?=\s*(?:[,>{+~]|$))/
+    },
+    { type: "property.css", pattern: /-?[a-z][\w-]*(?=\s*:)/i },
+    { type: "function.call", pattern: /[a-z-]+(?=\()/i },
+    {
+      type: "value",
+      pattern: /\b(?:auto|none|inherit|initial|unset|solid|relative|absolute|fixed|sticky|flex|grid|block|inline|transparent|currentColor)\b/i
+    },
+    operatorRule,
+    punctuationRule,
+    { type: "punctuation", pattern: /[>~]/ },
+    { type: "value", pattern: /-?[a-z_][\w-]*/i },
+    whitespaceRule
+  ];
+  return {
+    id: options.id,
+    ...options.aliases ? { aliases: options.aliases } : {},
+    states: { root: { rules } }
+  };
+}
+
+// src/languages/scss.ts
+var scss = createCssGrammar({
+  id: "scss",
+  aliases: ["sass"],
+  scss: true
+});
+export {
+  scss
+};

package/dist/esm/languages/shell.js

@@ -0,0 +1,118 @@
+// 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
+      ]
+    }
+  }
+};
+export {
+  bash as shell
+};

package/dist/esm/languages/sql.js

@@ -0,0 +1,123 @@
+// 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 = [
+  "add",
+  "all",
+  "alter",
+  "and",
+  "any",
+  "as",
+  "asc",
+  "between",
+  "by",
+  "case",
+  "check",
+  "column",
+  "constraint",
+  "create",
+  "cross",
+  "database",
+  "default",
+  "delete",
+  "desc",
+  "distinct",
+  "drop",
+  "else",
+  "end",
+  "exists",
+  "foreign",
+  "from",
+  "full",
+  "group",
+  "having",
+  "in",
+  "index",
+  "inner",
+  "insert",
+  "into",
+  "is",
+  "join",
+  "key",
+  "left",
+  "like",
+  "limit",
+  "not",
+  "null",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "primary",
+  "references",
+  "returning",
+  "right",
+  "select",
+  "set",
+  "table",
+  "then",
+  "union",
+  "unique",
+  "update",
+  "using",
+  "values",
+  "view",
+  "when",
+  "where",
+  "with"
+];
+var sql = {
+  id: "sql",
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /--[^\r\n]*/ },
+        { type: "comment", pattern: /\/\*[\s\S]*?(?:\*\/|$)/ },
+        singleStringRule,
+        doubleStringRule,
+        { type: "string", pattern: /`(?:``|[^`])*`?/ },
+        numberRule,
+        { type: "boolean", pattern: /\b(?:true|false)\b/i },
+        { type: "null", pattern: /\bnull\b/i },
+        { type: "keyword", pattern: words(KEYWORDS, "i") },
+        { type: "function.call", pattern: /\b[A-Za-z_]\w*(?=\s*\()/ },
+        { type: "property", pattern: /\b[A-Za-z_]\w*(?=\s*(?:,|\bfrom\b))/i },
+        { type: "variable", pattern: /(?:@{1,2}|:)[A-Za-z_]\w*/ },
+        { type: "variable", pattern: /\b[A-Za-z_]\w*\b/ },
+        operatorRule,
+        punctuationRule,
+        whitespaceRule
+      ]
+    }
+  }
+};
+export {
+  sql
+};

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

package/dist/esm/languages/swift.js

@@ -0,0 +1,189 @@
+// 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({
+  id: "swift",
+  aliases: [],
+  keywords: [
+    "associatedtype",
+    "class",
+    "deinit",
+    "enum",
+    "extension",
+    "fileprivate",
+    "func",
+    "import",
+    "init",
+    "inout",
+    "internal",
+    "let",
+    "open",
+    "operator",
+    "private",
+    "precedencegroup",
+    "protocol",
+    "public",
+    "rethrows",
+    "static",
+    "struct",
+    "subscript",
+    "typealias",
+    "var",
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "default",
+    "defer",
+    "do",
+    "else",
+    "fallthrough",
+    "for",
+    "guard",
+    "if",
+    "in",
+    "repeat",
+    "return",
+    "throw",
+    "switch",
+    "where",
+    "while",
+    "as",
+    "Any",
+    "catch",
+    "false",
+    "is",
+    "nil",
+    "self",
+    "Self",
+    "super",
+    "throws",
+    "true",
+    "try",
+    "async",
+    "await",
+    "actor",
+    "convenience",
+    "dynamic",
+    "didSet",
+    "final",
+    "get",
+    "indirect",
+    "infix",
+    "lazy",
+    "left",
+    "mutating",
+    "none",
+    "nonmutating",
+    "optional",
+    "override",
+    "postfix",
+    "precedence",
+    "prefix",
+    "required",
+    "right",
+    "set",
+    "some",
+    "Type",
+    "unowned",
+    "weak",
+    "willSet"
+  ],
+  builtins: [
+    "Array",
+    "Dictionary",
+    "Set",
+    "String",
+    "Int",
+    "Double",
+    "Float",
+    "Bool",
+    "Optional",
+    "Result",
+    "Error",
+    "Task"
+  ],
+  annotations: true,
+  preprocessor: true
+});
+export {
+  swift
+};

package/dist/esm/languages/toml.js

@@ -0,0 +1,36 @@
+// src/languages/shared/helpers.ts
+var whitespaceRule = { type: "plain", pattern: /\s+/ };
+
+// src/languages/toml.ts
+var toml = {
+  id: "toml",
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        { type: "heading", pattern: /\[\[?[^\]\r\n]+\]\]?/ },
+        {
+          type: "property",
+          pattern: /(?:[A-Za-z0-9_-]+|"[^"\r\n]+"|'[^'\r\n]+')(?=\s*=)/
+        },
+        { type: "string", pattern: /"""[\s\S]*?(?:"""|$)/ },
+        { type: "string", pattern: /'''[\s\S]*?(?:'''|$)/ },
+        { type: "string", pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/ },
+        { type: "string", pattern: /'[^'\r\n]*'?/ },
+        { type: "boolean", pattern: /\b(?:true|false)\b/ },
+        {
+          type: "number",
+          pattern: /[-+]?\b(?:0x[\da-f_]+|0o[0-7_]+|0b[01_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:e[-+]?\d+)?)\b/i
+        },
+        { type: "constant", pattern: /\b\d{4}-\d{2}-\d{2}(?:[Tt ][^\s#]+)?/ },
+        { type: "operator", pattern: /=/ },
+        { type: "punctuation", pattern: /[{}[\],.]/ },
+        whitespaceRule,
+        { type: "value", pattern: /[^\s=,\]}]+/ }
+      ]
+    }
+  }
+};
+export {
+  toml
+};