@docusaurus/utils 2.0.0-beta.14 → 2.0.0-beta.15

package/src/index.ts

@@ -8,11 +8,10 @@
 import logger from '@docusaurus/logger';
 import path from 'path';
 import {createHash} from 'crypto';
-import {camelCase, mapValues} from 'lodash';
-import escapeStringRegexp from 'escape-string-regexp';
+import {mapValues} from 'lodash';
 import fs from 'fs-extra';
 import {URL} from 'url';
-import {
+import type {
   ReportingSeverity,
   TranslationFileContent,
   TranslationFile,
@@ -20,32 +19,22 @@ import {
 
 import resolvePathnameUnsafe from 'resolve-pathname';
 
-import {posixPath as posixPathImport} from './posixPath';
 import {simpleHash, docuHash} from './hashUtils';
-import {normalizeUrl} from './normalizeUrl';
 import {DEFAULT_PLUGIN_ID} from './constants';
 
 export * from './constants';
-export * from './mdxUtils';
-export * from './normalizeUrl';
+export * from './urlUtils';
 export * from './tags';
-
-export const posixPath = posixPathImport;
-
 export * from './markdownParser';
 export * from './markdownLinks';
-export * from './escapePath';
 export * from './slugger';
-export {md5Hash, simpleHash, docuHash} from './hashUtils';
-export {
-  Globby,
-  GlobExcludeDefault,
-  createMatcher,
-  createAbsoluteFilePathMatcher,
-} from './globUtils';
+export * from './pathUtils';
+export * from './hashUtils';
+export * from './globUtils';
 export * from './webpackUtils';
+export * from './dataFileUtils';
 
-const fileHash = new Map();
+const fileHash = new Map<string, string>();
 export async function generate(
   generatedFilesDir: string,
   file: string,
@@ -80,18 +69,6 @@ export async function generate(
   }
 }
 
-export function objectWithKeySorted<T>(
-  obj: Record<string, T>,
-): Record<string, T> {
-  // https://github.com/lodash/lodash/issues/1459#issuecomment-460941233
-  return Object.keys(obj)
-    .sort()
-    .reduce((acc: Record<string, T>, key: string) => {
-      acc[key] = obj[key];
-      return acc;
-    }, {});
-}
-
 const indexRE = /(^|.*\/)index\.(md|mdx|js|jsx|ts|tsx)$/i;
 const extRE = /\.(md|mdx|js|jsx|ts|tsx)$/;
 
@@ -106,44 +83,13 @@ export function fileToPath(file: string): string {
   return `/${file.replace(extRE, '').replace(/\\/g, '/')}`;
 }
 
-export function encodePath(userpath: string): string {
-  return userpath
+export function encodePath(userPath: string): string {
+  return userPath
     .split('/')
     .map((item) => encodeURIComponent(item))
     .join('/');
 }
 
-/**
- * Convert first string character to the upper case.
- * E.g: docusaurus -> Docusaurus
- */
-export function upperFirst(str: string): string {
-  return str ? str.charAt(0).toUpperCase() + str.slice(1) : '';
-}
-
-/**
- * Generate unique React Component Name.
- * E.g: /foo-bar -> FooBar096
- */
-export function genComponentName(pagePath: string): string {
-  if (pagePath === '/') {
-    return 'index';
-  }
-  const pageHash = docuHash(pagePath);
-  return upperFirst(camelCase(pageHash));
-}
-
-// When you want to display a path in a message/warning/error,
-// it's more convenient to:
-// - make it relative to cwd()
-// - convert to posix (ie not using windows \ path separator)
-// This way, Jest tests can run more reliably on any computer/CI
-// on both Unix/Windows
-// For Windows users this is not perfect (as they see / instead of \) but it's probably good enough
-export function toMessageRelativeFilePath(filePath: string): string {
-  return posixPath(path.relative(process.cwd(), filePath));
-}
-
 const chunkNameCache = new Map();
 /**
  * Generate unique chunk name given a module path.
@@ -172,52 +118,6 @@ export function genChunkName(
   return chunkName;
 }
 
-// Too dynamic
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-export function idx(target: any, keyPaths?: string | (string | number)[]): any {
-  return (
-    target &&
-    keyPaths &&
-    (Array.isArray(keyPaths)
-      ? keyPaths.reduce((obj, key) => obj && obj[key], target)
-      : target[keyPaths])
-  );
-}
-
-/**
- * Given a filepath and dirpath, get the first directory.
- */
-export function getSubFolder(file: string, refDir: string): string | null {
-  const separator = escapeStringRegexp(path.sep);
-  const baseDir = escapeStringRegexp(path.basename(refDir));
-  const regexSubFolder = new RegExp(
-    `${baseDir}${separator}(.*?)${separator}.*`,
-  );
-  const match = regexSubFolder.exec(file);
-  return match && match[1];
-}
-
-/**
- * Alias filepath relative to site directory, very useful so that we
- * don't expose user's site structure.
- * Example: some/path/to/website/docs/foo.md -> @site/docs/foo.md
- */
-export function aliasedSitePath(filePath: string, siteDir: string): string {
-  const relativePath = posixPath(path.relative(siteDir, filePath));
-  // Cannot use path.join() as it resolves '../' and removes
-  // the '@site'. Let webpack loader resolve it.
-  return `@site/${relativePath}`;
-}
-
-export function getEditUrl(
-  fileRelativePath: string,
-  editUrl?: string,
-): string | undefined {
-  return editUrl
-    ? normalizeUrl([editUrl, posixPath(fileRelativePath)])
-    : undefined;
-}
-
 export function isValidPathname(str: string): boolean {
   if (!str.startsWith('/')) {
     return false;
@@ -240,7 +140,10 @@ export function addLeadingSlash(str: string): string {
 }
 
 export function addTrailingPathSeparator(str: string): string {
-  return str.endsWith(path.sep) ? str : `${str}${path.sep}`;
+  return str.endsWith(path.sep)
+    ? str
+    : // If this is Windows, we need to change the forward slash to backward
+      `${str.replace(/\/$/, '')}${path.sep}`;
 }
 
 // TODO deduplicate: also present in @docusaurus/utils-common
@@ -306,7 +209,40 @@ export function getPluginI18nPath({
   );
 }
 
-export async function mapAsyncSequencial<T, R>(
+/**
+ * @param permalink The URL that the HTML file corresponds to, without base URL
+ * @param outDir Full path to the output directory
+ * @param trailingSlash The site config option. If provided, only one path will be read.
+ * @returns This returns a buffer, which you have to decode string yourself if
+ * needed. (Not always necessary since the output isn't for human consumption
+ * anyways, and most HTML manipulation libs accept buffers)
+ */
+export async function readOutputHTMLFile(
+  permalink: string,
+  outDir: string,
+  trailingSlash: boolean | undefined,
+): Promise<Buffer> {
+  const withTrailingSlashPath = path.join(outDir, permalink, 'index.html');
+  const withoutTrailingSlashPath = path.join(outDir, `${permalink}.html`);
+  if (trailingSlash) {
+    return fs.readFile(withTrailingSlashPath);
+  } else if (trailingSlash === false) {
+    return fs.readFile(withoutTrailingSlashPath);
+  } else {
+    const HTMLPath = await findAsyncSequential(
+      [withTrailingSlashPath, withoutTrailingSlashPath],
+      fs.pathExists,
+    );
+    if (!HTMLPath) {
+      throw new Error(
+        `Expected output HTML file to be found at ${withTrailingSlashPath}`,
+      );
+    }
+    return fs.readFile(HTMLPath);
+  }
+}
+
+export async function mapAsyncSequential<T, R>(
   array: T[],
   action: (t: T) => Promise<R>,
 ): Promise<R[]> {
@@ -332,35 +268,6 @@ export async function findAsyncSequential<T>(
   return undefined;
 }
 
-// return the  first folder path in which the file exists in
-export async function findFolderContainingFile(
-  folderPaths: string[],
-  relativeFilePath: string,
-): Promise<string | undefined> {
-  return findAsyncSequential(folderPaths, (folderPath) =>
-    fs.pathExists(path.join(folderPath, relativeFilePath)),
-  );
-}
-
-export async function getFolderContainingFile(
-  folderPaths: string[],
-  relativeFilePath: string,
-): Promise<string> {
-  const maybeFolderPath = await findFolderContainingFile(
-    folderPaths,
-    relativeFilePath,
-  );
-  // should never happen, as the source was read from the FS anyway...
-  if (!maybeFolderPath) {
-    throw new Error(
-      `File "${relativeFilePath}" does not exist in any of these folders:\n- ${folderPaths.join(
-        '\n- ',
-      )}]`,
-    );
-  }
-  return maybeFolderPath;
-}
-
 export function reportMessage(
   message: string,
   reportingSeverity: ReportingSeverity,
@@ -392,20 +299,6 @@ export function mergeTranslations(
   return contents.reduce((acc, content) => ({...acc, ...content}), {});
 }
 
-export function getSwizzledComponent(
-  componentPath: string,
-): string | undefined {
-  const swizzledComponentPath = path.resolve(
-    process.cwd(),
-    'src',
-    componentPath,
-  );
-
-  return fs.existsSync(swizzledComponentPath)
-    ? swizzledComponentPath
-    : undefined;
-}
-
 // Useful to update all the messages of a translation file
 // Used in tests to simulate translations
 export function updateTranslationFileMessages(
@@ -420,21 +313,3 @@ export function updateTranslationFileMessages(
     })),
   };
 }
-
-// Input: ## Some heading {#some-heading}
-// Output: {text: "## Some heading", id: "some-heading"}
-export function parseMarkdownHeadingId(heading: string): {
-  text: string;
-  id?: string;
-} {
-  const customHeadingIdRegex = /^(.*?)\s*\{#([\w-]+)\}$/;
-  const matches = customHeadingIdRegex.exec(heading);
-  if (matches) {
-    return {
-      text: matches[1],
-      id: matches[2],
-    };
-  } else {
-    return {text: heading, id: undefined};
-  }
-}

package/src/markdownLinks.ts

@@ -6,7 +6,7 @@
  */
 
 import path from 'path';
-import {aliasedSitePath} from './index';
+import {aliasedSitePath} from './pathUtils';
 
 export type ContentPaths = {
   contentPath: string;
@@ -45,9 +45,16 @@ export function replaceMarkdownLinks<T extends ContentPaths>({
 
   // Replace internal markdown linking (except in fenced blocks).
   let fencedBlock = false;
+  let lastCodeFence = '';
   const lines = fileString.split('\n').map((line) => {
     if (line.trim().startsWith('```')) {
-      fencedBlock = !fencedBlock;
+      if (!fencedBlock) {
+        fencedBlock = true;
+        [lastCodeFence] = line.trim().match(/^`+/)!;
+        // If we are in a ````-fenced block, all ``` would be plain text instead of fences
+      } else if (line.trim().match(/^`+/)![0].length >= lastCodeFence.length) {
+        fencedBlock = false;
+      }
     }
     if (fencedBlock) {
       return line;
@@ -57,7 +64,7 @@ export function replaceMarkdownLinks<T extends ContentPaths>({
     // Replace inline-style links or reference-style links e.g:
     // This is [Document 1](doc1.md) -> we replace this doc1.md with correct link
     // [doc1]: doc1.md -> we replace this doc1.md with correct link
-    const mdRegex = /(?:(?:\]\()|(?:\]:\s?))(?!https)([^'")\]\s>]+\.mdx?)/g;
+    const mdRegex = /(?:(?:\]\()|(?:\]:\s?))(?!https?)([^'")\]\s>]+\.mdx?)/g;
     let mdMatch = mdRegex.exec(modifiedLine);
     while (mdMatch !== null) {
       // Replace it to correct html link.

package/src/markdownParser.ts

@@ -6,9 +6,26 @@
  */
 
 import logger from '@docusaurus/logger';
-import fs from 'fs-extra';
 import matter from 'gray-matter';
 
+// Input: ## Some heading {#some-heading}
+// Output: {text: "## Some heading", id: "some-heading"}
+export function parseMarkdownHeadingId(heading: string): {
+  text: string;
+  id?: string;
+} {
+  const customHeadingIdRegex = /^(.*?)\s*\{#([\w-]+)\}$/;
+  const matches = customHeadingIdRegex.exec(heading);
+  if (matches) {
+    return {
+      text: matches[1],
+      id: matches[2],
+    };
+  } else {
+    return {text: heading, id: undefined};
+  }
+}
+
 // Hacky way of stripping out import statements from the excerpt
 // TODO: Find a better way to do so, possibly by compiling the Markdown content,
 // stripping out HTML tags and obtaining the first line.
@@ -19,6 +36,7 @@ export function createExcerpt(fileString: string): string | undefined {
     .replace(/^[^\n]*\n[=]+/g, '')
     .split('\n');
   let inCode = false;
+  let lastCodeFence = '';
 
   /* eslint-disable no-continue */
   // eslint-disable-next-line no-restricted-syntax
@@ -35,7 +53,15 @@ export function createExcerpt(fileString: string): string | undefined {
 
     // Skip code block line.
     if (fileLine.trim().startsWith('```')) {
-      inCode = !inCode;
+      if (!inCode) {
+        inCode = true;
+        [lastCodeFence] = fileLine.trim().match(/^`+/)!;
+        // If we are in a ````-fenced block, all ``` would be plain text instead of fences
+      } else if (
+        fileLine.trim().match(/^`+/)![0].length >= lastCodeFence.length
+      ) {
+        inCode = false;
+      }
       continue;
     } else if (inCode) {
       continue;
@@ -82,8 +108,8 @@ export function parseFrontMatter(markdownFileContent: string): {
 } {
   const {data, content} = matter(markdownFileContent);
   return {
-    frontMatter: data ?? {},
-    content: content?.trim() ?? '',
+    frontMatter: data,
+    content: content.trim(),
   };
 }
 
@@ -166,22 +192,8 @@ export function parseMarkdownString(
       excerpt,
     };
   } catch (e) {
-    logger.error(`Error while parsing Markdown frontmatter.
-This can happen if you use special characters in frontmatter values (try using double quotes around that value).`);
+    logger.error(`Error while parsing Markdown front matter.
+This can happen if you use special characters in front matter values (try using double quotes around that value).`);
     throw e;
   }
 }
-
-export async function parseMarkdownFile(
-  source: string,
-  options?: {removeContentTitle?: boolean},
-): Promise<ParsedMarkdown> {
-  const markdownString = await fs.readFile(source, 'utf-8');
-  try {
-    return parseMarkdownString(markdownString, options);
-  } catch (e) {
-    throw new Error(
-      `Error while parsing Markdown file ${source}: "${(e as Error).message}".`,
-    );
-  }
-}

package/src/pathUtils.ts

@@ -7,22 +7,25 @@
 
 // Based on https://github.com/gatsbyjs/gatsby/pull/21518/files
 
+import path from 'path';
+
 // MacOS (APFS) and Windows (NTFS) filename length limit = 255 chars, Others = 255 bytes
 const MAX_PATH_SEGMENT_CHARS = 255;
 const MAX_PATH_SEGMENT_BYTES = 255;
 // Space for appending things to the string like file extensions and so on
 const SPACE_FOR_APPENDING = 10;
 
-const isMacOs = process.platform === `darwin`;
-const isWindows = process.platform === `win32`;
+const isMacOs = () => process.platform === 'darwin';
+const isWindows = () => process.platform === 'win32';
 
 export const isNameTooLong = (str: string): boolean =>
-  isMacOs || isWindows
+  // This is actually not entirely correct: we can't assume FS from OS. But good enough?
+  isMacOs() || isWindows()
     ? str.length + SPACE_FOR_APPENDING > MAX_PATH_SEGMENT_CHARS // MacOS (APFS) and Windows (NTFS) filename length limit (255 chars)
     : Buffer.from(str).length + SPACE_FOR_APPENDING > MAX_PATH_SEGMENT_BYTES; // Other (255 bytes)
 
 export const shortName = (str: string): string => {
-  if (isMacOs || isWindows) {
+  if (isMacOs() || isWindows()) {
     const overflowingChars = str.length - MAX_PATH_SEGMENT_CHARS;
     return str.slice(
       0,
@@ -39,3 +42,66 @@ export const shortName = (str: string): string => {
     )
     .toString();
 };
+
+/**
+ * Convert Windows backslash paths to posix style paths.
+ * E.g: endi\lie -> endi/lie
+ *
+ * Returns original path if the posix counterpart is not valid Windows path.
+ * This makes the legacy code that uses posixPath safe; but also makes it less
+ * useful when you actually want a path with forward slashes (e.g. for URL)
+ *
+ * Adopted from https://github.com/sindresorhus/slash/blob/main/index.js
+ */
+export function posixPath(str: string): string {
+  const isExtendedLengthPath = /^\\\\\?\\/.test(str);
+
+  // Forward slashes are only valid Windows paths when they don't contain non-ascii characters.
+  // eslint-disable-next-line no-control-regex
+  const hasNonAscii = /[^\u0000-\u0080]+/.test(str);
+
+  if (isExtendedLengthPath || hasNonAscii) {
+    return str;
+  }
+  return str.replace(/\\/g, '/');
+}
+
+// When you want to display a path in a message/warning/error,
+// it's more convenient to:
+// - make it relative to cwd()
+// - convert to posix (ie not using windows \ path separator)
+// This way, Jest tests can run more reliably on any computer/CI
+// on both Unix/Windows
+// For Windows users this is not perfect (as they see / instead of \) but it's probably good enough
+export function toMessageRelativeFilePath(filePath: string): string {
+  return posixPath(path.relative(process.cwd(), filePath));
+}
+
+/**
+ * Alias filepath relative to site directory, very useful so that we
+ * don't expose user's site structure.
+ * Example: some/path/to/website/docs/foo.md -> @site/docs/foo.md
+ */
+export function aliasedSitePath(filePath: string, siteDir: string): string {
+  const relativePath = posixPath(path.relative(siteDir, filePath));
+  // Cannot use path.join() as it resolves '../' and removes
+  // the '@site'. Let webpack loader resolve it.
+  return `@site/${relativePath}`;
+}
+
+/**
+ * When you have a path like C:\X\Y
+ * It is not safe to use directly when generating code
+ * For example, this would fail due to unescaped \: `<img src={require('${filePath}')} />`
+ * But this would work: `<img src={require('${escapePath(filePath)}')} />`
+ *
+ * posixPath can't be used in all cases, because forward slashes are only valid
+ * Windows paths when they don't contain non-ascii characters, and posixPath
+ * doesn't escape those that fail to be converted.
+ */
+export function escapePath(str: string): string {
+  const escaped = JSON.stringify(str);
+
+  // Remove the " around the json string;
+  return escaped.substring(1, escaped.length - 1);
+}

package/src/tags.ts

@@ -6,7 +6,7 @@
  */
 
 import {kebabCase, uniq, uniqBy} from 'lodash';
-import {normalizeUrl} from './normalizeUrl';
+import {normalizeUrl} from './urlUtils';
 
 export type Tag = {
   label: string;
@@ -47,10 +47,11 @@ export function normalizeFrontMatterTag(
 
 export function normalizeFrontMatterTags(
   tagsPath: string,
-  frontMatterTags: FrontMatterTag[] | undefined,
+  frontMatterTags: FrontMatterTag[] | undefined = [],
 ): Tag[] {
-  const tags =
-    frontMatterTags?.map((tag) => normalizeFrontMatterTag(tagsPath, tag)) ?? [];
+  const tags = frontMatterTags.map((tag) =>
+    normalizeFrontMatterTag(tagsPath, tag),
+  );
 
   return uniqBy(tags, (tag) => tag.permalink);
 }

package/src/{normalizeUrl.ts → urlUtils.ts}

@@ -15,7 +15,12 @@ export function normalizeUrl(rawUrls: string[]): string {
   // If the first part is a plain protocol, we combine it with the next part.
   if (urls[0].match(/^[^/:]+:\/*$/) && urls.length > 1) {
     const first = urls.shift();
-    urls[0] = first + urls[0];
+    if (first!.startsWith('file:') && urls[0].startsWith('/')) {
+      // Force a double slash here, else we lose the information that the next segment is an absolute path
+      urls[0] = `${first}//${urls[0]}`;
+    } else {
+      urls[0] = first + urls[0];
+    }
   }
 
   // There must be two or three slashes in the file protocol,
@@ -71,10 +76,20 @@ export function normalizeUrl(rawUrls: string[]): string {
   str = parts.shift() + (parts.length > 0 ? '?' : '') + parts.join('&');
 
   // Dedupe forward slashes in the entire path, avoiding protocol slashes.
-  str = str.replace(/([^:]\/)\/+/g, '$1');
+  str = str.replace(/([^:/]\/)\/+/g, '$1');
 
   // Dedupe forward slashes at the beginning of the path.
   str = str.replace(/^\/+/g, '/');
 
   return str;
 }
+
+export function getEditUrl(
+  fileRelativePath: string,
+  editUrl?: string,
+): string | undefined {
+  return editUrl
+    ? // Don't use posixPath for this: we need to force a forward slash path
+      normalizeUrl([editUrl, fileRelativePath.replace(/\\/g, '/')])
+    : undefined;
+}

package/src/webpackUtils.ts

@@ -7,7 +7,7 @@
 
 import type {RuleSetRule} from 'webpack';
 import path from 'path';
-import {posixPath} from './posixPath';
+import {escapePath} from './pathUtils';
 import {
   WEBPACK_URL_LOADER_LIMIT,
   OUTPUT_STATIC_ASSETS_DIR_NAME,
@@ -61,12 +61,12 @@ export function getFileLoaderUtils(): FileLoaderUtils {
     // Maybe with the ideal image plugin, all md images should be "ideal"?
     // This is used to force url-loader+file-loader on markdown images
     // https://webpack.js.org/concepts/loaders/#inline
-    inlineMarkdownImageFileLoader: `!${posixPath(
+    inlineMarkdownImageFileLoader: `!${escapePath(
       require.resolve('url-loader'),
     )}?limit=${urlLoaderLimit}&name=${fileLoaderFileName(
       'images',
-    )}&fallback=${posixPath(require.resolve('file-loader'))}!`,
-    inlineMarkdownLinkFileLoader: `!${posixPath(
+    )}&fallback=${escapePath(require.resolve('file-loader'))}!`,
+    inlineMarkdownLinkFileLoader: `!${escapePath(
       require.resolve('file-loader'),
     )}?name=${fileLoaderFileName('files')}!`,
   };

package/lib/escapePath.d.ts

@@ -1,18 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * When you have a path like C:\X\Y
- * It is not safe to use directly when generating code
- * For example, this would fail due to unescaped \: `<img src={require('${filePath}')} />`
- * But this would work: `<img src={require('${escapePath(filePath)}')} />`
- *
- * Workaround for issue in posixPath, maybe we won't need it anymore soon?
- * https://github.com/facebook/docusaurus/issues/4730#issuecomment-833530370
- * https://github.com/sindresorhus/slash/pull/16#issuecomment-833528479
- */
-export declare function escapePath(str: string): string;
-//# sourceMappingURL=escapePath.d.ts.map

package/lib/escapePath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"escapePath.d.ts","sourceRoot":"","sources":["../src/escapePath.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK9C"}

package/lib/escapePath.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapePath = void 0;
-/**
- * When you have a path like C:\X\Y
- * It is not safe to use directly when generating code
- * For example, this would fail due to unescaped \: `<img src={require('${filePath}')} />`
- * But this would work: `<img src={require('${escapePath(filePath)}')} />`
- *
- * Workaround for issue in posixPath, maybe we won't need it anymore soon?
- * https://github.com/facebook/docusaurus/issues/4730#issuecomment-833530370
- * https://github.com/sindresorhus/slash/pull/16#issuecomment-833528479
- */
-function escapePath(str) {
-    const escaped = JSON.stringify(str);
-    // Remove the " around the json string;
-    return escaped.substring(1, escaped.length - 1);
-}
-exports.escapePath = escapePath;
-//# sourceMappingURL=escapePath.js.map

package/lib/escapePath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"escapePath.js","sourceRoot":"","sources":["../src/escapePath.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH;;;;;;;;;GASG;AACH,SAAgB,UAAU,CAAC,GAAW;IACpC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAEpC,uCAAuC;IACvC,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAClD,CAAC;AALD,gCAKC"}

package/lib/mdxUtils.d.ts

@@ -1,17 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Transform mdx text to plain html text
- * Initially created to convert MDX blog posts to HTML for the RSS feed
- * without import/export nodes
- *
- * TODO not ideal implementation, won't work well with MDX elements!
- * TODO theme+global site config should be able to declare MDX comps in scope for rendering the RSS feeds
- * see also https://github.com/facebook/docusaurus/issues/4625
- */
-export declare function mdxToHtml(mdxStr: string): string;
-//# sourceMappingURL=mdxUtils.d.ts.map

package/lib/mdxUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mdxUtils.d.ts","sourceRoot":"","sources":["../src/mdxUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,GAEb,MAAM,CAMR"}