npm - @dragon708/docmind-markdown - Versions diffs - 1.2.1 → 1.2.3 - Mend

@dragon708/docmind-markdown 1.2.1 → 1.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2249) hide show

package/node_modules/cheerio/src/load.ts ADDED Viewed

@@ -0,0 +1,282 @@
+import {
+  type CheerioOptions,
+  type InternalOptions,
+  flattenOptions,
+} from './options.js';
+import * as staticMethods from './static.js';
+import { Cheerio } from './cheerio.js';
+import { isHtml, isCheerio } from './utils.js';
+import type { AnyNode, Document, Element, ParentNode } from 'domhandler';
+import type { SelectorType, BasicAcceptedElems } from './types.js';
+import { ElementType } from 'htmlparser2';
+type StaticType = typeof staticMethods;
+/**
+ * A querying function, bound to a document created from the provided markup.
+ *
+ * Also provides several helper methods for dealing with the document as a
+ * whole.
+ */
+export interface CheerioAPI extends StaticType {
+  /**
+   * This selector method is the starting point for traversing and manipulating
+   * the document. Like jQuery, it's the primary method for selecting elements
+   * in the document.
+   *
+   * `selector` searches within the `context` scope, which searches within the
+   * `root` scope.
+   *
+   * @example
+   *
+   * ```js
+   * $('ul .pear').attr('class');
+   * //=> pear
+   *
+   * $('li[class=orange]').html();
+   * //=> Orange
+   *
+   * $('.apple', '#fruits').text();
+   * //=> Apple
+   * ```
+   *
+   * Optionally, you can also load HTML by passing the string as the selector:
+   *
+   * ```js
+   * $('<ul id="fruits">...</ul>');
+   * ```
+   *
+   * Or the context:
+   *
+   * ```js
+   * $('ul', '<ul id="fruits">...</ul>');
+   * ```
+   *
+   * Or as the root:
+   *
+   * ```js
+   * $('li', 'ul', '<ul id="fruits">...</ul>');
+   * ```
+   *
+   * @param selector - Either a selector to look for within the document, or the
+   *   contents of a new Cheerio instance.
+   * @param context - Either a selector to look for within the root, or the
+   *   contents of the document to query.
+   * @param root - Optional HTML document string.
+   */
+  <T extends AnyNode, S extends string>(
+    selector?: S | BasicAcceptedElems<T>,
+    context?: BasicAcceptedElems<AnyNode> | null,
+    root?: BasicAcceptedElems<Document>,
+    options?: CheerioOptions,
+  ): Cheerio<S extends SelectorType ? Element : T>;
+  /**
+   * The root the document was originally loaded with.
+   *
+   * @private
+   */
+  _root: Document;
+  /**
+   * The options the document was originally loaded with.
+   *
+   * @private
+   */
+  _options: InternalOptions;
+  /** Mimic jQuery's prototype alias for plugin authors. */
+  fn: typeof Cheerio.prototype;
+  /**
+   * The `.load` static method defined on the "loaded" Cheerio factory function
+   * is deprecated. Users are encouraged to instead use the `load` function
+   * exported by the Cheerio module.
+   *
+   * @deprecated Use the `load` function exported by the Cheerio module.
+   * @category Deprecated
+   * @example
+   *
+   * ```js
+   * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+   * ```
+   */
+  load: ReturnType<typeof getLoad>;
+}
+export function getLoad(
+  parse: Cheerio<AnyNode>['_parse'],
+  render: (
+    dom: AnyNode | ArrayLike<AnyNode>,
+    options: InternalOptions,
+  ) => string,
+) {
+  /**
+   * Create a querying function, bound to a document created from the provided
+   * markup.
+   *
+   * Note that similar to web browser contexts, this operation may introduce
+   * `<html>`, `<head>`, and `<body>` elements; set `isDocument` to `false` to
+   * switch to fragment mode and disable this.
+   *
+   * @param content - Markup to be loaded.
+   * @param options - Options for the created instance.
+   * @param isDocument - Allows parser to be switched to fragment mode.
+   * @returns The loaded document.
+   * @see {@link https://cheerio.js.org/docs/basics/loading#load} for additional usage information.
+   */
+  return function load(
+    content: string | AnyNode | AnyNode[] | Buffer,
+    options?: CheerioOptions | null,
+    isDocument = true,
+  ): CheerioAPI {
+    if ((content as string | null) == null) {
+      throw new Error('cheerio.load() expects a string');
+    }
+    const internalOpts = flattenOptions(options);
+    const initialRoot = parse(content, internalOpts, isDocument, null);
+    /**
+     * Create an extended class here, so that extensions only live on one
+     * instance.
+     */
+    class LoadedCheerio<T> extends Cheerio<T> {
+      _make<T>(
+        selector?: ArrayLike<T> | T | string,
+        context?: BasicAcceptedElems<AnyNode> | null,
+      ): Cheerio<T> {
+        const cheerio = initialize(selector, context);
+        cheerio.prevObject = this;
+        return cheerio;
+      }
+      _parse(
+        content: string | Document | AnyNode | AnyNode[] | Buffer,
+        options: InternalOptions,
+        isDocument: boolean,
+        context: ParentNode | null,
+      ) {
+        return parse(content, options, isDocument, context);
+      }
+      _render(dom: AnyNode | ArrayLike<AnyNode>): string {
+        return render(dom, this.options);
+      }
+    }
+    function initialize<T = AnyNode, S extends string = string>(
+      selector?: ArrayLike<T> | T | S,
+      context?: BasicAcceptedElems<AnyNode> | null,
+      root: BasicAcceptedElems<Document> = initialRoot,
+      opts?: CheerioOptions,
+    ): Cheerio<S extends SelectorType ? Element : T> {
+      type Result = S extends SelectorType ? Element : T;
+      // $($)
+      if (selector && isCheerio<Result>(selector)) return selector;
+      const options = flattenOptions(opts, internalOpts);
+      const r =
+        typeof root === 'string'
+          ? [parse(root, options, false, null)]
+          : 'length' in root
+            ? root
+            : [root];
+      const rootInstance = isCheerio<Document>(r)
+        ? r
+        : new LoadedCheerio<Document>(r, null, options);
+      // Add a cyclic reference, so that calling methods on `_root` never fails.
+      rootInstance._root = rootInstance;
+      // $(), $(null), $(undefined), $(false)
+      if (!selector) {
+        return new LoadedCheerio<Result>(undefined, rootInstance, options);
+      }
+      const elements: AnyNode[] | undefined =
+        typeof selector === 'string' && isHtml(selector)
+          ? // $(<html>)
+            parse(selector, options, false, null).children
+          : isNode(selector)
+            ? // $(dom)
+              [selector]
+            : Array.isArray(selector)
+              ? // $([dom])
+                selector
+              : undefined;
+      const instance = new LoadedCheerio(elements, rootInstance, options);
+      if (elements) {
+        return instance as Cheerio<Result>;
+      }
+      if (typeof selector !== 'string') {
+        throw new TypeError('Unexpected type of selector');
+      }
+      // We know that our selector is a string now.
+      let search = selector;
+      const searchContext: Cheerio<AnyNode> | undefined = context
+        ? // If we don't have a context, maybe we have a root, from loading
+          typeof context === 'string'
+          ? isHtml(context)
+            ? // $('li', '<ul>...</ul>')
+              new LoadedCheerio<Document>(
+                [parse(context, options, false, null)],
+                rootInstance,
+                options,
+              )
+            : // $('li', 'ul')
+              ((search = `${context} ${search}` as S), rootInstance)
+          : isCheerio<AnyNode>(context)
+            ? // $('li', $)
+              context
+            : // $('li', node), $('li', [nodes])
+              new LoadedCheerio<AnyNode>(
+                Array.isArray(context) ? context : [context],
+                rootInstance,
+                options,
+              )
+        : rootInstance;
+      // If we still don't have a context, return
+      if (!searchContext) return instance as Cheerio<Result>;
+      /*
+       * #id, .class, tag
+       */
+      return searchContext.find(search) as Cheerio<Result>;
+    }
+    // Add in static methods & properties
+    Object.assign(initialize, staticMethods, {
+      load,
+      // `_root` and `_options` are used in static methods.
+      _root: initialRoot,
+      _options: internalOpts,
+      // Add `fn` for plugins
+      fn: LoadedCheerio.prototype,
+      // Add the prototype here to maintain `instanceof` behavior.
+      prototype: LoadedCheerio.prototype,
+    });
+    return initialize as CheerioAPI;
+  };
+}
+function isNode(obj: unknown): obj is AnyNode {
+  return (
+    // @ts-expect-error: TS doesn't know about the `name` property.
+    !!obj.name ||
+    // @ts-expect-error: TS doesn't know about the `type` property.
+    obj.type === ElementType.Root ||
+    // @ts-expect-error: TS doesn't know about the `type` property.
+    obj.type === ElementType.Text ||
+    // @ts-expect-error: TS doesn't know about the `type` property.
+    obj.type === ElementType.Comment
+  );
+}

