@shikijs/transformers 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @shikijs/transformers
+
+Collective of common transformers for [shiki](https://github.com/shikijs/shiki), inspired by [shiki-processor](https://github.com/innocenzi/shiki-processor).
+
+[Documentation](https://shiki.style/packages/transformers)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,150 @@
+import { ShikiTransformer, ShikiTransformerContext } from 'shiki';
+import { Element } from 'hast';
+
+interface TransformerRenderWhitespaceOptions {
+    /**
+     * Class for tab
+     *
+     * @default 'tab'
+     */
+    classTab?: string;
+    /**
+     * Class for space
+     *
+     * @default 'space'
+     */
+    classSpace?: string;
+    /**
+     * Position of rendered whitespace
+     * @default all position
+     */
+    position?: 'all' | 'boundary' | 'trailing';
+}
+/**
+ * Render whitespaces as separate tokens.
+ * Apply with CSS, it can be used to render tabs and spaces visually.
+ */
+declare function transformerRenderWhitespace(options?: TransformerRenderWhitespaceOptions): ShikiTransformer;
+
+/**
+ * Remove line breaks between lines.
+ * Useful when you override `display: block` to `.line` in CSS.
+ */
+declare function transformerRemoveLineBreak(): ShikiTransformer;
+
+interface TransformerCompactLineOption {
+    /**
+     * 1-based line number.
+     */
+    line: number;
+    classes?: string[];
+}
+/**
+ * Transformer for `shiki`'s legacy `lineOptions`
+ */
+declare function transformerCompactLineOptions(lineOptions?: TransformerCompactLineOption[]): ShikiTransformer;
+
+interface TransformerNotationFocusOptions {
+    /**
+     * Class for focused lines
+     */
+    classActiveLine?: string;
+    /**
+     * Class added to the root element when the code has focused lines
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code focus]` notation in code to mark focused lines.
+ */
+declare function transformerNotationFocus(options?: TransformerNotationFocusOptions): ShikiTransformer;
+
+interface TransformerNotationHighlightOptions {
+    /**
+     * Class for highlighted lines
+     */
+    classActiveLine?: string;
+    /**
+     * Class added to the root element when the code has highlighted lines
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code highlight]` notation in code to mark highlighted lines.
+ */
+declare function transformerNotationHighlight(options?: TransformerNotationHighlightOptions): ShikiTransformer;
+
+interface TransformerNotationWordHighlightOptions {
+    /**
+     * Class for highlighted words
+     */
+    classActiveWord?: string;
+    /**
+     * Class added to the root element when the code has highlighted words
+     */
+    classActivePre?: string;
+}
+declare function transformerNotationWordHighlight(options?: TransformerNotationWordHighlightOptions): ShikiTransformer;
+
+declare function parseMetaHighlightWords(meta: string): string[];
+interface TransformerMetaWordHighlightOptions {
+    /**
+     * Class for highlighted words
+     *
+     * @default 'highlighted-word'
+     */
+    className?: string;
+}
+/**
+ * Allow using `/word/` in the code snippet meta to mark highlighted words.
+ */
+declare function transformerMetaWordHighlight(options?: TransformerMetaWordHighlightOptions): ShikiTransformer;
+
+interface TransformerNotationDiffOptions {
+    /**
+     * Class for added lines
+     */
+    classLineAdd?: string;
+    /**
+     * Class for removed lines
+     */
+    classLineRemove?: string;
+    /**
+     * Class added to the <pre> element when the current code has diff
+     */
+    classActivePre?: string;
+}
+/**
+ * Use `[!code ++]` and `[!code --]` to mark added and removed lines.
+ */
+declare function transformerNotationDiff(options?: TransformerNotationDiffOptions): ShikiTransformer;
+
+interface TransformerNotationErrorLevelOptions {
+    classMap?: Record<string, string | string[]>;
+    /**
+     * Class added to the <pre> element when the current code has diff
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code error]` `[!code warning]` notation in code to mark highlighted lines.
+ */
+declare function transformerNotationErrorLevel(options?: TransformerNotationErrorLevelOptions): ShikiTransformer;
+
+declare function parseMetaHighlightString(meta: string): number[] | null;
+interface TransformerMetaHighlightOptions {
+    /**
+     * Class for highlighted lines
+     *
+     * @default 'highlighted'
+     */
+    className?: string;
+}
+/**
+ * Allow using `{1,3-5}` in the code snippet meta to mark highlighted lines.
+ */
+declare function transformerMetaHighlight(options?: TransformerMetaHighlightOptions): ShikiTransformer;
+
+declare function createCommentNotationTransformer(name: string, regex: RegExp, onMatch: (this: ShikiTransformerContext, match: string[], line: Element, commentNode: Element, lines: Element[], index: number) => boolean, removeEmptyLines?: boolean): ShikiTransformer;
+
+export { type TransformerCompactLineOption, type TransformerMetaHighlightOptions, type TransformerMetaWordHighlightOptions, type TransformerNotationDiffOptions, type TransformerNotationErrorLevelOptions, type TransformerNotationFocusOptions, type TransformerNotationHighlightOptions, type TransformerNotationWordHighlightOptions, type TransformerRenderWhitespaceOptions, createCommentNotationTransformer, parseMetaHighlightString, parseMetaHighlightWords, transformerCompactLineOptions, transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight, transformerRemoveLineBreak, transformerRenderWhitespace };

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+import { ShikiTransformer, ShikiTransformerContext } from 'shiki';
+import { Element } from 'hast';
+
+interface TransformerRenderWhitespaceOptions {
+    /**
+     * Class for tab
+     *
+     * @default 'tab'
+     */
+    classTab?: string;
+    /**
+     * Class for space
+     *
+     * @default 'space'
+     */
+    classSpace?: string;
+    /**
+     * Position of rendered whitespace
+     * @default all position
+     */
+    position?: 'all' | 'boundary' | 'trailing';
+}
+/**
+ * Render whitespaces as separate tokens.
+ * Apply with CSS, it can be used to render tabs and spaces visually.
+ */
+declare function transformerRenderWhitespace(options?: TransformerRenderWhitespaceOptions): ShikiTransformer;
+
+/**
+ * Remove line breaks between lines.
+ * Useful when you override `display: block` to `.line` in CSS.
+ */
+declare function transformerRemoveLineBreak(): ShikiTransformer;
+
+interface TransformerCompactLineOption {
+    /**
+     * 1-based line number.
+     */
+    line: number;
+    classes?: string[];
+}
+/**
+ * Transformer for `shiki`'s legacy `lineOptions`
+ */
+declare function transformerCompactLineOptions(lineOptions?: TransformerCompactLineOption[]): ShikiTransformer;
+
+interface TransformerNotationFocusOptions {
+    /**
+     * Class for focused lines
+     */
+    classActiveLine?: string;
+    /**
+     * Class added to the root element when the code has focused lines
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code focus]` notation in code to mark focused lines.
+ */
+declare function transformerNotationFocus(options?: TransformerNotationFocusOptions): ShikiTransformer;
+
+interface TransformerNotationHighlightOptions {
+    /**
+     * Class for highlighted lines
+     */
+    classActiveLine?: string;
+    /**
+     * Class added to the root element when the code has highlighted lines
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code highlight]` notation in code to mark highlighted lines.
+ */
+declare function transformerNotationHighlight(options?: TransformerNotationHighlightOptions): ShikiTransformer;
+
+interface TransformerNotationWordHighlightOptions {
+    /**
+     * Class for highlighted words
+     */
+    classActiveWord?: string;
+    /**
+     * Class added to the root element when the code has highlighted words
+     */
+    classActivePre?: string;
+}
+declare function transformerNotationWordHighlight(options?: TransformerNotationWordHighlightOptions): ShikiTransformer;
+
+declare function parseMetaHighlightWords(meta: string): string[];
+interface TransformerMetaWordHighlightOptions {
+    /**
+     * Class for highlighted words
+     *
+     * @default 'highlighted-word'
+     */
+    className?: string;
+}
+/**
+ * Allow using `/word/` in the code snippet meta to mark highlighted words.
+ */
+declare function transformerMetaWordHighlight(options?: TransformerMetaWordHighlightOptions): ShikiTransformer;
+
+interface TransformerNotationDiffOptions {
+    /**
+     * Class for added lines
+     */
+    classLineAdd?: string;
+    /**
+     * Class for removed lines
+     */
+    classLineRemove?: string;
+    /**
+     * Class added to the <pre> element when the current code has diff
+     */
+    classActivePre?: string;
+}
+/**
+ * Use `[!code ++]` and `[!code --]` to mark added and removed lines.
+ */
+declare function transformerNotationDiff(options?: TransformerNotationDiffOptions): ShikiTransformer;
+
+interface TransformerNotationErrorLevelOptions {
+    classMap?: Record<string, string | string[]>;
+    /**
+     * Class added to the <pre> element when the current code has diff
+     */
+    classActivePre?: string;
+}
+/**
+ * Allow using `[!code error]` `[!code warning]` notation in code to mark highlighted lines.
+ */
+declare function transformerNotationErrorLevel(options?: TransformerNotationErrorLevelOptions): ShikiTransformer;
+
+declare function parseMetaHighlightString(meta: string): number[] | null;
+interface TransformerMetaHighlightOptions {
+    /**
+     * Class for highlighted lines
+     *
+     * @default 'highlighted'
+     */
+    className?: string;
+}
+/**
+ * Allow using `{1,3-5}` in the code snippet meta to mark highlighted lines.
+ */
+declare function transformerMetaHighlight(options?: TransformerMetaHighlightOptions): ShikiTransformer;
+
+declare function createCommentNotationTransformer(name: string, regex: RegExp, onMatch: (this: ShikiTransformerContext, match: string[], line: Element, commentNode: Element, lines: Element[], index: number) => boolean, removeEmptyLines?: boolean): ShikiTransformer;
+
+export { type TransformerCompactLineOption, type TransformerMetaHighlightOptions, type TransformerMetaWordHighlightOptions, type TransformerNotationDiffOptions, type TransformerNotationErrorLevelOptions, type TransformerNotationFocusOptions, type TransformerNotationHighlightOptions, type TransformerNotationWordHighlightOptions, type TransformerRenderWhitespaceOptions, createCommentNotationTransformer, parseMetaHighlightString, parseMetaHighlightWords, transformerCompactLineOptions, transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight, transformerRemoveLineBreak, transformerRenderWhitespace };

package/dist/index.mjs

@@ -0,0 +1,394 @@
+import { addClassToHast } from 'shiki';
+import { addClassToHast as addClassToHast$1 } from 'shiki/core';
+
+function separateContinuousSpaces(inputs) {
+  const result = [];
+  let current = "";
+  function bump() {
+    if (current.length)
+      result.push(current);
+    current = "";
+  }
+  inputs.forEach((part, idx) => {
+    if (isTab(part)) {
+      bump();
+      result.push(part);
+    } else if (isSpace(part) && (isSpace(inputs[idx - 1]) || isSpace(inputs[idx + 1]))) {
+      bump();
+      result.push(part);
+    } else {
+      current += part;
+    }
+  });
+  bump();
+  return result;
+}
+function isTab(part) {
+  return part === "	";
+}
+function isSpace(part) {
+  return part === " " || part === "	";
+}
+function splitSpaces(parts, type, renderContinuousSpaces = true) {
+  if (type === "all")
+    return parts;
+  let leftCount = 0;
+  let rightCount = 0;
+  if (type === "boundary") {
+    for (let i = 0; i < parts.length; i++) {
+      if (isSpace(parts[i]))
+        leftCount++;
+      else
+        break;
+    }
+  }
+  if (type === "boundary" || type === "trailing") {
+    for (let i = parts.length - 1; i >= 0; i--) {
+      if (isSpace(parts[i]))
+        rightCount++;
+      else
+        break;
+    }
+  }
+  const middle = parts.slice(leftCount, parts.length - rightCount);
+  return [
+    ...parts.slice(0, leftCount),
+    ...renderContinuousSpaces ? separateContinuousSpaces(middle) : [middle.join("")],
+    ...parts.slice(parts.length - rightCount)
+  ];
+}
+
+function transformerRenderWhitespace(options = {}) {
+  const classMap = {
+    " ": options.classSpace ?? "space",
+    "	": options.classTab ?? "tab"
+  };
+  const position = options.position ?? "all";
+  const keys = Object.keys(classMap);
+  return {
+    name: "@shikijs/transformers:render-whitespace",
+    // We use `root` hook here to ensure it runs after all other transformers
+    root(root) {
+      const pre = root.children[0];
+      const code = pre.children[0];
+      code.children.forEach(
+        (line) => {
+          if (line.type !== "element")
+            return;
+          const elements = line.children.filter((token) => token.type === "element");
+          const last = elements.length - 1;
+          line.children = line.children.flatMap((token) => {
+            if (token.type !== "element")
+              return token;
+            const index = elements.indexOf(token);
+            if (position === "boundary" && index !== 0 && index !== last)
+              return token;
+            if (position === "trailing" && index !== last)
+              return token;
+            const node = token.children[0];
+            if (node.type !== "text" || !node.value)
+              return token;
+            const parts = splitSpaces(
+              node.value.split(/([ \t])/).filter((i) => i.length),
+              position === "boundary" && index === last && last !== 0 ? "trailing" : position,
+              position !== "trailing"
+            );
+            if (parts.length <= 1)
+              return token;
+            return parts.map((part) => {
+              const clone = {
+                ...token,
+                properties: { ...token.properties }
+              };
+              clone.children = [{ type: "text", value: part }];
+              if (keys.includes(part)) {
+                addClassToHast(clone, classMap[part]);
+                delete clone.properties.style;
+              }
+              return clone;
+            });
+          });
+        }
+      );
+    }
+  };
+}
+
+function transformerRemoveLineBreak() {
+  return {
+    name: "@shikijs/transformers:remove-line-break",
+    code(code) {
+      code.children = code.children.filter((line) => !(line.type === "text" && line.value === "\n"));
+    }
+  };
+}
+
+function transformerCompactLineOptions(lineOptions = []) {
+  return {
+    name: "@shikijs/transformers:compact-line-options",
+    line(node, line) {
+      const lineOption = lineOptions.find((o) => o.line === line);
+      if (lineOption?.classes)
+        addClassToHast(node, lineOption.classes);
+      return node;
+    }
+  };
+}
+
+function createCommentNotationTransformer(name, regex, onMatch, removeEmptyLines = false) {
+  return {
+    name,
+    code(code) {
+      const lines = code.children.filter((i) => i.type === "element");
+      const linesToRemove = [];
+      lines.forEach((line, idx) => {
+        let nodeToRemove;
+        for (const child of line.children) {
+          if (child.type !== "element")
+            continue;
+          const text = child.children[0];
+          if (text.type !== "text")
+            continue;
+          let replaced = false;
+          text.value = text.value.replace(regex, (...match) => {
+            if (onMatch.call(this, match, line, child, lines, idx)) {
+              replaced = true;
+              return "";
+            }
+            return match[0];
+          });
+          if (replaced && !text.value.trim())
+            nodeToRemove = child;
+        }
+        if (nodeToRemove) {
+          line.children.splice(line.children.indexOf(nodeToRemove), 1);
+          if (line.children.length === 0) {
+            linesToRemove.push(line);
+            if (removeEmptyLines) {
+              const next = code.children[code.children.indexOf(line) + 1];
+              if (next && next.type === "text" && next.value === "\n")
+                linesToRemove.push(next);
+            }
+          }
+        }
+      });
+      for (const line of linesToRemove)
+        code.children.splice(code.children.indexOf(line), 1);
+    }
+  };
+}
+
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function transformerNotationMap(options = {}, name = "@shikijs/transformers:notation-map") {
+  const {
+    classMap = {},
+    classActivePre = void 0
+  } = options;
+  return createCommentNotationTransformer(
+    name,
+    new RegExp(`\\s*(?://|/\\*|<!--|#)\\s+\\[!code (${Object.keys(classMap).map(escapeRegExp).join("|")})(:\\d+)?\\]\\s*(?:\\*/|-->)?`),
+    function([_, match, range = ":1"], _line, _comment, lines, index) {
+      const lineNum = Number.parseInt(range.slice(1), 10);
+      lines.slice(index, index + lineNum).forEach((line) => {
+        addClassToHast(line, classMap[match]);
+      });
+      if (classActivePre)
+        addClassToHast(this.pre, classActivePre);
+      return true;
+    }
+  );
+}
+
+function transformerNotationFocus(options = {}) {
+  const {
+    classActiveLine = "focused",
+    classActivePre = "has-focused"
+  } = options;
+  return transformerNotationMap(
+    {
+      classMap: {
+        focus: classActiveLine
+      },
+      classActivePre
+    },
+    "@shikijs/transformers:notation-focus"
+  );
+}
+
+function transformerNotationHighlight(options = {}) {
+  const {
+    classActiveLine = "highlighted",
+    classActivePre = "has-highlighted"
+  } = options;
+  return transformerNotationMap(
+    {
+      classMap: {
+        highlight: classActiveLine,
+        hl: classActiveLine
+      },
+      classActivePre
+    },
+    "@shikijs/transformers:notation-highlight"
+  );
+}
+
+function highlightWordInLine(line, ignoredElement, word, className) {
+  line.children = line.children.flatMap((span) => {
+    if (span.type !== "element" || span.tagName !== "span" || span === ignoredElement)
+      return span;
+    const textNode = span.children[0];
+    if (textNode.type !== "text")
+      return span;
+    return replaceSpan(span, textNode.value, word, className) ?? span;
+  });
+}
+function inheritElement(original, overrides) {
+  return {
+    ...original,
+    properties: {
+      ...original.properties
+    },
+    ...overrides
+  };
+}
+function replaceSpan(span, text, word, className) {
+  const index = text.indexOf(word);
+  if (index === -1)
+    return;
+  const createNode = (value) => inheritElement(span, {
+    children: [
+      {
+        type: "text",
+        value
+      }
+    ]
+  });
+  const nodes = [];
+  if (index > 0)
+    nodes.push(createNode(text.slice(0, index)));
+  const highlightedNode = createNode(word);
+  addClassToHast$1(highlightedNode, className);
+  nodes.push(highlightedNode);
+  if (index + word.length < text.length)
+    nodes.push(createNode(text.slice(index + word.length)));
+  return nodes;
+}
+
+function transformerNotationWordHighlight(options = {}) {
+  const {
+    classActiveWord = "highlighted-word",
+    classActivePre = void 0
+  } = options;
+  return createCommentNotationTransformer(
+    "@shikijs/transformers:notation-highlight-word",
+    // comment-start             | marker    | word           | range | comment-end
+    /^\s*(?:\/\/|\/\*|<!--|#)\s+\[!code word:((?:\\.|[^:\]])+)(:\d+)?\]\s*(?:\*\/|-->)?/,
+    function([_, word, range], _line, comment, lines, index) {
+      const lineNum = range ? Number.parseInt(range.slice(1), 10) : lines.length;
+      word = word.replace(/\\(.)/g, "$1");
+      lines.slice(index + 1, index + 1 + lineNum).forEach((line) => highlightWordInLine(line, comment, word, classActiveWord));
+      if (classActivePre)
+        addClassToHast(this.pre, classActivePre);
+      return true;
+    },
+    true
+    // remove empty lines
+  );
+}
+
+function parseMetaHighlightWords(meta) {
+  if (!meta)
+    return [];
+  const match = Array.from(meta.matchAll(/\/((?:\\.|[^\/])+?)\//ig));
+  return match.map((v) => v[1].replace(/\\(.)/g, "$1"));
+}
+function transformerMetaWordHighlight(options = {}) {
+  const {
+    className = "highlighted-word"
+  } = options;
+  return {
+    name: "@shikijs/transformers:meta-word-highlight",
+    line(node) {
+      if (!this.options.meta?.__raw)
+        return;
+      const words = parseMetaHighlightWords(this.options.meta.__raw);
+      for (const word of words)
+        highlightWordInLine(node, null, word, className);
+      return node;
+    }
+  };
+}
+
+function transformerNotationDiff(options = {}) {
+  const {
+    classLineAdd = "diff add",
+    classLineRemove = "diff remove",
+    classActivePre = "has-diff"
+  } = options;
+  return transformerNotationMap(
+    {
+      classMap: {
+        "++": classLineAdd,
+        "--": classLineRemove
+      },
+      classActivePre
+    },
+    "@shikijs/transformers:notation-diff"
+  );
+}
+
+function transformerNotationErrorLevel(options = {}) {
+  const {
+    classMap = {
+      error: ["highlighted", "error"],
+      warning: ["highlighted", "warning"]
+    },
+    classActivePre = "has-highlighted"
+  } = options;
+  return transformerNotationMap(
+    {
+      classMap,
+      classActivePre
+    },
+    "@shikijs/transformers:notation-error-level"
+  );
+}
+
+function parseMetaHighlightString(meta) {
+  if (!meta)
+    return null;
+  const match = meta.match(/{([\d,-]+)}/);
+  if (!match)
+    return null;
+  const lines = match[1].split(",").flatMap((v) => {
+    const num = v.split("-").map((v2) => Number.parseInt(v2, 10));
+    if (num.length === 1)
+      return [num[0]];
+    else
+      return Array.from({ length: num[1] - num[0] + 1 }, (_, i) => i + num[0]);
+  });
+  return lines;
+}
+const symbol = Symbol("highlighted-lines");
+function transformerMetaHighlight(options = {}) {
+  const {
+    className = "highlighted"
+  } = options;
+  return {
+    name: "@shikijs/transformers:meta-highlight",
+    line(node, line) {
+      var _a;
+      if (!this.options.meta?.__raw)
+        return;
+      (_a = this.meta)[symbol] || (_a[symbol] = parseMetaHighlightString(this.options.meta.__raw));
+      const lines = this.meta[symbol] || [];
+      if (lines.includes(line))
+        addClassToHast(node, className);
+      return node;
+    }
+  };
+}
+
+export { createCommentNotationTransformer, parseMetaHighlightString, parseMetaHighlightWords, transformerCompactLineOptions, transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight, transformerRemoveLineBreak, transformerRenderWhitespace };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@shikijs/transformers",
+  "type": "module",
+  "version": "1.0.0-beta.0",
+  "description": "Collective of common transformers transformers for Shiki",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/shikijs/shiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikijs/shiki.git",
+    "directory": "packages/transformers"
+  },
+  "bugs": "https://github.com/shikijs/shiki/issues",
+  "keywords": [
+    "shiki",
+    "@shikijs/transformers"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "shiki": "1.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub"
+  }
+}