@rse/ase 0.0.30 → 0.0.32

package/plugin/node_modules/katex/src/wide-character.ts

@@ -0,0 +1,155 @@
+/**
+ * This file provides support for Unicode range U+1D400 to U+1D7FF,
+ * Mathematical Alphanumeric Symbols.
+ *
+ * Function wideCharacterFont takes a wide character as input and returns
+ * the font information necessary to render it properly.
+ */
+
+import ParseError from "./ParseError";
+import type {FontName} from "./types/fonts";
+
+type WideChar = {
+    readonly mathClass: string;
+    readonly textClass: string;
+    readonly font: Extract<FontName,
+        | "Main-Bold"
+        | "Math-Italic"
+        | "Main-BoldItalic"
+        | "Script-Regular"
+        | "Fraktur-Regular"
+        | "AMS-Regular"
+        | "SansSerif-Regular"
+        | "SansSerif-Bold"
+        | "SansSerif-Italic"
+        | "Typewriter-Regular"
+    > | "";
+};
+
+const boldUpright: WideChar = {
+    mathClass: "mathbf",
+    textClass: "textbf",
+    font: "Main-Bold",
+};
+const italic: WideChar = {
+    mathClass: "mathnormal",
+    textClass: "textit",
+    font: "Math-Italic",
+};
+const boldItalic: WideChar = {
+    mathClass: "boldsymbol",
+    textClass: "boldsymbol",
+    font: "Main-BoldItalic",
+};
+const script: WideChar = {
+    mathClass: "mathscr",
+    textClass: "textscr",
+    font: "Script-Regular",
+};
+const noFont: WideChar = {mathClass: "", textClass: "", font: ""};
+const fraktur: WideChar = {
+    mathClass: "mathfrak",
+    textClass: "textfrak",
+    font: "Fraktur-Regular",
+};
+const doubleStruck: WideChar = {
+    mathClass: "mathbb",
+    textClass: "textbb",
+    font: "AMS-Regular",
+};
+const boldFraktur: WideChar = {
+    mathClass: "mathboldfrak",
+    textClass: "textboldfrak",
+    font: "Fraktur-Regular",
+};
+const sansSerif: WideChar = {
+    mathClass: "mathsf",
+    textClass: "textsf",
+    font: "SansSerif-Regular",
+};
+const boldSansSerif: WideChar = {
+    mathClass: "mathboldsf",
+    textClass: "textboldsf",
+    font: "SansSerif-Bold",
+};
+const italicSansSerif: WideChar = {
+    mathClass: "mathitsf",
+    textClass: "textitsf",
+    font: "SansSerif-Italic",
+};
+const monospace: WideChar = {
+    mathClass: "mathtt",
+    textClass: "texttt",
+    font: "Typewriter-Regular",
+};
+
+/**
+ * Data below is from https://www.unicode.org/charts/PDF/U1D400.pdf
+ * That document sorts characters into groups by font type, say bold or italic.
+ *
+ * In the arrays below, each object consists of three properties:
+ *      * The CSS class of that group when in math mode.
+ *      * The CSS class of that group when in text mode.
+ *      * The font name, so that KaTeX can get font metrics.
+ */
+
+const wideLatinLetterData = [
+    boldUpright, boldUpright,  // A-Z, a-z
+    italic, italic,            // A-Z, a-z
+    boldItalic, boldItalic,   // A-Z, a-z
+    // Map fancy A-Z letters to script, not calligraphic.
+    // This aligns with unicode-math and math fonts (except Cambria Math).
+    script, noFont, // A-Z script, a-z — no font
+    noFont, noFont, // A-Z bold script, a-z bold script — no font
+    fraktur, fraktur,          // A-Z, a-z
+    doubleStruck, doubleStruck, // A-Z double-struck, k double-struck
+    // Note that we are using a bold font, but font metrics for regular Fraktur.
+    boldFraktur, boldFraktur,  // A-Z, a-z
+    sansSerif, sansSerif,      // A-Z, a-z
+    boldSansSerif, boldSansSerif, // A-Z, a-z
+    italicSansSerif, italicSansSerif, // A-Z, a-z
+    noFont, noFont,           // A-Z bold italic sans, a-z bold italic sans - no font
+    monospace, monospace,     // A-Z, a-z
+] as const;
+
+const wideNumeralData = [
+    boldUpright,      // 0-9
+    noFont,           // 0-9 double-struck. No KaTeX font.
+    sansSerif,        // 0-9
+    boldSansSerif,   // 0-9
+    monospace,       // 0-9
+] as const;
+
+export const wideCharacterFont = (
+    wideChar: string,
+): WideChar => {
+
+    // IE doesn't support codePointAt(). So work with the surrogate pair.
+    const H = wideChar.charCodeAt(0);    // high surrogate
+    const L = wideChar.charCodeAt(1);    // low surrogate
+    const codePoint = ((H - 0xD800) * 0x400) + (L - 0xDC00) + 0x10000;
+
+    if (0x1D400 <= codePoint && codePoint < 0x1D6A4) {
+        // wideLatinLetterData contains exactly 26 chars on each row.
+        // So we can calculate the relevant row. No traverse necessary.
+        const i = Math.floor((codePoint - 0x1D400) / 26);
+        return wideLatinLetterData[i];
+
+    } else if (0x1D7CE <= codePoint && codePoint <= 0x1D7FF) {
+        // Numerals, ten per row.
+        const i = Math.floor((codePoint - 0x1D7CE) / 10);
+        return wideNumeralData[i];
+
+    } else if (codePoint === 0x1D6A5 || codePoint === 0x1D6A6) {
+        // dotless i or j
+        return wideLatinLetterData[0];
+
+    } else if (0x1D6A6 < codePoint && codePoint < 0x1D7CE) {
+        // Greek letters. Not supported, yet.
+        return noFont;
+
+    } else {
+        // We don't support any wide characters outside 1D400–1D7FF.
+        throw new ParseError("Unsupported character: " + wideChar);
+    }
+};

