npm - @rse/ase - Versions diffs - 0.0.42 → 0.0.44 - Mend

@rse/ase 0.0.42 → 0.0.44

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 (1554) hide show

package/plugin/node_modules/micromark-util-sanitize-uri/readme.md DELETED Viewed

@@ -1,214 +0,0 @@
-# micromark-util-sanitize-uri
-[![Build][build-badge]][build]
-[![Coverage][coverage-badge]][coverage]
-[![Downloads][downloads-badge]][downloads]
-[![Size][bundle-size-badge]][bundle-size]
-[![Sponsors][sponsors-badge]][opencollective]
-[![Backers][backers-badge]][opencollective]
-[![Chat][chat-badge]][chat]
-[micromark][] utility to sanitize urls.
-## Contents
-* [What is this?](#what-is-this)
-* [When should I use this?](#when-should-i-use-this)
-* [Install](#install)
-* [Use](#use)
-* [API](#api)
-  * [`normalizeUri(value)`](#normalizeurivalue)
-  * [`sanitizeUri(url[, pattern])`](#sanitizeuriurl-pattern)
-* [Types](#types)
-* [Compatibility](#compatibility)
-* [Security](#security)
-* [Contribute](#contribute)
-* [License](#license)
-## What is this?
-This package exposes an algorithm to make URLs safe.
-## When should I use this?
-This package might be useful when you are making your own micromark extensions.
-## Install
-This package is [ESM only][esm].
-In Node.js (version 16+), install with [npm][]:
-```sh
-npm install micromark-util-sanitize-uri
-```
-In Deno with [`esm.sh`][esmsh]:
-```js
-import {sanitizeUri} from 'https://esm.sh/micromark-util-sanitize-uri@1'
-```
-In browsers with [`esm.sh`][esmsh]:
-```html
-<script type="module">
-  import {sanitizeUri} from 'https://esm.sh/micromark-util-sanitize-uri@1?bundle'
-</script>
-```
-## Use
-```js
-import {sanitizeUri} from 'micromark-util-sanitize-uri'
-sanitizeUri('https://example.com/a&amp;b') // 'https://example.com/a&amp;amp;b'
-sanitizeUri('https://example.com/a%b') // 'https://example.com/a%25b'
-sanitizeUri('https://example.com/a%20b') // 'https://example.com/a%20b'
-sanitizeUri('https://example.com/👍') // 'https://example.com/%F0%9F%91%8D'
-sanitizeUri('https://example.com/', /^https?$/i) // 'https://example.com/'
-sanitizeUri('javascript:alert(1)', /^https?$/i) // ''
-sanitizeUri('./example.jpg', /^https?$/i) // './example.jpg'
-sanitizeUri('#a', /^https?$/i) // '#a'
-```
-## API
-This module exports the identifiers [`normalizeUri`][api-normalize-uri] and
-[`sanitizeUri`][api-sanitize-uri].
-There is no default export.
-### `normalizeUri(value)`
-Normalize a URL.
-Encode unsafe characters with percent-encoding, skipping already encoded
-sequences.
-###### Parameters
-* `value` (`string`)
-  — URI to normalize
-###### Returns
-Normalized URI (`string`).
-### `sanitizeUri(url[, pattern])`
-Make a value safe for injection as a URL.
-This encodes unsafe characters with percent-encoding and skips already
-encoded sequences (see [`normalizeUri`][api-normalize-uri]).
-Further unsafe characters are encoded as character references (see
-[`micromark-util-encode`][micromark-util-encode]).
-A regex of allowed protocols can be given, in which case the URL is sanitized.
-For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or
-`/^https?$/i` for `img[src]` (this is what `github.com` allows).
-If the URL includes an unknown protocol (one not matched by `protocol`, such
-as a dangerous example, `javascript:`), the value is ignored.
-###### Parameters
-* `url` (`string`)
-  — URI to sanitize
-* `pattern` (`RegExp`, optional)
-  — allowed protocols
-###### Returns
-Sanitized URI (`string`).
-## Types
-This package is fully typed with [TypeScript][].
-It exports no additional types.
-## Compatibility
-Projects maintained by the unified collective are compatible with maintained
-versions of Node.js.
-When we cut a new major release, we drop support for unmaintained versions of
-Node.
-This means we try to keep the current release line,
-`micromark-util-sanitize-uri@2`, compatible with Node.js 16.
-This package works with `micromark@3`.
-## Security
-This package is safe.
-See [`security.md`][securitymd] in [`micromark/.github`][health] for how to
-submit a security report.
-## Contribute
-See [`contributing.md`][contributing] in [`micromark/.github`][health] for ways
-to get started.
-See [`support.md`][support] for ways to get help.
-This project has a [code of conduct][coc].
-By interacting with this repository, organisation, or community you agree to
-abide by its terms.
-## License
-[MIT][license] © [Titus Wormer][author]
-<!-- Definitions -->
-[build-badge]: https://github.com/micromark/micromark/workflows/main/badge.svg
-[build]: https://github.com/micromark/micromark/actions
-[coverage-badge]: https://img.shields.io/codecov/c/github/micromark/micromark.svg
-[coverage]: https://codecov.io/github/micromark/micromark
-[downloads-badge]: https://img.shields.io/npm/dm/micromark-util-sanitize-uri.svg
-[downloads]: https://www.npmjs.com/package/micromark-util-sanitize-uri
-[bundle-size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=micromark-util-sanitize-uri
-[bundle-size]: https://bundlejs.com/?q=micromark-util-sanitize-uri
-[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
-[backers-badge]: https://opencollective.com/unified/backers/badge.svg
-[opencollective]: https://opencollective.com/unified
-[npm]: https://docs.npmjs.com/cli/install
-[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
-[esmsh]: https://esm.sh
-[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
-[chat]: https://github.com/micromark/micromark/discussions
-[license]: https://github.com/micromark/micromark/blob/main/license
-[author]: https://wooorm.com
-[health]: https://github.com/micromark/.github
-[securitymd]: https://github.com/micromark/.github/blob/main/security.md
-[contributing]: https://github.com/micromark/.github/blob/main/contributing.md
-[support]: https://github.com/micromark/.github/blob/main/support.md
-[coc]: https://github.com/micromark/.github/blob/main/code-of-conduct.md
-[typescript]: https://www.typescriptlang.org
-[micromark]: https://github.com/micromark/micromark
-[micromark-util-encode]: https://github.com/micromark/micromark/tree/main/packages/micromark-util-encode
-[api-normalize-uri]: #normalizeurivalue
-[api-sanitize-uri]: #sanitizeuriurl-pattern

package/plugin/node_modules/micromark-util-subtokenize/dev/index.d.ts DELETED Viewed

@@ -1,12 +0,0 @@
-/**
- * Tokenize subcontent.
- *
- * @param {Array<Event>} eventsArray
- *   List of events.
- * @returns {boolean}
- *   Whether subtokens were found.
- */
-export function subtokenize(eventsArray: Array<Event>): boolean;
-export { SpliceBuffer } from "./lib/splice-buffer.js";
-import type { Event } from 'micromark-util-types';
-//# sourceMappingURL=index.d.ts.map

package/plugin/node_modules/micromark-util-subtokenize/dev/index.d.ts.map DELETED Viewed

	@@ -1 +0,0 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AAEH,yCANW,KAAK,CAAC,KAAK,CAAC,GAEV,OAAO,CAuHnB;;2BAvIqC,sBAAsB"}

package/plugin/node_modules/micromark-util-subtokenize/dev/index.js DELETED Viewed

@@ -1,284 +0,0 @@
-/**
- * @import {Chunk, Event, Token} from 'micromark-util-types'
- */
-import {ok as assert} from 'devlop'
-import {splice} from 'micromark-util-chunked'
-import {codes, types} from 'micromark-util-symbol'
-import {SpliceBuffer} from './lib/splice-buffer.js'
-// Hidden API exposed for testing.
-export {SpliceBuffer} from './lib/splice-buffer.js'
-/**
- * Tokenize subcontent.
- *
- * @param {Array<Event>} eventsArray
- *   List of events.
- * @returns {boolean}
- *   Whether subtokens were found.
- */
-// eslint-disable-next-line complexity
-export function subtokenize(eventsArray) {
-  /** @type {Record<string, number>} */
-  const jumps = {}
-  let index = -1
-  /** @type {Event} */
-  let event
-  /** @type {number | undefined} */
-  let lineIndex
-  /** @type {number} */
-  let otherIndex
-  /** @type {Event} */
-  let otherEvent
-  /** @type {Array<Event>} */
-  let parameters
-  /** @type {Array<Event>} */
-  let subevents
-  /** @type {boolean | undefined} */
-  let more
-  const events = new SpliceBuffer(eventsArray)
-  while (++index < events.length) {
-    while (index in jumps) {
-      index = jumps[index]
-    }
-    event = events.get(index)
-    // Add a hook for the GFM tasklist extension, which needs to know if text
-    // is in the first content of a list item.
-    if (
-      index &&
-      event[1].type === types.chunkFlow &&
-      events.get(index - 1)[1].type === types.listItemPrefix
-    ) {
-      assert(event[1]._tokenizer, 'expected `_tokenizer` on subtokens')
-      subevents = event[1]._tokenizer.events
-      otherIndex = 0
-      if (
-        otherIndex < subevents.length &&
-        subevents[otherIndex][1].type === types.lineEndingBlank
-      ) {
-        otherIndex += 2
-      }
-      if (
-        otherIndex < subevents.length &&
-        subevents[otherIndex][1].type === types.content
-      ) {
-        while (++otherIndex < subevents.length) {
-          if (subevents[otherIndex][1].type === types.content) {
-            break
-          }
-          if (subevents[otherIndex][1].type === types.chunkText) {
-            subevents[otherIndex][1]._isInFirstContentOfListItem = true
-            otherIndex++
-          }
-        }
-      }
-    }
-    // Enter.
-    if (event[0] === 'enter') {
-      if (event[1].contentType) {
-        Object.assign(jumps, subcontent(events, index))
-        index = jumps[index]
-        more = true
-      }
-    }
-    // Exit.
-    else if (event[1]._container) {
-      otherIndex = index
-      lineIndex = undefined
-      while (otherIndex--) {
-        otherEvent = events.get(otherIndex)
-        if (
-          otherEvent[1].type === types.lineEnding ||
-          otherEvent[1].type === types.lineEndingBlank
-        ) {
-          if (otherEvent[0] === 'enter') {
-            if (lineIndex) {
-              events.get(lineIndex)[1].type = types.lineEndingBlank
-            }
-            otherEvent[1].type = types.lineEnding
-            lineIndex = otherIndex
-          }
-        } else if (
-          otherEvent[1].type === types.linePrefix ||
-          otherEvent[1].type === types.listItemIndent
-        ) {
-          // Move past.
-        } else {
-          break
-        }
-      }
-      if (lineIndex) {
-        // Fix position.
-        event[1].end = {...events.get(lineIndex)[1].start}
-        // Switch container exit w/ line endings.
-        parameters = events.slice(lineIndex, index)
-        parameters.unshift(event)
-        events.splice(lineIndex, index - lineIndex + 1, parameters)
-      }
-    }
-  }
-  // The changes to the `events` buffer must be copied back into the eventsArray
-  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0))
-  return !more
-}
-/**
- * Tokenize embedded tokens.
- *
- * @param {SpliceBuffer<Event>} events
- *   Events.
- * @param {number} eventIndex
- *   Index.
- * @returns {Record<string, number>}
- *   Gaps.
- */
-function subcontent(events, eventIndex) {
-  const token = events.get(eventIndex)[1]
-  const context = events.get(eventIndex)[2]
-  let startPosition = eventIndex - 1
-  /** @type {Array<number>} */
-  const startPositions = []
-  assert(token.contentType, 'expected `contentType` on subtokens')
-  let tokenizer = token._tokenizer
-  if (!tokenizer) {
-    tokenizer = context.parser[token.contentType](token.start)
-    if (token._contentTypeTextTrailing) {
-      tokenizer._contentTypeTextTrailing = true
-    }
-  }
-  const childEvents = tokenizer.events
-  /** @type {Array<[number, number]>} */
-  const jumps = []
-  /** @type {Record<string, number>} */
-  const gaps = {}
-  /** @type {Array<Chunk>} */
-  let stream
-  /** @type {Token | undefined} */
-  let previous
-  let index = -1
-  /** @type {Token | undefined} */
-  let current = token
-  let adjust = 0
-  let start = 0
-  const breaks = [start]
-  // Loop forward through the linked tokens to pass them in order to the
-  // subtokenizer.
-  while (current) {
-    // Find the position of the event for this token.
-    while (events.get(++startPosition)[1] !== current) {
-      // Empty.
-    }
-    assert(
-      !previous || current.previous === previous,
-      'expected previous to match'
-    )
-    assert(!previous || previous.next === current, 'expected next to match')
-    startPositions.push(startPosition)
-    if (!current._tokenizer) {
-      stream = context.sliceStream(current)
-      if (!current.next) {
-        stream.push(codes.eof)
-      }
-      if (previous) {
-        tokenizer.defineSkip(current.start)
-      }
-      if (current._isInFirstContentOfListItem) {
-        tokenizer._gfmTasklistFirstContentOfListItem = true
-      }
-      tokenizer.write(stream)
-      if (current._isInFirstContentOfListItem) {
-        tokenizer._gfmTasklistFirstContentOfListItem = undefined
-      }
-    }
-    // Unravel the next token.
-    previous = current
-    current = current.next
-  }
-  // Now, loop back through all events (and linked tokens), to figure out which
-  // parts belong where.
-  current = token
-  while (++index < childEvents.length) {
-    if (
-      // Find a void token that includes a break.
-      childEvents[index][0] === 'exit' &&
-      childEvents[index - 1][0] === 'enter' &&
-      childEvents[index][1].type === childEvents[index - 1][1].type &&
-      childEvents[index][1].start.line !== childEvents[index][1].end.line
-    ) {
-      assert(current, 'expected a current token')
-      start = index + 1
-      breaks.push(start)
-      // Help GC.
-      current._tokenizer = undefined
-      current.previous = undefined
-      current = current.next
-    }
-  }
-  // Help GC.
-  tokenizer.events = []
-  // If there’s one more token (which is the cases for lines that end in an
-  // EOF), that’s perfect: the last point we found starts it.
-  // If there isn’t then make sure any remaining content is added to it.
-  if (current) {
-    // Help GC.
-    current._tokenizer = undefined
-    current.previous = undefined
-    assert(!current.next, 'expected no next token')
-  } else {
-    breaks.pop()
-  }
-  // Now splice the events from the subtokenizer into the current events,
-  // moving back to front so that splice indices aren’t affected.
-  index = breaks.length
-  while (index--) {
-    const slice = childEvents.slice(breaks[index], breaks[index + 1])
-    const start = startPositions.pop()
-    assert(start !== undefined, 'expected a start position when splicing')
-    jumps.push([start, start + slice.length - 1])
-    events.splice(start, 2, slice)
-  }
-  jumps.reverse()
-  index = -1
-  while (++index < jumps.length) {
-    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]
-    adjust += jumps[index][1] - jumps[index][0] - 1
-  }
-  return gaps
-}

package/plugin/node_modules/micromark-util-subtokenize/dev/lib/splice-buffer.d.ts DELETED Viewed

@@ -1,161 +0,0 @@
-/**
- * Some of the internal operations of micromark do lots of editing
- * operations on very large arrays. This runs into problems with two
- * properties of most circa-2020 JavaScript interpreters:
- *
- *  - Array-length modifications at the high end of an array (push/pop) are
- *    expected to be common and are implemented in (amortized) time
- *    proportional to the number of elements added or removed, whereas
- *    other operations (shift/unshift and splice) are much less efficient.
- *  - Function arguments are passed on the stack, so adding tens of thousands
- *    of elements to an array with `arr.push(...newElements)` will frequently
- *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)
- *
- * SpliceBuffers are an implementation of gap buffers, which are a
- * generalization of the "queue made of two stacks" idea. The splice buffer
- * maintains a cursor, and moving the cursor has cost proportional to the
- * distance the cursor moves, but inserting, deleting, or splicing in
- * new information at the cursor is as efficient as the push/pop operation.
- * This allows for an efficient sequence of splices (or pushes, pops, shifts,
- * or unshifts) as long such edits happen at the same part of the array or
- * generally sweep through the array from the beginning to the end.
- *
- * The interface for splice buffers also supports large numbers of inputs by
- * passing a single array argument rather passing multiple arguments on the
- * function call stack.
- *
- * @template T
- *   Item type.
- */
-export class SpliceBuffer<T> {
-    /**
-     * @param {ReadonlyArray<T> | null | undefined} [initial]
-     *   Initial items (optional).
-     * @returns
-     *   Splice buffer.
-     */
-    constructor(initial?: ReadonlyArray<T> | null | undefined);
-    /** @type {Array<T>} */
-    left: Array<T>;
-    /** @type {Array<T>} */
-    right: Array<T>;
-    /**
-     * Array access;
-     * does not move the cursor.
-     *
-     * @param {number} index
-     *   Index.
-     * @return {T}
-     *   Item.
-     */
-    get(index: number): T;
-    /**
-     * The length of the splice buffer, one greater than the largest index in the
-     * array.
-     */
-    get length(): number;
-    /**
-     * Remove and return `list[0]`;
-     * moves the cursor to `0`.
-     *
-     * @returns {T | undefined}
-     *   Item, optional.
-     */
-    shift(): T | undefined;
-    /**
-     * Slice the buffer to get an array;
-     * does not move the cursor.
-     *
-     * @param {number} start
-     *   Start.
-     * @param {number | null | undefined} [end]
-     *   End (optional).
-     * @returns {Array<T>}
-     *   Array of items.
-     */
-    slice(start: number, end?: number | null | undefined): Array<T>;
-    /**
-     * Mimics the behavior of Array.prototype.splice() except for the change of
-     * interface necessary to avoid segfaults when patching in very large arrays.
-     *
-     * This operation moves cursor is moved to `start` and results in the cursor
-     * placed after any inserted items.
-     *
-     * @param {number} start
-     *   Start;
-     *   zero-based index at which to start changing the array;
-     *   negative numbers count backwards from the end of the array and values
-     *   that are out-of bounds are clamped to the appropriate end of the array.
-     * @param {number | null | undefined} [deleteCount=0]
-     *   Delete count (default: `0`);
-     *   maximum number of elements to delete, starting from start.
-     * @param {Array<T> | null | undefined} [items=[]]
-     *   Items to include in place of the deleted items (default: `[]`).
-     * @return {Array<T>}
-     *   Any removed items.
-     */
-    splice(start: number, deleteCount?: number | null | undefined, items?: Array<T> | null | undefined): Array<T>;
-    /**
-     * Remove and return the highest-numbered item in the array, so
-     * `list[list.length - 1]`;
-     * Moves the cursor to `length`.
-     *
-     * @returns {T | undefined}
-     *   Item, optional.
-     */
-    pop(): T | undefined;
-    /**
-     * Inserts a single item to the high-numbered side of the array;
-     * moves the cursor to `length`.
-     *
-     * @param {T} item
-     *   Item.
-     * @returns {undefined}
-     *   Nothing.
-     */
-    push(item: T): undefined;
-    /**
-     * Inserts many items to the high-numbered side of the array.
-     * Moves the cursor to `length`.
-     *
-     * @param {Array<T>} items
-     *   Items.
-     * @returns {undefined}
-     *   Nothing.
-     */
-    pushMany(items: Array<T>): undefined;
-    /**
-     * Inserts a single item to the low-numbered side of the array;
-     * Moves the cursor to `0`.
-     *
-     * @param {T} item
-     *   Item.
-     * @returns {undefined}
-     *   Nothing.
-     */
-    unshift(item: T): undefined;
-    /**
-     * Inserts many items to the low-numbered side of the array;
-     * moves the cursor to `0`.
-     *
-     * @param {Array<T>} items
-     *   Items.
-     * @returns {undefined}
-     *   Nothing.
-     */
-    unshiftMany(items: Array<T>): undefined;
-    /**
-     * Move the cursor to a specific position in the array. Requires
-     * time proportional to the distance moved.
-     *
-     * If `n < 0`, the cursor will end up at the beginning.
-     * If `n > length`, the cursor will end up at the end.
-     *
-     * @param {number} n
-     *   Position.
-     * @return {undefined}
-     *   Nothing.
-     */
-    setCursor(n: number): undefined;
-}
-//# sourceMappingURL=splice-buffer.d.ts.map

package/plugin/node_modules/micromark-util-subtokenize/dev/lib/splice-buffer.d.ts.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"file":"splice-buffer.d.ts","sourceRoot":"","sources":["splice-buffer.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0BAHa,CAAC;IAIZ;;;;;OAKG;IACH,sBALW,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAU7C;IAJC,uBAAuB;IACvB,MADW,KAAK,CAAC,CAAC,CAAC,CACoB;IACvC,uBAAuB;IACvB,OADW,KAAK,CAAC,CAAC,CAAC,CACJ;IAGjB;;;;;;;;OAQG;IACH,WALW,MAAM,GAEL,CAAC,CAgBZ;IAED;;;OAGG;IACH,qBAEC;IAED;;;;;;OAMG;IACH,SAHa,CAAC,GAAG,SAAS,CAMzB;IAED;;;;;;;;;;OAUG;IACH,aAPW,MAAM,QAEN,MAAM,GAAG,IAAI,GAAG,SAAS,GAEvB,KAAK,CAAC,CAAC,CAAC,CA0BpB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAbW,MAAM,gBAKN,MAAM,GAAG,IAAI,GAAG,SAAS,UAGzB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAE1B,KAAK,CAAC,CAAC,CAAC,CAcnB;IAED;;;;;;;OAOG;IACH,OAHa,CAAC,GAAG,SAAS,CAMzB;IAED;;;;;;;;OAQG;IACH,WALW,CAAC,GAEC,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,gBALW,KAAK,CAAC,CAAC,CAAC,GAEN,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,cALW,CAAC,GAEC,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,mBALW,KAAK,CAAC,CAAC,CAAC,GAEN,SAAS,CAMrB;IAED;;;;;;;;;;;OAWG;IACH,aALW,MAAM,GAEL,SAAS,CAsBpB;CACF"}