package/node_modules/cheerio/src/options.ts ADDED Viewed

@@ -0,0 +1,136 @@
+import type { DomHandlerOptions } from 'domhandler';
+import type { ParserOptions as HTMLParser2ParserOptions } from 'htmlparser2';
+import type { ParserOptions as Parse5ParserOptions } from 'parse5';
+import type { Htmlparser2TreeAdapterMap } from 'parse5-htmlparser2-tree-adapter';
+import type { Options as SelectOptions } from 'cheerio-select';
+import type { DomSerializerOptions } from 'dom-serializer';
+/**
+ * Options accepted by htmlparser2, the default parser for XML.
+ *
+ * @see https://github.com/fb55/htmlparser2/wiki/Parser-options
+ */
+export interface HTMLParser2Options
+  extends DomHandlerOptions, DomSerializerOptions, HTMLParser2ParserOptions {
+  /** Treat the input as an XML document. */
+  xmlMode?: boolean;
+}
+/**
+ * Options accepted by Cheerio.
+ *
+ * Please note that parser-specific options are _only recognized_ if the
+ * relevant parser is used.
+ */
+export interface CheerioOptions extends Parse5ParserOptions<Htmlparser2TreeAdapterMap> {
+  /**
+   * Recommended way of configuring htmlparser2 when wanting to parse XML.
+   *
+   * This will switch Cheerio to use htmlparser2.
+   *
+   * @default false
+   */
+  xml?: HTMLParser2Options | boolean;
+  /**
+   * Enable xml mode, which will switch Cheerio to use htmlparser2.
+   *
+   * @deprecated Please use the `xml` option instead.
+   * @default false
+   */
+  xmlMode?: boolean;
+  /** The base URI for the document. Used to resolve the `href` and `src` props. */
+  baseURI?: string | URL;
+  /**
+   * Is the document in quirks mode?
+   *
+   * This will lead to `.className` and `#id` being case-insensitive.
+   *
+   * @default false
+   */
+  quirksMode?: SelectOptions['quirksMode'];
+  /**
+   * Extension point for pseudo-classes.
+   *
+   * Maps from names to either strings of functions.
+   *
+   * - A string value is a selector that the element must match to be selected.
+   * - A function is called with the element as its first argument, and optional
+   *   parameters second. If it returns true, the element is selected.
+   *
+   * @example
+   *
+   * ```js
+   * const $ = cheerio.load(
+   *   '<div class="foo"></div><div data-bar="boo"></div>',
+   *   {
+   *     pseudos: {
+   *       // `:foo` is an alias for `div.foo`
+   *       foo: 'div.foo',
+   *       // `:bar(val)` is equivalent to `[data-bar=val s]`
+   *       bar: (el, val) => el.attribs['data-bar'] === val,
+   *     },
+   *   },
+   * );
+   *
+   * $(':foo').length; // 1
+   * $('div:bar(boo)').length; // 1
+   * $('div:bar(baz)').length; // 0
+   * ```
+   */
+  pseudos?: SelectOptions['pseudos'];
+}
+/** Internal options for Cheerio. */
+export interface InternalOptions
+  extends HTMLParser2Options, Omit<CheerioOptions, 'xml'> {
+  /**
+   * Whether to use htmlparser2.
+   *
+   * This is set to true if `xml` is set to true.
+   */
+  _useHtmlParser2?: boolean;
+}
+const defaultOpts: InternalOptions = {
+  _useHtmlParser2: false,
+};
+/**
+ * Flatten the options for Cheerio.
+ *
+ * This will set `_useHtmlParser2` to true if `xml` is set to true.
+ *
+ * @param options - The options to flatten.
+ * @param baseOptions - The base options to use.
+ * @returns The flattened options.
+ */
+export function flattenOptions(
+  options?: CheerioOptions | null,
+  baseOptions?: InternalOptions,
+): InternalOptions {
+  if (!options) {
+    return baseOptions ?? defaultOpts;
+  }
+  const opts: InternalOptions = {
+    _useHtmlParser2: !!options.xmlMode,
+    ...baseOptions,
+    ...options,
+  };
+  if (options.xml) {
+    opts._useHtmlParser2 = true;
+    opts.xmlMode = true;
+    if (options.xml !== true) {
+      Object.assign(opts, options.xml);
+    }
+  } else if (options.xmlMode) {
+    opts._useHtmlParser2 = true;
+  }
+  return opts;
+}

