@blue-patterns/richtext 0.0.0-stage → 0.7.18

package/dist/internal/CodeSyntaxPlugin.js

@@ -0,0 +1,397 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file CodeSyntaxPlugin.tsx
+ * @input Uses @lexical/react (composer context), @lexical/code (CodeNode),
+ *   lexical, core CodeBlock's highlight styles and token types, and
+ *   CodeLineTokens (codeLineTokens.ts), core CodeBlock's tokens kept line by
+ *   line.
+ * @output Exports CodeSyntaxPlugin, which colors the code in every fenced code
+ *   block with core CodeBlock's tokenizer and syntax color tokens; and
+ *   CODE_SYNTAX_CLASS, the class the theme gives code blocks for it.
+ * @position Rendered by RichTextEditor and RichTextView. A fenced code block
+ *   with a language core CodeBlock knows is colored as core Markdown colors
+ *   it: the same tokenizer finds the same tokens, and each token type takes
+ *   its `--color-syntax-*` token (spec:AST-061 FR1) — no palette of its own.
+ *   The colors are CSS Custom Highlight ranges over the text Lexical renders,
+ *   the way core CodeBlock colors editable code, so the document and its DOM
+ *   are untouched. A block is colored in full when it appears, or when its
+ *   language, its element, or its set of text nodes changes. An edit that
+ *   only rewrites one text node's text re-tokenizes just the lines
+ *   CodeLineTokens says it can change, and replaces only the ranges in that
+ *   text node, reading no other. Browsers without the Highlight API show
+ *   plain code.
+ */
+import { useEffect, useState } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $isCodeNode, CodeNode } from '@lexical/code';
+import { $getNodeByKey, $isTextNode } from 'lexical';
+import { ensureHighlightStyles, TOKEN_TYPES } from '@blue-patterns/core/CodeBlock';
+import { listedLanguage, sameLanguages } from "../codeLanguages.js";
+import { CodeLineTokens } from "../codeLineTokens.js";
+
+/** The class the theme adds to every code block (editorTheme.ts). */
+export const CODE_SYNTAX_CLASS = 'astryx-richtext-code';
+let hasInjectedRules = false;
+
+/**
+ * The highlight rules for code blocks, injected once: each token type takes
+ * the same syntax color token core CodeBlock's rules use.
+ */
+function ensureRules() {
+  if (hasInjectedRules || typeof document === 'undefined') {
+    return;
+  }
+  hasInjectedRules = true;
+  const style = document.createElement('style');
+  style.setAttribute('data-astryx-richtext-code-syntax', '');
+  style.textContent = TOKEN_TYPES.map(type => `.${CODE_SYNTAX_CLASS}::highlight(astryx-${type}) { color: var(--color-syntax-${type}); }`).join('\n');
+  document.head.append(style);
+}
+function supportsHighlights() {
+  return typeof CSS !== 'undefined' && 'highlights' in CSS && typeof Highlight !== 'undefined';
+}
+
+/** A colored token: its range, and the highlight that holds it. */
+
+/**
+ * A colored code block, with what an edit needs to recolor part of it.
+ * Offsets in the rendered text are offsets in the block's DOM text nodes
+ * laid end to end, which is the code itself when its line breaks render as
+ * text, and the code without them when each renders as an element (`flat`).
+ */
+
+function highlightFor(type) {
+  const name = `astryx-${type}`;
+  let highlight = CSS.highlights.get(name);
+  if (highlight == null) {
+    highlight = new Highlight();
+    CSS.highlights.set(name, highlight);
+  }
+  return highlight;
+}
+
+/**
+ * The DOM position of `offset` in a block's rendered text: in the text node
+ * that holds the character there when `inside`, else in the first text node
+ * that reaches it. Null past the end of the text.
+ */
+function pointAt(block, offset, inside) {
+  const {
+    texts,
+    starts,
+    length
+  } = block;
+  if (texts.length === 0 || offset > length) {
+    return null;
+  }
+  let low = 0;
+  let high = texts.length - 1;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    const end = mid + 1 < texts.length ? starts[mid + 1] : length;
+    if (inside ? end > offset : end >= offset) {
+      high = mid;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return [texts[low], offset - starts[low]];
+}
+
+/** Colors one line's tokens. */
+function paintLine(block, line) {
+  // A flat block's rendered text has no line breaks before this line.
+  const base = block.lines.starts[line] - (block.flat ? line : 0);
+  const painted = [];
+  for (const token of block.lines.tokens[line] ?? []) {
+    const start = base + token.start;
+    const end = base + token.end;
+    const from = pointAt(block, start, start < end);
+    const to = pointAt(block, end, false);
+    if (from == null || to == null) {
+      continue;
+    }
+    const highlight = highlightFor(token.type);
+    try {
+      const range = new Range();
+      range.setStart(...from);
+      range.setEnd(...to);
+      highlight.add(range);
+      painted.push({
+        range,
+        highlight
+      });
+    } catch {
+      // A range the DOM refuses colors nothing.
+    }
+  }
+  block.ranges[line] = painted;
+}
+function unpaintLine(block, line) {
+  for (const {
+    range,
+    highlight
+  } of block.ranges[line] ?? []) {
+    highlight.delete(range);
+  }
+  block.ranges[line] = [];
+}
+function unpaintAll(block) {
+  for (let line = 0; line < block.ranges.length; line++) {
+    unpaintLine(block, line);
+  }
+  block.ranges = [];
+}
+function repaintAll(block) {
+  unpaintAll(block);
+  for (let line = 0; line < block.lines.tokens.length; line++) {
+    paintLine(block, line);
+  }
+}
+
+/**
+ * Lists a block's DOM text nodes in order with their offsets, and the
+ * Lexical text nodes that render as exactly one of them.
+ */
+function $indexText(editor, node, block) {
+  const walker = document.createTreeWalker(block.element, NodeFilter.SHOW_TEXT);
+  while (walker.nextNode() != null) {
+    const text = walker.currentNode;
+    block.texts.push(text);
+    block.starts.push(block.length);
+    block.codeStarts.push(NaN);
+    block.length += text.length;
+  }
+  const indexes = new Map(block.texts.map((text, index) => [text, index]));
+  let codeStart = 0;
+  for (const child of node.getChildren()) {
+    const dom = $isTextNode(child) ? editor.getElementByKey(child.getKey()) : null;
+    const index = dom?.childNodes.length === 1 ? indexes.get(dom.firstChild) : undefined;
+    if (index != null) {
+      block.leaves.set(child.getKey(), {
+        index,
+        text: child.getTextContent()
+      });
+      block.codeStarts[index] = codeStart;
+    }
+    codeStart += child.getTextContentSize();
+  }
+}
+
+/** The key of the code block that holds the node `key`, if any. */
+function $codeBlockOf(key) {
+  let node = $getNodeByKey(key)?.getParent() ?? null;
+  while (node != null && !$isCodeNode(node)) {
+    node = node.getParent();
+  }
+  return node?.getKey() ?? null;
+}
+export function CodeSyntaxPlugin({
+  codeLanguages
+} = {}) {
+  const [editor] = useLexicalComposerContext();
+  // Keep one list while it names the same values, so an inline
+  // `codeLanguages={[…]}` does not re-colour every block on each parent
+  // render (adjusting state during render, not in an Effect).
+  const [languages, setLanguages] = useState(codeLanguages);
+  if (!sameLanguages(languages, codeLanguages)) {
+    setLanguages(codeLanguages);
+  }
+
+  // Synchronizes the editor's code blocks with the CSS highlight registry:
+  // Lexical mutation and update listeners colour each block, and the cleanup
+  // removes the listeners and every highlight range they added.
+  useEffect(() => {
+    if (!supportsHighlights()) {
+      return undefined;
+    }
+    ensureRules();
+    // Every code block in the editor, the ones colored, and the ones colored
+    // in full during the current update.
+    const blocks = new Set();
+    const colored = new Map();
+    const repainted = new Set();
+    const uncolor = key => {
+      const block = colored.get(key);
+      if (block != null) {
+        unpaintAll(block);
+        colored.delete(key);
+      }
+    };
+    // Colors a block in full, unless `force` is false and its element,
+    // language, and code are as last colored.
+    const $color = (key, force) => {
+      const node = $getNodeByKey(key);
+      const element = editor.getElementByKey(key);
+      if (!$isCodeNode(node) || element == null) {
+        uncolor(key);
+        return;
+      }
+      const code = node.getTextContent();
+      const language = node.getLanguage() ?? '';
+      const previous = colored.get(key);
+      if (!force && previous != null && previous.element === element && previous.language === language && previous.lines.text === code) {
+        return;
+      }
+      uncolor(key);
+      const rendered = element.textContent ?? '';
+      if (rendered !== code && rendered !== code.replaceAll('\n', '')) {
+        // Not rendered yet; the block's next change tries again.
+        return;
+      }
+      ensureHighlightStyles();
+      const block = {
+        element,
+        language,
+        lines: new CodeLineTokens(code, listedLanguage(languages, language) ?? language),
+        flat: rendered !== code,
+        texts: [],
+        starts: [],
+        codeStarts: [],
+        length: 0,
+        leaves: new Map(),
+        ranges: []
+      };
+      $indexText(editor, node, block);
+      repaintAll(block);
+      colored.set(key, block);
+      repainted.add(key);
+    };
+    // Recolors a block after an update that rewrote the text of its leaf
+    // `leafKey` and changed nothing else in it. False when the block must
+    // be colored in full instead.
+    const $recolorLeaf = (key, leafKey) => {
+      const block = colored.get(key);
+      const leaf = block?.leaves.get(leafKey);
+      const node = $getNodeByKey(leafKey);
+      const parent = node?.getParent();
+      if (block == null || leaf == null || !$isTextNode(node) || !$isCodeNode(parent) || parent.getKey() !== key || (parent.getLanguage() ?? '') !== block.language || editor.getElementByKey(key) !== block.element) {
+        return false;
+      }
+      const text = block.texts[leaf.index];
+      const dom = editor.getElementByKey(leafKey);
+      const after = node.getTextContent();
+      if (dom?.childNodes.length !== 1 || dom.firstChild !== text || text.data !== after) {
+        return false;
+      }
+      const before = leaf.text;
+      if (after === before) {
+        return true;
+      }
+      let first = 0;
+      while (first < before.length && first < after.length && before[first] === after[first]) {
+        first++;
+      }
+      let beforeEnd = before.length;
+      let afterEnd = after.length;
+      while (beforeEnd > first && afterEnd > first && before[beforeEnd - 1] === after[afterEnd - 1]) {
+        beforeEnd--;
+        afterEnd--;
+      }
+      const inserted = after.slice(first, afterEnd);
+      // A flat block's text holds no line breaks; one typed in would no
+      // longer lay the code over its rendered text.
+      if (block.flat && inserted.includes('\n')) {
+        return false;
+      }
+      const leafStart = block.codeStarts[leaf.index];
+      const lines = block.lines.replace(leafStart + first, beforeEnd - first, inserted);
+      const delta = after.length - before.length;
+      for (let i = leaf.index + 1; i < block.texts.length; i++) {
+        block.starts[i] += delta;
+        block.codeStarts[i] += delta;
+      }
+      block.length += delta;
+      leaf.text = after;
+      if (lines == null) {
+        repaintAll(block);
+        return true;
+      }
+      // Lexical rewrites a changed DOM text node whole, which leaves every
+      // range in it stale: recolor each line the node holds, and any other
+      // line the edit re-tokenized. Every other range sits in a text node of
+      // its own line and is still right.
+      const recolor = new Set(lines);
+      const last = block.lines.lineAt(leafStart + Math.max(after.length - 1, 0));
+      for (let i = block.lines.lineAt(leafStart); i <= last; i++) {
+        recolor.add(i);
+      }
+      for (const i of recolor) {
+        unpaintLine(block, i);
+        paintLine(block, i);
+      }
+      return true;
+    };
+    const unregisterMutations = editor.registerMutationListener(CodeNode, mutations => {
+      editor.getEditorState().read(() => {
+        for (const [key, mutation] of mutations) {
+          if (mutation === 'destroyed') {
+            blocks.delete(key);
+            uncolor(key);
+          } else {
+            blocks.add(key);
+            $color(key, false);
+          }
+        }
+      });
+    }, {
+      skipInitialization: false
+    });
+    repainted.clear();
+    // Typing in a block changes its text nodes, not the block itself: after
+    // each update, recolor the blocks whose text nodes changed. A block whose
+    // only change is one leaf's text takes the partial path; any other
+    // change colors it in full, unless the block listener just did.
+    const unregisterUpdates = editor.registerUpdateListener(({
+      editorState,
+      mutatedNodes,
+      prevEditorState
+    }) => {
+      if (mutatedNodes != null && blocks.size > 0) {
+        const mutations = [];
+        for (const nodes of mutatedNodes.values()) {
+          for (const mutation of nodes) {
+            mutations.push(mutation);
+          }
+        }
+        const before = prevEditorState.read(() => mutations.map(([key, mutation]) => mutation === 'created' ? null : $codeBlockOf(key)));
+        editorState.read(() => {
+          // Each changed block, with the one leaf whose text an update
+          // rewrote, or null when anything else in it changed.
+          const changed = new Map();
+          const note = (key, leafKey) => {
+            if (key != null && blocks.has(key)) {
+              changed.set(key, changed.has(key) ? null : leafKey);
+            }
+          };
+          mutations.forEach(([key, mutation], i) => {
+            const after = mutation === 'destroyed' ? null : $codeBlockOf(key);
+            const rewritten = mutation === 'updated' && after === before[i] && $isTextNode($getNodeByKey(key));
+            note(after, rewritten ? key : null);
+            if (before[i] !== after) {
+              note(before[i], null);
+            }
+          });
+          for (const [key, leafKey] of changed) {
+            if (!repainted.has(key) && (leafKey == null || !$recolorLeaf(key, leafKey))) {
+              $color(key, true);
+            }
+          }
+        });
+      }
+      repainted.clear();
+    });
+    return () => {
+      unregisterMutations();
+      unregisterUpdates();
+      for (const key of [...colored.keys()]) {
+        uncolor(key);
+      }
+      blocks.clear();
+    };
+  }, [editor, languages]);
+  return null;
+}

package/dist/internal/CodeTabPlugin.d.ts

@@ -0,0 +1,2 @@
+export declare function CodeTabPlugin(): null;
+//# sourceMappingURL=CodeTabPlugin.d.ts.map

package/dist/internal/CodeTabPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeTabPlugin.d.ts","sourceRoot":"","sources":["../../src/internal/CodeTabPlugin.tsx"],"names":[],"mappings":"AAwQA,wBAAgB,aAAa,IAAI,IAAI,CAiCpC"}

package/dist/internal/CodeTabPlugin.js

@@ -0,0 +1,256 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file CodeTabPlugin.tsx
+ * @input Uses @lexical/react (composer context), @lexical/code (CodeNode), and
+ *   lexical.
+ * @output Exports CodeTabPlugin, which makes Tab and Shift+Tab in a code block
+ *   indent and outdent every line the selection touches, by the indent the
+ *   block's own lines use.
+ * @position Rendered by RichTextEditor; always on, and not exported from the
+ *   package. A press indents by the block's own indent, so edited code keeps
+ *   the indentation its author chose; the selection stays on the same
+ *   characters, and each press is one undo step. It replaces only what Tab
+ *   did in a code block before: TabIndentationPlugin put a tab character in
+ *   place of the selection. Its listener sits at the front of the
+ *   editor-priority queue, ahead of TabIndentationPlugin and behind every
+ *   low-priority listener, so Escape then Tab still moves focus out of the
+ *   editor (TabFocusEscapePlugin, WCAG 2.1.2). A selection that reaches
+ *   outside the code block keeps TabIndentationPlugin's meaning. Read-only
+ *   and disabled editors are unchanged.
+ */
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $isCodeNode } from '@lexical/code';
+import { $addUpdateTag, $createTextNode, $getSelection, $isRangeSelection, $isTabNode, $isTextNode, COMMAND_PRIORITY_BEFORE_EDITOR, HISTORY_PUSH_TAG, KEY_TAB_COMMAND } from 'lexical';
+
+/** The narrowest space indent a block uses, and the widest. */
+const MIN_SPACE_INDENT = 2;
+const MAX_SPACE_INDENT = 8;
+function leadingSpaces(line) {
+  return /^ */.exec(line)?.[0].length ?? 0;
+}
+
+/**
+ * The indent a code block's lines use: a tab when any line starts with one;
+ * otherwise the fewest spaces an indented line starts with, kept between two
+ * and eight; otherwise two spaces.
+ */
+function codeIndentUnit(lines) {
+  if (lines.some(line => line.startsWith('\t'))) {
+    return '\t';
+  }
+  const widths = lines.map(leadingSpaces).filter(width => width > 0);
+  const width = widths.length === 0 ? MIN_SPACE_INDENT : Math.min(...widths);
+  return ' '.repeat(Math.min(MAX_SPACE_INDENT, Math.max(MIN_SPACE_INDENT, width)));
+}
+
+/**
+ * A code block's children, the offset in the block's text where each one
+ * starts, and that text. A line ends at a line break node or at a newline
+ * inside a text node: imported code holds newlines, and Enter adds line
+ * break nodes.
+ */
+
+function $layoutOf(code) {
+  const children = code.getChildren();
+  const starts = [];
+  let text = '';
+  for (const child of children) {
+    starts.push(text.length);
+    text += child.getTextContent();
+  }
+  return {
+    children,
+    starts,
+    text
+  };
+}
+
+/** A text node that can take a caret and grow: any but a tab node. */
+function $isPlainText(node) {
+  return $isTextNode(node) && !$isTabNode(node);
+}
+
+/** The code block that holds both ends of the selection, or null. */
+function $selectionCodeBlock(selection) {
+  const blockOf = point => {
+    const node = point.getNode();
+    return $isCodeNode(node) ? node : node.getParent();
+  };
+  const block = blockOf(selection.anchor);
+  return $isCodeNode(block) && block.is(blockOf(selection.focus)) ? block : null;
+}
+
+/** Where a point of the block's selection falls in the block's text. */
+function $offsetOf(code, layout, point) {
+  if (point.key === code.getKey()) {
+    return point.offset < layout.children.length ? layout.starts[point.offset] : layout.text.length;
+  }
+  const index = layout.children.findIndex(child => child.getKey() === point.key);
+  return index < 0 ? 0 : layout.starts[index] + point.offset;
+}
+
+/**
+ * Moves a selection point to an offset in the block's text: into the text
+ * node there, or between children where none holds it (beside a tab or a
+ * line break, or on an empty line).
+ */
+function $placePoint(code, point, offset) {
+  const children = code.getChildren();
+  let start = 0;
+  for (let index = 0; index < children.length; index++) {
+    const child = children[index];
+    const size = child.getTextContentSize();
+    if ($isPlainText(child) && offset >= start && offset <= start + size) {
+      point.set(child.getKey(), offset - start, 'text');
+      return;
+    }
+    if (offset <= start) {
+      point.set(code.getKey(), index, 'element');
+      return;
+    }
+    start += size;
+  }
+  point.set(code.getKey(), children.length, 'element');
+}
+
+/** Inserts text at an offset in the block's text. */
+function $insertAt(code, offset, text) {
+  const {
+    children,
+    starts
+  } = $layoutOf(code);
+  for (let index = 0; index < children.length; index++) {
+    const child = children[index];
+    const start = starts[index];
+    if ($isPlainText(child) && offset >= start && offset <= start + child.getTextContentSize()) {
+      const content = child.getTextContent();
+      const at = offset - start;
+      child.setTextContent(content.slice(0, at) + text + content.slice(at));
+      return;
+    }
+    if (offset <= start) {
+      child.insertBefore($createTextNode(text));
+      return;
+    }
+  }
+  code.append($createTextNode(text));
+}
+
+/** Removes `count` characters at an offset in the block's text. */
+function $removeAt(code, offset, count) {
+  const {
+    children,
+    starts
+  } = $layoutOf(code);
+  let left = count;
+  for (let index = 0; index < children.length && left > 0; index++) {
+    const child = children[index];
+    const size = child.getTextContentSize();
+    if (!$isTextNode(child) || starts[index] + size <= offset) {
+      continue;
+    }
+    const from = Math.max(0, offset - starts[index]);
+    const removed = Math.min(left, size - from);
+    const content = child.getTextContent();
+    const rest = content.slice(0, from) + content.slice(from + removed);
+    if (rest === '') {
+      child.remove();
+    } else {
+      child.setTextContent(rest);
+    }
+    left -= removed;
+  }
+}
+
+/**
+ * Indents, or outdents, every line the selection touches by the block's own
+ * indent, and puts the selection back on the characters it held.
+ */
+function $shiftLines(code, selection, isOutdent) {
+  const layout = $layoutOf(code);
+  const lines = layout.text.split('\n');
+  const lineStarts = [];
+  let lineStart = 0;
+  for (const line of lines) {
+    lineStarts.push(lineStart);
+    lineStart += line.length + 1;
+  }
+  const lineAt = offset => {
+    let line = 0;
+    while (line + 1 < lineStarts.length && lineStarts[line + 1] <= offset) {
+      line++;
+    }
+    return line;
+  };
+  const unit = codeIndentUnit(lines);
+  // A tab-indented block outdents a space-indented line by the narrowest
+  // space indent.
+  const spaceUnit = unit === '\t' ? MIN_SPACE_INDENT : unit.length;
+  const anchor = $offsetOf(code, layout, selection.anchor);
+  const focus = $offsetOf(code, layout, selection.focus);
+  const start = Math.min(anchor, focus);
+  const end = Math.max(anchor, focus);
+  const first = lineAt(start);
+  let last = lineAt(end);
+  // A selection that ends where a line begins does not reach into that line.
+  if (last > first && lineStarts[last] === end) {
+    last--;
+  }
+  // Each edit as [offset, characters added (negative when removed)], made
+  // from the last line up so the offsets of the lines above stay true.
+  const edits = [];
+  for (let line = last; line >= first; line--) {
+    const at = lineStarts[line];
+    if (!isOutdent) {
+      $insertAt(code, at, unit);
+      edits.push([at, unit.length]);
+      continue;
+    }
+    const removed = lines[line].startsWith('\t') ? 1 : Math.min(leadingSpaces(lines[line]), spaceUnit);
+    if (removed > 0) {
+      $removeAt(code, at, removed);
+      edits.push([at, -removed]);
+    }
+  }
+  // A point keeps its character: text added at or before it pushes it on,
+  // and a point inside removed indentation moves to its line's start.
+  const shifted = offset => edits.reduce((moved, [at, delta]) => {
+    if (delta > 0) {
+      return offset >= at ? moved + delta : moved;
+    }
+    return offset > at ? moved - Math.min(-delta, offset - at) : moved;
+  }, offset);
+  $placePoint(code, selection.anchor, shifted(anchor));
+  $placePoint(code, selection.focus, shifted(focus));
+}
+export function CodeTabPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => editor.registerCommand(KEY_TAB_COMMAND, event => {
+    const selection = $getSelection();
+    if (!editor.isEditable() || !$isRangeSelection(selection)) {
+      return false;
+    }
+    const code = $selectionCodeBlock(selection);
+    if (code == null) {
+      return false;
+    }
+    event.preventDefault();
+    // One undo step per press, even when a press adds or removes a
+    // single character beside the caret. The push tag starts a step
+    // before the press. A dirty block makes history class the press
+    // as its own change, so typing after it starts another step.
+    $addUpdateTag(HISTORY_PUSH_TAG);
+    $shiftLines(code, selection, event.shiftKey);
+    code.markDirty();
+    return true;
+  },
+  // After TabFocusEscapePlugin's low-priority listener, which lets an
+  // armed Tab move focus, and before TabIndentationPlugin's; see the
+  // file header.
+  COMMAND_PRIORITY_BEFORE_EDITOR), [editor]);
+  return null;
+}

package/dist/internal/DisabledLinkGuardPlugin.d.ts

@@ -0,0 +1,4 @@
+export declare function DisabledLinkGuardPlugin({ isDisabled }: {
+    isDisabled: boolean;
+}): null;
+//# sourceMappingURL=DisabledLinkGuardPlugin.d.ts.map

package/dist/internal/DisabledLinkGuardPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DisabledLinkGuardPlugin.d.ts","sourceRoot":"","sources":["../../src/internal/DisabledLinkGuardPlugin.tsx"],"names":[],"mappings":"AAoEA,wBAAgB,uBAAuB,CAAC,EAAC,UAAU,EAAC,EAAE;IAAC,UAAU,EAAE,OAAO,CAAA;CAAC,QAwB1E"}