@blcklab/yuirinx 0.1.1

package/dist/cjs/languages/python.cjs

@@ -0,0 +1,200 @@
+"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/python.ts
+var python_exports = {};
+__export(python_exports, {
+  python: () => python
+});
+module.exports = __toCommonJS(python_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/
+};
+
+// src/languages/python.ts
+var KEYWORDS = [
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "case",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "exec",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "match",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+];
+var BUILTINS = [
+  "abs",
+  "all",
+  "any",
+  "bool",
+  "bytes",
+  "callable",
+  "chr",
+  "dict",
+  "dir",
+  "divmod",
+  "enumerate",
+  "eval",
+  "filter",
+  "float",
+  "format",
+  "frozenset",
+  "getattr",
+  "hasattr",
+  "hash",
+  "help",
+  "hex",
+  "id",
+  "input",
+  "int",
+  "isinstance",
+  "issubclass",
+  "iter",
+  "len",
+  "list",
+  "map",
+  "max",
+  "memoryview",
+  "min",
+  "next",
+  "object",
+  "oct",
+  "open",
+  "ord",
+  "pow",
+  "print",
+  "property",
+  "range",
+  "repr",
+  "reversed",
+  "round",
+  "set",
+  "slice",
+  "sorted",
+  "str",
+  "sum",
+  "super",
+  "tuple",
+  "type",
+  "vars",
+  "zip"
+];
+var python = {
+  id: "python",
+  aliases: ["py"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        {
+          type: "string",
+          pattern: /(?:[rubf]{0,2})(?:"""|''')/i,
+          push: (match) => match[0].endsWith('"""') ? "tripleDouble" : "tripleSingle"
+        },
+        {
+          type: "string",
+          pattern: /(?:[rubf]{0,2})"(?:\\[\s\S]|[^"\\\r\n])*"?/i
+        },
+        {
+          type: "string",
+          pattern: /(?:[rubf]{0,2})'(?:\\[\s\S]|[^'\\\r\n])*'?/i
+        },
+        { type: "decorator", pattern: /@[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*/ },
+        numberRule,
+        { type: "boolean", pattern: /\b(?:True|False)\b/ },
+        { type: "null", pattern: /\bNone\b/ },
+        { type: "keyword", pattern: words(KEYWORDS) },
+        { type: "builtin", pattern: words(BUILTINS) },
+        { type: "function.call", pattern: /\b[A-Za-z_]\w*(?=\s*\()/ },
+        { type: "type", pattern: /\b[A-Z][A-Za-z\d_]*\b/ },
+        { type: "variable", pattern: /\b[A-Za-z_]\w*\b/ },
+        operatorRule,
+        punctuationRule,
+        whitespaceRule
+      ]
+    },
+    tripleDouble: {
+      fallbackType: "string",
+      rules: [
+        { type: "string", pattern: /"""/, pop: true },
+        { type: "string.escape", pattern: /\\[\s\S]/ },
+        { type: "string", pattern: /[^"\\]+/ },
+        { type: "string", pattern: /"|\\/ }
+      ]
+    },
+    tripleSingle: {
+      fallbackType: "string",
+      rules: [
+        { type: "string", pattern: /'''/, pop: true },
+        { type: "string.escape", pattern: /\\[\s\S]/ },
+        { type: "string", pattern: /[^'\\]+/ },
+        { type: "string", pattern: /'|\\/ }
+      ]
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  python
+});

package/dist/cjs/languages/ruby.cjs

@@ -0,0 +1,117 @@
+"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/ruby.ts
+var ruby_exports = {};
+__export(ruby_exports, {
+  ruby: () => ruby
+});
+module.exports = __toCommonJS(ruby_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/
+};
+
+// src/languages/ruby.ts
+var KEYWORDS = [
+  "BEGIN",
+  "END",
+  "alias",
+  "and",
+  "begin",
+  "break",
+  "case",
+  "class",
+  "def",
+  "defined?",
+  "do",
+  "else",
+  "elsif",
+  "end",
+  "ensure",
+  "false",
+  "for",
+  "if",
+  "in",
+  "module",
+  "next",
+  "nil",
+  "not",
+  "or",
+  "redo",
+  "rescue",
+  "retry",
+  "return",
+  "self",
+  "super",
+  "then",
+  "true",
+  "undef",
+  "unless",
+  "until",
+  "when",
+  "while",
+  "yield"
+];
+var ruby = {
+  id: "ruby",
+  aliases: ["rb"],
+  states: {
+    root: {
+      rules: [
+        { type: "comment", pattern: /#[^\r\n]*/ },
+        { type: "comment.documentation", pattern: /=begin[\s\S]*?(?:=end|$)/ },
+        { type: "string", pattern: /"(?:\\[\s\S]|[^"\\\r\n])*"?/ },
+        { type: "string", pattern: /'(?:\\[\s\S]|[^'\\\r\n])*'?/ },
+        { type: "string", pattern: /%[qQwWiIxr]?[^\w\s](?:\\.|[^\r\n])*?/ },
+        { type: "symbol", pattern: /:[A-Za-z_]\w*[!?=]?/ },
+        { type: "variable", pattern: /(?:@@?|\$)[A-Za-z_]\w*/ },
+        numberRule,
+        { type: "keyword", pattern: words(KEYWORDS) },
+        { type: "function.call", pattern: /\b[A-Za-z_]\w*[!?=]?(?=\s*\()/ },
+        { type: "class", pattern: /\b[A-Z][A-Za-z\d_]*\b/ },
+        { type: "variable", pattern: /\b[A-Za-z_]\w*[!?=]?\b/ },
+        operatorRule,
+        punctuationRule,
+        whitespaceRule
+      ]
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ruby
+});

package/dist/cjs/languages/rust.cjs

@@ -0,0 +1,179 @@
+"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/rust.ts
+var rust_exports = {};
+__export(rust_exports, {
+  rust: () => rust
+});
+module.exports = __toCommonJS(rust_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/rust.ts
+var rust = createCLikeGrammar({
+  id: "rust",
+  aliases: ["rs"],
+  keywords: [
+    "as",
+    "async",
+    "await",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "union",
+    "unsafe",
+    "use",
+    "where",
+    "while"
+  ],
+  builtins: [
+    "Box",
+    "String",
+    "Vec",
+    "Option",
+    "Result",
+    "Some",
+    "None",
+    "Ok",
+    "Err",
+    "Iterator",
+    "IntoIterator",
+    "Clone",
+    "Copy",
+    "Send",
+    "Sync",
+    "Sized",
+    "Unpin",
+    "Drop",
+    "Default"
+  ],
+  annotations: true,
+  preprocessor: false
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rust
+});

package/dist/cjs/languages/scss.cjs

@@ -0,0 +1,98 @@
+"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/scss.ts
+var scss_exports = {};
+__export(scss_exports, {
+  scss: () => scss
+});
+module.exports = __toCommonJS(scss_exports);
+
+// 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
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scss
+});