package/node_modules/cheerio/src/parse.ts ADDED Viewed

@@ -0,0 +1,105 @@
+import { removeElement } from 'domutils';
+import {
+  type AnyNode,
+  Document,
+  type ParentNode,
+  isDocument as checkIsDocument,
+} from 'domhandler';
+import type { InternalOptions } from './options.js';
+/**
+ * Get the parse function with options.
+ *
+ * @param parser - The parser function.
+ * @returns The parse function with options.
+ */
+export function getParse(
+  parser: (
+    content: string,
+    options: InternalOptions,
+    isDocument: boolean,
+    context: ParentNode | null,
+  ) => Document,
+) {
+  /**
+   * Parse a HTML string or a node.
+   *
+   * @param content - The HTML string or node.
+   * @param options - The parser options.
+   * @param isDocument - If `content` is a document.
+   * @param context - The context node in the DOM tree.
+   * @returns The parsed document node.
+   */
+  return function parse(
+    content: string | Document | AnyNode | AnyNode[] | Buffer,
+    options: InternalOptions,
+    isDocument: boolean,
+    context: ParentNode | null,
+  ): Document {
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(content)) {
+      content = content.toString();
+    }
+    if (typeof content === 'string') {
+      return parser(content, options, isDocument, context);
+    }
+    const doc = content as AnyNode | AnyNode[] | Document;
+    if (!Array.isArray(doc) && checkIsDocument(doc)) {
+      // If `doc` is already a root, just return it
+      return doc;
+    }
+    // Add content to new root element
+    const root = new Document([]);
+    // Update the DOM using the root
+    update(doc, root);
+    return root;
+  };
+}
+/**
+ * Update the dom structure, for one changed layer.
+ *
+ * @param newChilds - The new children.
+ * @param parent - The new parent.
+ * @returns The parent node.
+ */
+export function update(
+  newChilds: AnyNode[] | AnyNode,
+  parent: ParentNode | null,
+): ParentNode | null {
+  // Normalize
+  const arr = Array.isArray(newChilds) ? newChilds : [newChilds];
+  // Update parent
+  if (parent) {
+    parent.children = arr;
+  } else {
+    parent = null;
+  }
+  // Update neighbors
+  for (let i = 0; i < arr.length; i++) {
+    const node = arr[i];
+    // Cleanly remove existing nodes from their previous structures.
+    if (node.parent && node.parent.children !== arr) {
+      removeElement(node);
+    }
+    if (parent) {
+      node.prev = arr[i - 1] || null;
+      node.next = arr[i + 1] || null;
+    } else {
+      node.prev = node.next = null;
+    }
+    node.parent = parent;
+  }
+  return parent;
+}