package/plugin/node_modules/katex/types/katex.d.ts

@@ -0,0 +1,259 @@
+// Adapted from
+// - https://katex.org/docs/options
+// - https://katex.org/docs/api
+// - https://katex.org/docs/error
+// for v0.16.11 on 2024/12/01
+// with some references from https://www.npmjs.com/package/@types/katex
+
+/**
+ * For the `trust` option in `KatexOptions`, a custom function
+ * `handler(context)` can be provided to customize behavior depending on the
+ * context (command, arguments e.g. a URL, etc.)
+ * @see https://katex.org/docs/options
+ */
+export type TrustContext =
+    | { command: "\\url", url: string, protocol?: string }
+    | { command: "\\href", url: string, protocol?: string }
+    | { command: "\\includegraphics", url: string, protocol?: string }
+    | { command: "\\htmlClass", class: string }
+    | { command: "\\htmlId", id: string }
+    | { command: "\\htmlStyle", style: string }
+    | { command: "\\htmlData", attributes: Record<string, string> }
+
+
+export type Catcodes = Record<string, number>;
+
+export interface Lexer {
+  input: string;
+  tokenRegex: RegExp;
+  settings: Required<KatexOptions>;
+  catcodes: Catcodes;
+}
+
+export interface SourceLocation {
+  start: number;
+  end: number;
+  lexer: Lexer;
+}
+
+export interface Token {
+  text: string;
+  loc: SourceLocation | undefined;
+  noexpand?: boolean;
+  treatAsRelax?: boolean;
+}
+
+
+export type StrictFunction = (
+  errorCode:
+    | "unknownSymbol"
+    | "unicodeTextInMathMode"
+    | "mathVsTextUnits"
+    | "commentAtEnd"
+    | "htmlExtension"
+    | "newLineInDisplayMode",
+  errorMsg: string,
+  token: Token,
+) => boolean | "error" | "warn" | "ignore" | undefined;
+
+
+/**
+ * Options for `katex.render` and `katex.renderToString`.
+ * @see https://katex.org/docs/options
+ */
+export interface KatexOptions {
+    /**
+     * If `true` the math will be rendered in display mode.
+     * If `false` the math will be rendered in inline mode.
+     * @see https://katex.org/docs/options
+     *
+     * @default false
+     */
+    displayMode?: boolean;
+    /**
+     * Determines the markup language of the output. The valid choices are:
+     * - `html`: Outputs KaTeX in HTML only.
+     * - `mathml`: Outputs KaTeX in MathML only.
+     * - `htmlAndMathml`: Outputs HTML for visual rendering and includes MathML
+     * for accessibility.
+     *
+     * @default "htmlAndMathml"
+     */
+    output?: "html" | "mathml" | "htmlAndMathml";
+    /**
+     * If `true`, display math has `\tag`s rendered on the left instead of the
+     * right, like `\usepackage[leqno]{amsmath}` in LaTeX.
+     *
+     * @default false
+     */
+    leqno?: boolean;
+    /**
+     * If `true`, display math renders flush left with a `2em` left margin,
+     * like `\documentclass[fleqn]` in LaTeX with the `amsmath` package.
+     *
+     * @default false
+     */
+    fleqn?: boolean;
+    /**
+     * If `true`, KaTeX will throw a `ParseError` when it encounters an
+     * unsupported command or invalid LaTeX.
+     * If `false`, KaTeX will render unsupported commands as text, and render
+     * invalid LaTeX as its source code with hover text giving the error, in
+     * the color given by `errorColor`.
+     *
+     * @default true
+     */
+    throwOnError?: boolean;
+    /**
+     * A color string given in the format `"#XXX"` or `"#XXXXXX"`. This option
+     * determines the color that unsupported commands and invalid LaTeX are
+     * rendered in when `throwOnError` is set to `false`.
+     *
+     * @default "#cc0000"
+     */
+    errorColor?: string;
+    /**
+     * A collection of custom macros.
+     * @see https://katex.org/docs/options
+     */
+    macros?: Record<string, string | object | ((macroExpander:object)
+        => string | object)>;
+    /**
+     * Specifies a minimum thickness, in ems, for fraction lines, `\sqrt` top
+     * lines, `{array}` vertical lines, `\hline`, `\hdashline`, `\underline`,
+     * `\overline`, and the borders of `\fbox`, `\boxed`, and `\fcolorbox`.
+     * The usual value for these items is `0.04`, so for `minRuleThickness`
+     * to be effective it should probably take a value slightly above `0.04`,
+     * say `0.05` or `0.06`. Negative values will be ignored.
+     */
+    minRuleThickness?: number;
+    /**
+     * In early versions of both KaTeX (<0.8.0) and MathJax, the `\color`
+     * function expected the content to be a function argument, as in
+     * `\color{blue}{hello}`. In current KaTeX, `\color` is a switch, as in
+     * `\color{blue}` hello. This matches LaTeX behavior. If you want the old
+     * `\color` behavior, set option colorIsTextColor to true.
+     */
+    colorIsTextColor?: boolean;
+    /**
+     * All user-specified sizes, e.g. in `\rule{500em}{500em}`, will be capped
+     * to `maxSize` ems. If set to `Infinity` (the default), users can make
+     * elements and spaces arbitrarily large.
+     *
+     * @default Infinity
+     */
+    maxSize?: number;
+    /**
+     * Limit the number of macro expansions to the specified number, to prevent
+     * e.g. infinite macro loops. `\edef` expansion counts all expanded tokens.
+     * If set to `Infinity`, the macro expander will try to fully expand as in
+     * LaTeX.
+     *
+     * @default 1000
+     */
+    maxExpand?: number;
+    /**
+     * If `false` or `"ignore"`, allow features that make writing LaTeX
+     * convenient but are not actually supported by (Xe)LaTeX
+     * (similar to MathJax).
+     * If `true` or `"error"` (LaTeX faithfulness mode), throw an error for any
+     * such transgressions.
+     * If `"warn"` (the default), warn about such behavior via `console.warn`.
+     * Provide a custom function `handler(errorCode, errorMsg, token)` to
+     * customize behavior depending on the type of transgression (summarized by
+     * the string code `errorCode` and detailed in `errorMsg`); this function
+     * can also return `"ignore"`, `"error"`, or `"warn"` to use a built-in
+     * behavior.
+     * @see https://katex.org/docs/options
+     *
+     * @default "warn"
+     */
+    strict?:
+        | boolean
+        | "ignore" | "warn" | "error"
+        | StrictFunction;
+    /**
+     * If `false` (do not trust input), prevent any commands like
+     * `\includegraphics` that could enable adverse behavior, rendering them
+     * instead in `errorColor`.
+     * If `true` (trust input), allow all such commands.
+     * Provide a custom function `handler(context)` to customize behavior
+     * depending on the context (command, arguments e.g. a URL, etc.).
+     * @see https://katex.org/docs/options
+     *
+     * @default false
+    */
+    trust?: boolean | ((context: TrustContext) => boolean);
+    /**
+     * Run KaTeX code in the global group. As a consequence, macros defined at
+     * the top level by `\def` and `\newcommand` are added to the macros
+     * argument and can be used in subsequent render calls. In LaTeX,
+     * constructs such as `\begin{equation}` and `$$` create a local group and
+     * prevent definitions other than `\gdef` from becoming visible outside of
+     * those blocks, so this is KaTeX's default behavior.
+     *
+     * @default false
+     */
+    globalGroup?: boolean;
+}
+
+/**
+ * In-browser rendering
+ *
+ * Call the `render` function with a TeX expression and a DOM element to
+ * render into.
+ *
+ * @param {string} tex A TeX expression.
+ * @param {HTMLElement} element A HTML DOM element.
+ * @param {KatexOptions} options An options object.
+ * @returns {void}
+ * @see https://katex.org/docs/api
+ */
+export function render(
+    tex: string,
+    element: HTMLElement,
+    options?: KatexOptions,
+): void;
+
+/**
+ * Server-side rendering or rendering to a string
+ *
+ * Use the `renderToString` function to generate HTML on the server or to
+ * generate an HTML string of the rendered math.
+ *
+ * @param {string} tex A TeX expression.
+ * @param {KatexOptions} options An options object.
+ * @returns {string} The HTML string of the rendered math.
+ * @see https://katex.org/docs/api
+ */
+export function renderToString(tex: string, options?: KatexOptions): string;
+
+/**
+ * If KaTeX encounters an error (invalid or unsupported LaTeX) and
+ * `throwOnError` hasn't been set to `false`, then `katex.render` and
+ * `katex.renderToString` will throw an exception of type
+ * `ParseError`. The message in this error includes some of the LaTeX source
+ * code, so needs to be escaped if you want to render it to HTML.
+ * @see https://katex.org/docs/error
+ */
+export class ParseError implements Error {
+    constructor(message: string, token?: object);
+    name: "ParseError";
+    position: number;
+    length: number;
+    rawMessage: string;
+    message: string;
+}
+
+export const version: string;
+
+export as namespace katex;
+
+declare const katex: {
+    version: string;
+    render: typeof render;
+    renderToString: typeof renderToString;
+    ParseError: typeof ParseError;
+};
+
+export default katex;

