@blcklab/yuirinx 0.1.1

package/dist/cjs/languages/tsx.cjs

@@ -0,0 +1,264 @@
+"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/tsx.ts
+var tsx_exports = {};
+__export(tsx_exports, {
+  tsx: () => tsx
+});
+module.exports = __toCommonJS(tsx_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/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/tsx.ts
+var tsx = createEcmaGrammar({
+  id: "tsx",
+  aliases: ["typescriptreact"],
+  typescript: true,
+  jsx: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tsx
+});

package/dist/cjs/languages/typescript.cjs

@@ -0,0 +1,263 @@
+"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/typescript.ts
+var typescript_exports = {};
+__export(typescript_exports, {
+  typescript: () => typescript
+});
+module.exports = __toCommonJS(typescript_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/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/typescript.ts
+var typescript = createEcmaGrammar({
+  id: "typescript",
+  aliases: ["ts", "mts", "cts"],
+  typescript: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  typescript
+});

package/dist/cjs/languages/vue.cjs

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

package/dist/cjs/languages/xml.cjs

@@ -0,0 +1,77 @@
+"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/xml.ts
+var xml_exports = {};
+__export(xml_exports, {
+  xml: () => xml
+});
+module.exports = __toCommonJS(xml_exports);
+
+// 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/xml.ts
+var xml = createMarkupGrammar({
+  id: "xml",
+  aliases: ["xhtml", "svg"]
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  xml
+});