@blcklab/yuirinx 0.1.1

package/dist/cjs/languages/bash.cjs

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/languages/bash.ts
+var bash_exports = {};
+__export(bash_exports, {
+  bash: () => bash
+});
+module.exports = __toCommonJS(bash_exports);
+
+// 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
+      ]
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bash
+});

package/dist/cjs/languages/c.cjs

@@ -0,0 +1,177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/languages/c.ts
+var c_exports = {};
+__export(c_exports, {
+  c: () => c
+});
+module.exports = __toCommonJS(c_exports);
+
+// 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/c.ts
+var c = createCLikeGrammar({
+  id: "c",
+  aliases: ["h"],
+  keywords: [
+    "auto",
+    "break",
+    "case",
+    "char",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "extern",
+    "float",
+    "for",
+    "goto",
+    "if",
+    "inline",
+    "int",
+    "long",
+    "register",
+    "restrict",
+    "return",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "struct",
+    "switch",
+    "typedef",
+    "union",
+    "unsigned",
+    "void",
+    "volatile",
+    "while",
+    "_Alignas",
+    "_Alignof",
+    "_Atomic",
+    "_Bool",
+    "_Complex",
+    "_Generic",
+    "_Imaginary",
+    "_Noreturn",
+    "_Static_assert",
+    "_Thread_local"
+  ],
+  builtins: [
+    "NULL",
+    "FILE",
+    "size_t",
+    "ptrdiff_t",
+    "uint8_t",
+    "uint16_t",
+    "uint32_t",
+    "uint64_t",
+    "int8_t",
+    "int16_t",
+    "int32_t",
+    "int64_t"
+  ],
+  annotations: false,
+  preprocessor: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  c
+});

package/dist/cjs/languages/cpp.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/languages/cpp.ts
+var cpp_exports = {};
+__export(cpp_exports, {
+  cpp: () => cpp
+});
+module.exports = __toCommonJS(cpp_exports);
+
+// 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/cpp.ts
+var cpp = createCLikeGrammar({
+  id: "cpp",
+  aliases: ["c++", "cc", "cxx", "hpp"],
+  keywords: [
+    "alignas",
+    "alignof",
+    "and",
+    "and_eq",
+    "asm",
+    "atomic_cancel",
+    "atomic_commit",
+    "atomic_noexcept",
+    "auto",
+    "bitand",
+    "bitor",
+    "bool",
+    "break",
+    "case",
+    "catch",
+    "char",
+    "char8_t",
+    "char16_t",
+    "char32_t",
+    "class",
+    "compl",
+    "concept",
+    "const",
+    "consteval",
+    "constexpr",
+    "constinit",
+    "const_cast",
+    "continue",
+    "co_await",
+    "co_return",
+    "co_yield",
+    "decltype",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "dynamic_cast",
+    "else",
+    "enum",
+    "explicit",
+    "export",
+    "extern",
+    "false",
+    "float",
+    "for",
+    "friend",
+    "goto",
+    "if",
+    "inline",
+    "int",
+    "long",
+    "mutable",
+    "namespace",
+    "new",
+    "noexcept",
+    "not",
+    "not_eq",
+    "nullptr",
+    "operator",
+    "or",
+    "or_eq",
+    "private",
+    "protected",
+    "public",
+    "reflexpr",
+    "register",
+    "reinterpret_cast",
+    "requires",
+    "return",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "static_assert",
+    "static_cast",
+    "struct",
+    "switch",
+    "synchronized",
+    "template",
+    "this",
+    "thread_local",
+    "throw",
+    "true",
+    "try",
+    "typedef",
+    "typeid",
+    "typename",
+    "union",
+    "unsigned",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "wchar_t",
+    "while",
+    "xor",
+    "xor_eq"
+  ],
+  builtins: [
+    "std",
+    "string",
+    "vector",
+    "map",
+    "set",
+    "unordered_map",
+    "unique_ptr",
+    "shared_ptr",
+    "optional",
+    "variant",
+    "tuple",
+    "array",
+    "cout",
+    "cin",
+    "cerr",
+    "endl",
+    "size_t"
+  ],
+  annotations: false,
+  preprocessor: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cpp
+});