package/node_modules/cheerio/src/parsers/parse5-adapter.ts ADDED Viewed

@@ -0,0 +1,66 @@
+import {
+  type AnyNode,
+  type Document,
+  type ParentNode,
+  isDocument,
+} from 'domhandler';
+import { parse as parseDocument, parseFragment, serializeOuter } from 'parse5';
+import { adapter as htmlparser2Adapter } from 'parse5-htmlparser2-tree-adapter';
+import type { InternalOptions } from '../options.js';
+/**
+ * Parse the content with `parse5` in the context of the given `ParentNode`.
+ *
+ * @param content - The content to parse.
+ * @param options - A set of options to use to parse.
+ * @param isDocument - Whether to parse the content as a full HTML document.
+ * @param context - The context in which to parse the content.
+ * @returns The parsed content.
+ */
+export function parseWithParse5(
+  content: string,
+  options: InternalOptions,
+  isDocument: boolean,
+  context: ParentNode | null,
+): Document {
+  options.treeAdapter ??= htmlparser2Adapter;
+  if (options.scriptingEnabled !== false) {
+    options.scriptingEnabled = true;
+  }
+  return isDocument
+    ? parseDocument(content, options)
+    : parseFragment(context, content, options);
+}
+const renderOpts = { treeAdapter: htmlparser2Adapter };
+/**
+ * Renders the given DOM tree with `parse5` and returns the result as a string.
+ *
+ * @param dom - The DOM tree to render.
+ * @returns The rendered document.
+ */
+export function renderWithParse5(dom: AnyNode | ArrayLike<AnyNode>): string {
+  /*
+   * `dom-serializer` passes over the special "root" node and renders the
+   * node's children in its place. To mimic this behavior with `parse5`, an
+   * equivalent operation must be applied to the input array.
+   */
+  const nodes = 'length' in dom ? dom : [dom];
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    if (isDocument(node)) {
+      Array.prototype.splice.call(nodes, index, 1, ...node.children);
+    }
+  }
+  let result = '';
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    result += serializeOuter(node, renderOpts);
+  }
+  return result;
+}

