@node-core/utils 7.2.1 → 7.2.3

package/node_modules/cheerio/src/load.ts

@@ -1,282 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,33 +0,0 @@
-/**
- * @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);