@milpa/comal 0.0.0-stage → 0.1.0

package/node_modules/cheerio/src/static.ts

@@ -0,0 +1,312 @@
+import type { BasicAcceptedElems } from './types.js';
+import type { CheerioAPI } from './load.js';
+import type { Cheerio } from './cheerio.js';
+import type { AnyNode, Document } from 'domhandler';
+import { textContent } from 'domutils';
+import {
+  type InternalOptions,
+  type CheerioOptions,
+  flattenOptions as flattenOptions,
+} from './options.js';
+import type { ExtractedMap, ExtractMap } from './api/extract.js';
+
+/**
+ * Helper function to render a DOM.
+ *
+ * @param that - Cheerio instance to render.
+ * @param dom - The DOM to render. Defaults to `that`'s root.
+ * @param options - Options for rendering.
+ * @returns The rendered document.
+ */
+function render(
+  that: CheerioAPI,
+  dom: BasicAcceptedElems<AnyNode> | undefined,
+  options: InternalOptions,
+): string {
+  if (!that) return '';
+
+  return that(dom ?? that._root.children, null, undefined, options).toString();
+}
+
+/**
+ * Checks if a passed object is an options object.
+ *
+ * @param dom - Object to check if it is an options object.
+ * @param options - Options object.
+ * @returns Whether the object is an options object.
+ */
+function isOptions(
+  dom?: BasicAcceptedElems<AnyNode> | CheerioOptions | null,
+  options?: CheerioOptions,
+): dom is CheerioOptions {
+  return (
+    !options &&
+    typeof dom === 'object' &&
+    dom != null &&
+    !('length' in dom) &&
+    !('type' in dom)
+  );
+}
+
+/**
+ * Renders the document.
+ *
+ * @category Static
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export function html(this: CheerioAPI, options?: CheerioOptions): string;
+/**
+ * Renders the document.
+ *
+ * @category Static
+ * @param dom - Element to render.
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export function html(
+  this: CheerioAPI,
+  dom?: BasicAcceptedElems<AnyNode>,
+  options?: CheerioOptions,
+): string;
+export function html(
+  this: CheerioAPI,
+  dom?: BasicAcceptedElems<AnyNode> | CheerioOptions,
+  options?: CheerioOptions,
+): string {
+  /*
+   * Be flexible about parameters, sometimes we call html(),
+   * with options as only parameter
+   * check dom argument for dom element specific properties
+   * assume there is no 'length' or 'type' properties in the options object
+   */
+  const toRender = isOptions(dom) ? ((options = dom), undefined) : dom;
+
+  /*
+   * Sometimes `$.html()` is used without preloading html,
+   * so fallback non-existing options to the default ones.
+   */
+  const opts = {
+    ...this?._options,
+    ...flattenOptions(options),
+  };
+
+  return render(this, toRender, opts);
+}
+
+/**
+ * Render the document as XML.
+ *
+ * @category Static
+ * @param dom - Element to render.
+ * @returns THe rendered document.
+ */
+export function xml(
+  this: CheerioAPI,
+  dom?: BasicAcceptedElems<AnyNode>,
+): string {
+  const options = { ...this._options, xmlMode: true };
+
+  return render(this, dom, options);
+}
+
+/**
+ * Render the document as text.
+ *
+ * This returns the `textContent` of the passed elements. The result will
+ * include the contents of `<script>` and `<style>` elements. To avoid this, use
+ * `.prop('innerText')` instead.
+ *
+ * @category Static
+ * @param elements - Elements to render.
+ * @returns The rendered document.
+ */
+export function text(
+  this: CheerioAPI | void,
+  elements?: ArrayLike<AnyNode>,
+): string {
+  const elems = elements ?? (this ? this.root() : []);
+
+  let ret = '';
+
+  for (let i = 0; i < elems.length; i++) {
+    ret += textContent(elems[i]);
+  }
+
+  return ret;
+}
+
+/**
+ * Parses a string into an array of DOM nodes. The `context` argument has no
+ * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
+ *
+ * @category Static
+ * @param data - Markup that will be parsed.
+ * @param context - Will be ignored. If it is a boolean it will be used as the
+ *   value of `keepScripts`.
+ * @param keepScripts - If false all scripts will be removed.
+ * @returns The parsed DOM.
+ * @alias Cheerio.parseHTML
+ * @see {@link https://api.jquery.com/jQuery.parseHTML/}
+ */
+export function parseHTML(
+  this: CheerioAPI,
+  data: string,
+  context?: unknown,
+  keepScripts?: boolean,
+): AnyNode[];
+export function parseHTML(this: CheerioAPI, data?: '' | null): null;
+export function parseHTML(
+  this: CheerioAPI,
+  data?: string | null,
+  context?: unknown,
+  keepScripts = typeof context === 'boolean' ? context : false,
+): AnyNode[] | null {
+  if (!data || typeof data !== 'string') {
+    return null;
+  }
+
+  if (typeof context === 'boolean') {
+    keepScripts = context;
+  }
+
+  const parsed = this.load(data, this._options, false);
+  if (!keepScripts) {
+    parsed('script').remove();
+  }
+
+  /*
+   * The `children` array is used by Cheerio internally to group elements that
+   * share the same parents. When nodes created through `parseHTML` are
+   * inserted into previously-existing DOM structures, they will be removed
+   * from the `children` array. The results of `parseHTML` should remain
+   * constant across these operations, so a shallow copy should be returned.
+   */
+  return [...parsed.root()[0].children];
+}
+
+/**
+ * Sometimes you need to work with the top-level root element. To query it, you
+ * can use `$.root()`.
+ *
+ * @category Static
+ * @example
+ *
+ * ```js
+ * $.root().append('<ul id="vegetables"></ul>').html();
+ * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+ * ```
+ *
+ * @returns Cheerio instance wrapping the root node.
+ * @alias Cheerio.root
+ */
+export function root(this: CheerioAPI): Cheerio<Document> {
+  return this(this._root);
+}
+
+/**
+ * Checks to see if the `contained` DOM element is a descendant of the
+ * `container` DOM element.
+ *
+ * @category Static
+ * @param container - Potential parent node.
+ * @param contained - Potential child node.
+ * @returns Indicates if the nodes contain one another.
+ * @alias Cheerio.contains
+ * @see {@link https://api.jquery.com/jQuery.contains/}
+ */
+export function contains(container: AnyNode, contained: AnyNode): boolean {
+  // According to the jQuery API, an element does not "contain" itself
+  if (contained === container) {
+    return false;
+  }
+
+  /*
+   * Step up the descendants, stopping when the root element is reached
+   * (signaled by `.parent` returning a reference to the same object)
+   */
+  let next: AnyNode | null = contained;
+  while (next && next !== next.parent) {
+    next = next.parent;
+    if (next === container) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Extract multiple values from a document, and store them in an object.
+ *
+ * @category Static
+ * @param map - An object containing key-value pairs. The keys are the names of
+ *   the properties to be created on the object, and the values are the
+ *   selectors to be used to extract the values.
+ * @returns An object containing the extracted values.
+ */
+export function extract<M extends ExtractMap>(
+  this: CheerioAPI,
+  map: M,
+): ExtractedMap<M> {
+  return this.root().extract(map);
+}
+
+type Writable<T> = { -readonly [P in keyof T]: T[P] };
+
+/**
+ * $.merge().
+ *
+ * @category Static
+ * @param arr1 - First array.
+ * @param arr2 - Second array.
+ * @returns `arr1`, with elements of `arr2` inserted.
+ * @alias Cheerio.merge
+ * @see {@link https://api.jquery.com/jQuery.merge/}
+ */
+export function merge<T>(
+  arr1: Writable<ArrayLike<T>>,
+  arr2: ArrayLike<T>,
+): ArrayLike<T> | undefined {
+  if (!isArrayLike(arr1) || !isArrayLike(arr2)) {
+    return;
+  }
+  let newLength = arr1.length;
+  const len = +arr2.length;
+
+  for (let i = 0; i < len; i++) {
+    arr1[newLength++] = arr2[i];
+  }
+  arr1.length = newLength;
+  return arr1;
+}
+
+/**
+ * Checks if an object is array-like.
+ *
+ * @category Static
+ * @param item - Item to check.
+ * @returns Indicates if the item is array-like.
+ */
+function isArrayLike(item: unknown): item is ArrayLike<unknown> {
+  if (Array.isArray(item)) {
+    return true;
+  }
+
+  if (
+    typeof item !== 'object' ||
+    item === null ||
+    !('length' in item) ||
+    typeof item.length !== 'number' ||
+    item.length < 0
+  ) {
+    return false;
+  }
+
+  for (let i = 0; i < item.length; i++) {
+    if (!(i in item)) {
+      return false;
+    }
+  }
+  return true;
+}

package/node_modules/cheerio/src/types.ts

@@ -0,0 +1,58 @@
+/** @file Types used in signatures of Cheerio methods. */
+
+type LowercaseLetters =
+  | 'a'
+  | 'b'
+  | 'c'
+  | 'd'
+  | 'e'
+  | 'f'
+  | 'g'
+  | 'h'
+  | 'i'
+  | 'j'
+  | 'k'
+  | 'l'
+  | 'm'
+  | 'n'
+  | 'o'
+  | 'p'
+  | 'q'
+  | 'r'
+  | 's'
+  | 't'
+  | 'u'
+  | 'v'
+  | 'w'
+  | 'x'
+  | 'y'
+  | 'z';
+
+type AlphaNumeric =
+  | LowercaseLetters
+  | Uppercase<LowercaseLetters>
+  | `${number}`;
+
+type SelectorSpecial = '.' | '#' | ':' | '|' | '>' | '+' | '~' | '[';
+/**
+ * Type for identifying selectors. Allows us to "upgrade" queries using
+ * selectors to return `Element`s.
+ */
+export type SelectorType =
+  | `${SelectorSpecial}${AlphaNumeric}${string}`
+  | `${AlphaNumeric}${string}`;
+
+import type { Cheerio } from './cheerio.js';
+import type { AnyNode } from 'domhandler';
+
+/** Elements that can be passed to manipulation methods. */
+export type BasicAcceptedElems<T extends AnyNode> = ArrayLike<T> | T | string;
+/** Elements that can be passed to manipulation methods, including functions. */
+export type AcceptedElems<T extends AnyNode> =
+  | BasicAcceptedElems<T>
+  | ((this: T, i: number, el: T) => BasicAcceptedElems<T>);
+
+/** Function signature, for traversal methods. */
+export type FilterFunction<T> = (this: T, i: number, el: T) => boolean;
+/** Supported filter types, for traversal methods. */
+export type AcceptedFilters<T> = string | FilterFunction<T> | T | Cheerio<T>;

package/node_modules/cheerio/src/utils.ts

@@ -0,0 +1,99 @@
+import type { AnyNode } from 'domhandler';
+import type { Cheerio } from './cheerio.js';
+
+/**
+ * Checks if an object is a Cheerio instance.
+ *
+ * @category Utils
+ * @param maybeCheerio - The object to check.
+ * @returns Whether the object is a Cheerio instance.
+ */
+export function isCheerio<T>(
+  maybeCheerio: unknown,
+): maybeCheerio is Cheerio<T> {
+  return (maybeCheerio as Cheerio<T>).cheerio != null;
+}
+
+/**
+ * Convert a string to camel case notation.
+ *
+ * @private
+ * @category Utils
+ * @param str - The string to be converted.
+ * @returns String in camel case notation.
+ */
+export function camelCase(str: string): string {
+  return str.replace(/[._-](\w|$)/g, (_, x) => (x as string).toUpperCase());
+}
+
+/**
+ * Convert a string from camel case to "CSS case", where word boundaries are
+ * described by hyphens ("-") and all characters are lower-case.
+ *
+ * @private
+ * @category Utils
+ * @param str - The string to be converted.
+ * @returns String in "CSS case".
+ */
+export function cssCase(str: string): string {
+  return str.replace(/[A-Z]/g, '-$&').toLowerCase();
+}
+
+/**
+ * Iterate over each DOM element without creating intermediary Cheerio
+ * instances.
+ *
+ * This is indented for use internally to avoid otherwise unnecessary memory
+ * pressure introduced by _make.
+ *
+ * @category Utils
+ * @param array - The array to iterate over.
+ * @param fn - Function to call.
+ * @returns The original instance.
+ */
+export function domEach<
+  T extends AnyNode,
+  Arr extends ArrayLike<T> = Cheerio<T>,
+>(array: Arr, fn: (elem: T, index: number) => void): Arr {
+  const len = array.length;
+  for (let i = 0; i < len; i++) fn(array[i], i);
+  return array;
+}
+
+const enum CharacterCode {
+  LowerA = 97,
+  LowerZ = 122,
+  UpperA = 65,
+  UpperZ = 90,
+  Exclamation = 33,
+}
+
+/**
+ * Check if string is HTML.
+ *
+ * Tests for a `<` within a string, immediate followed by a letter and
+ * eventually followed by a `>`.
+ *
+ * @private
+ * @category Utils
+ * @param str - The string to check.
+ * @returns Indicates if `str` is HTML.
+ */
+export function isHtml(str: string): boolean {
+  if (typeof str !== 'string') {
+    return false;
+  }
+
+  const tagStart = str.indexOf('<');
+
+  if (tagStart === -1 || tagStart > str.length - 3) return false;
+
+  const tagChar = str.charCodeAt(tagStart + 1) as CharacterCode;
+
+  return (
+    ((tagChar >= CharacterCode.LowerA && tagChar <= CharacterCode.LowerZ) ||
+      (tagChar >= CharacterCode.UpperA && tagChar <= CharacterCode.UpperZ) ||
+      tagChar === CharacterCode.Exclamation) &&
+    str.includes('>', tagStart + 2)
+  );
+}

package/node_modules/cheerio-select/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/cheerio-select/README.md

@@ -0,0 +1,18 @@
+# cheerio-select [![NPM version](http://img.shields.io/npm/v/cheerio-select.svg)](https://npmjs.org/package/cheerio-select) [![Build Status](https://travis-ci.org/cheeriojs/cheerio-select.svg?branch=master)](http://travis-ci.org/cheeriojs/cheerio-select) [![Downloads](https://img.shields.io/npm/dm/cheerio-select.svg)](https://npmjs.org/package/cheerio-select) [![Coverage](https://coveralls.io/repos/cheeriojs/cheerio-select/badge.svg?branch=master)](https://coveralls.io/r/cheeriojs/cheerio-select)
+
+CSS selector engine supporting jQuery selectors, based on [`css-select`](https://github.com/fb55/css-select).
+
+Supports all jQuery positional pseudo-selectors:
+
+-   `:first`
+-   `:last`
+-   `:eq`
+-   `:nth`
+-   `:gt`
+-   `:lt`
+-   `:even`
+-   `:odd`
+-   `:not(:positional)`, where `:positional` is any of the above.
+
+This library is a thin wrapper around [`css-select`](https://github.com/fb55/css-select).
+Only use this module if you will actually use jQuery positional selectors.

package/node_modules/cheerio-select/lib/esm/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { AnyNode } from "domhandler";
+import type { Selector } from "css-what";
+export declare function getDocumentRoot(node: AnyNode): AnyNode;
+export declare function groupSelectors(selectors: Selector[][]): [plain: Selector[][], filtered: Selector[][]];
+//# sourceMappingURL=helpers.d.ts.map

package/node_modules/cheerio-select/lib/esm/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"https://raw.githubusercontent.com/cheeriojs/cheerio-select/ef063a6ca4c3f0d02d2fc3505e750b6fb81c448d/src/","sources":["helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGzC,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAGtD;AAED,wBAAgB,cAAc,CAC1B,SAAS,EAAE,QAAQ,EAAE,EAAE,GACxB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC,CAa/C"}

package/node_modules/cheerio-select/lib/esm/helpers.js

@@ -0,0 +1,20 @@
+import { isFilter } from "./positionals.js";
+export function getDocumentRoot(node) {
+    while (node.parent)
+        node = node.parent;
+    return node;
+}
+export function groupSelectors(selectors) {
+    const filteredSelectors = [];
+    const plainSelectors = [];
+    for (const selector of selectors) {
+        if (selector.some(isFilter)) {
+            filteredSelectors.push(selector);
+        }
+        else {
+            plainSelectors.push(selector);
+        }
+    }
+    return [plainSelectors, filteredSelectors];
+}
+//# sourceMappingURL=helpers.js.map

package/node_modules/cheerio-select/lib/esm/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"https://raw.githubusercontent.com/cheeriojs/cheerio-select/ef063a6ca4c3f0d02d2fc3505e750b6fb81c448d/src/","sources":["helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,MAAM,UAAU,eAAe,CAAC,IAAa;IACzC,OAAO,IAAI,CAAC,MAAM;QAAE,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;IACvC,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,SAAuB;IAEvB,MAAM,iBAAiB,GAAiB,EAAE,CAAC;IAC3C,MAAM,cAAc,GAAiB,EAAE,CAAC;IAExC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;QAC9B,IAAI,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACzB,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACpC;aAAM;YACH,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACjC;KACJ;IAED,OAAO,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;AAC/C,CAAC"}

package/node_modules/cheerio-select/lib/esm/index.d.ts

@@ -0,0 +1,12 @@
+import { type Options as CSSSelectOptions } from "css-select";
+import type { Element, AnyNode, Document } from "domhandler";
+export { filters, pseudos, aliases } from "css-select";
+export interface Options extends CSSSelectOptions<AnyNode, Element> {
+    /** Optional reference to the root of the document. If not set, this will be computed when needed. */
+    root?: Document;
+}
+export declare function is(element: Element, selector: string | ((el: Element) => boolean), options?: Options): boolean;
+export declare function some(elements: Element[], selector: string | ((el: Element) => boolean), options?: Options): boolean;
+export declare function filter(selector: string, elements: AnyNode[], options?: Options): Element[];
+export declare function select(selector: string | ((el: Element) => boolean), root: AnyNode | AnyNode[], options?: Options, limit?: number): Element[];
+//# sourceMappingURL=index.d.ts.map

package/node_modules/cheerio-select/lib/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"https://raw.githubusercontent.com/cheeriojs/cheerio-select/ef063a6ca4c3f0d02d2fc3505e750b6fb81c448d/src/","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,OAAO,IAAI,gBAAgB,EAEnC,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAU7D,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAYvD,MAAM,WAAW,OAAQ,SAAQ,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC;IAC/D,qGAAqG;IACrG,IAAI,CAAC,EAAE,QAAQ,CAAC;CACnB;AAED,wBAAgB,EAAE,CACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAET;AAED,wBAAgB,IAAI,CAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAWT;AAsCD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,OAAY,GACtB,OAAO,EAAE,CAEX;AAoGD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,IAAI,EAAE,OAAO,GAAG,OAAO,EAAE,EACzB,OAAO,GAAE,OAAY,EACrB,KAAK,SAAW,GACjB,OAAO,EAAE,CA2BX"}