package/node_modules/cheerio/src/slim.ts ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * @file Alternative entry point for Cheerio that always uses htmlparser2. This
+ *   way, parse5 won't be loaded, saving some memory.
+ */
+import { type CheerioAPI, getLoad } from './load.js';
+import { type CheerioOptions } from './options.js';
+import { getParse } from './parse.js';
+import type { AnyNode } from 'domhandler';
+import render from 'dom-serializer';
+import { parseDocument } from 'htmlparser2';
+export { contains, merge } from './static.js';
+export type * from './types.js';
+export type { Cheerio } from './cheerio.js';
+export type { CheerioOptions, HTMLParser2Options } from './options.js';
+export type { CheerioAPI } from './load.js';
+/**
+ * Create a querying function, bound to a document created from the provided
+ * markup.
+ *
+ * @param content - Markup to be loaded.
+ * @param options - Options for the created instance.
+ * @param isDocument - Always `false` here, as we are always using
+ *   `htmlparser2`.
+ * @returns The loaded document.
+ * @see {@link https://cheerio.js.org#loading} for additional usage information.
+ */
+export const load: (
+  content: string | AnyNode | AnyNode[] | Buffer,
+  options?: CheerioOptions | null,
+  isDocument?: boolean,
+) => CheerioAPI = getLoad(getParse(parseDocument), render);