package/plugin/node_modules/linkify-it/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Vitaly Puzrin.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/plugin/node_modules/linkify-it/README.md

@@ -0,0 +1,196 @@
+linkify-it
+==========
+
+[![CI](https://github.com/markdown-it/linkify-it/actions/workflows/ci.yml/badge.svg)](https://github.com/markdown-it/linkify-it/actions/workflows/ci.yml)
+[![NPM version](https://img.shields.io/npm/v/linkify-it.svg?style=flat)](https://www.npmjs.org/package/linkify-it)
+[![Coverage Status](https://img.shields.io/coveralls/markdown-it/linkify-it/master.svg?style=flat)](https://coveralls.io/r/markdown-it/linkify-it?branch=master)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/markdown-it/linkify-it)
+
+> Links recognition library with FULL unicode support.
+> Focused on high quality link patterns detection in plain text.
+
+__[Demo](http://markdown-it.github.io/linkify-it/)__
+
+Why it's awesome:
+
+- Full unicode support, _with astral characters_!
+- International domains support.
+- Allows rules extension & custom normalizers.
+
+
+Install
+-------
+
+```bash
+npm install linkify-it --save
+```
+
+Browserification is also supported.
+
+
+Usage examples
+--------------
+
+##### Example 1
+
+```js
+import linkifyit from 'linkify-it';
+const linkify = linkifyit();
+
+// Reload full tlds list & add unofficial `.onion` domain.
+linkify
+  .tlds(require('tlds'))          // Reload with full tlds list
+  .tlds('onion', true)            // Add unofficial `.onion` domain
+  .add('git:', 'http:')           // Add `git:` protocol as "alias"
+  .add('ftp:', null)              // Disable `ftp:` protocol
+  .set({ fuzzyIP: true });        // Enable IPs in fuzzy links (without schema)
+
+console.log(linkify.test('Site github.com!'));  // true
+
+console.log(linkify.match('Site github.com!')); // [ {
+                                                //   schema: "",
+                                                //   index: 5,
+                                                //   lastIndex: 15,
+                                                //   raw: "github.com",
+                                                //   text: "github.com",
+                                                //   url: "http://github.com",
+                                                // } ]
+```
+
+##### Example 2. Add twitter mentions handler
+
+```js
+linkify.add('@', {
+  validate: function (text, pos, self) {
+    const tail = text.slice(pos);
+
+    if (!self.re.twitter) {
+      self.re.twitter =  new RegExp(
+        '^([a-zA-Z0-9_]){1,15}(?!_)(?=$|' + self.re.src_ZPCc + ')'
+      );
+    }
+    if (self.re.twitter.test(tail)) {
+      // Linkifier allows punctuation chars before prefix,
+      // but we additionally disable `@` ("@@mention" is invalid)
+      if (pos >= 2 && tail[pos - 2] === '@') {
+        return false;
+      }
+      return tail.match(self.re.twitter)[0].length;
+    }
+    return 0;
+  },
+  normalize: function (match) {
+    match.url = 'https://twitter.com/' + match.url.replace(/^@/, '');
+  }
+});
+```
+
+
+API
+---
+
+__[API documentation](http://markdown-it.github.io/linkify-it/doc)__
+
+### new LinkifyIt(schemas, options)
+
+Creates new linkifier instance with optional additional schemas.
+Can be called without `new` keyword for convenience.
+
+By default understands:
+
+- `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links
+- "fuzzy" links and emails (google.com, foo@bar.com).
+
+`schemas` is an object, where each key/value describes protocol/rule:
+
+- __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`
+  for example). `linkify-it` makes sure that prefix is not preceded with
+  alphanumeric char.
+- __value__ - rule to check tail after link prefix
+  - _String_ - just alias to existing rule
+  - _Object_
+    - _validate_ - either a `RegExp` (start with `^`, and don't include the
+      link prefix itself), or a validator function which, given arguments
+      _text_, _pos_, and _self_, returns the length of a match in _text_
+      starting at index _pos_.  _pos_ is the index right after the link prefix.
+      _self_ can be used to access the linkify object to cache data.
+    - _normalize_ - optional function to normalize text & url of matched result
+      (for example, for twitter mentions).
+
+`options`:
+
+- __fuzzyLink__ - recognize URL-s without `http(s)://` head. Default `true`.
+- __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts
+  like version numbers. Default `false`.
+- __fuzzyEmail__ - recognize emails without `mailto:` prefix. Default `true`.
+- __---__ - set `true` to terminate link with `---` (if it's considered as long dash).
+
+
+### .test(text)
+
+Searches linkifiable pattern and returns `true` on success or `false` on fail.
+
+
+### .pretest(text)
+
+Quick check if link MAY BE can exist. Can be used to optimize more expensive
+`.test()` calls. Return `false` if link can not be found, `true` - if `.test()`
+call needed to know exactly.
+
+
+### .testSchemaAt(text, name, offset)
+
+Similar to `.test()` but checks only specific protocol tail exactly at given
+position. Returns length of found pattern (0 on fail).
+
+
+### .match(text)
+
+Returns `Array` of found link matches or null if nothing found.
+
+Each match has:
+
+- __schema__ - link schema, can be empty for fuzzy links, or `//` for
+  protocol-neutral  links.
+- __index__ - offset of matched text
+- __lastIndex__ - index of next char after mathch end
+- __raw__ - matched text
+- __text__ - normalized text
+- __url__ - link, generated from matched text
+
+
+### .matchAtStart(text)
+
+Checks if a match exists at the start of the string. Returns `Match`
+(see docs for `match(text)`) or null if no URL is at the start.
+Doesn't work with fuzzy links.
+
+
+### .tlds(list[, keepOld])
+
+Load (or merge) new tlds list. Those are needed for fuzzy links (without schema)
+to avoid false positives. By default:
+
+- 2-letter root zones are ok.
+- biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф are ok.
+- encoded (`xn--...`) root zones are ok.
+
+If that's not enough, you can reload defaults with more detailed zones list.
+
+### .add(key, value)
+
+Add a new schema to the schemas object.  As described in the constructor
+definition, `key` is a link prefix (`skype:`, for example), and `value`
+is a String to alias to another schema, or an Object with `validate` and
+optionally `normalize` definitions.  To disable an existing rule, use
+`.add(key, null)`.
+
+
+### .set(options)
+
+Override default options. Missed properties will not be changed.
+
+
+## License
+
+[MIT](https://github.com/markdown-it/linkify-it/blob/master/LICENSE)