@blcklab/yuirinx 0.1.1 → 0.1.2

package/dist/esm/languages/tsx.js

@@ -1,232 +1,5 @@
-// 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({
+import { createEcmaGrammar } from "./shared/ecmascript.js";
+const tsx = createEcmaGrammar({
   id: "tsx",
   aliases: ["typescriptreact"],
   typescript: true,

package/dist/esm/languages/typescript.js

@@ -1,232 +1,5 @@
-// 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({
+import { createEcmaGrammar } from "./shared/ecmascript.js";
+const typescript = createEcmaGrammar({
   id: "typescript",
   aliases: ["ts", "mts", "cts"],
   typescript: true

package/dist/esm/languages/vue.js

@@ -1,47 +1,5 @@
-// 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" });
+import { createMarkupGrammar } from "./shared/markup.js";
+const vue = createMarkupGrammar({ id: "vue" });
 export {
   vue
 };

package/dist/esm/languages/xml.js

@@ -1,47 +1,5 @@
-// 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({
+import { createMarkupGrammar } from "./shared/markup.js";
+const xml = createMarkupGrammar({
   id: "xml",
   aliases: ["xhtml", "svg"]
 });

package/dist/esm/languages/yaml.js

@@ -1,8 +1,5 @@
-// src/languages/shared/helpers.ts
-var whitespaceRule = { type: "plain", pattern: /\s+/ };
-
-// src/languages/yaml.ts
-var yaml = {
+import { whitespaceRule } from "./shared/helpers.js";
+const yaml = {
   id: "yaml",
   aliases: ["yml"],
   states: {

package/dist/esm/singleton.js

@@ -0,0 +1,24 @@
+import { createHighlighter } from "./core/create-highlighter.js";
+const defaultHighlighter = createHighlighter();
+function highlight(code, options = {}) {
+  return defaultHighlighter.highlight(code, options);
+}
+function tokenize(code, language) {
+  return defaultHighlighter.tokenize(code, language);
+}
+function render(tokens, options) {
+  return defaultHighlighter.render(tokens, options);
+}
+function registerLanguage(grammar) {
+  defaultHighlighter.registerLanguage(grammar);
+}
+function registerTheme(theme) {
+  defaultHighlighter.registerTheme(theme);
+}
+export {
+  highlight,
+  registerLanguage,
+  registerTheme,
+  render,
+  tokenize
+};