@rse/ase 0.0.42 → 0.0.43

package/plugin/node_modules/micromark/dev/lib/initialize/text.js

@@ -1,244 +0,0 @@
-/**
- * @import {
- *   Code,
- *   InitialConstruct,
- *   Initializer,
- *   Resolver,
- *   State,
- *   TokenizeContext
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {codes, constants, types} from 'micromark-util-symbol'
-
-export const resolver = {resolveAll: createResolver()}
-export const string = initializeFactory('string')
-export const text = initializeFactory('text')
-
-/**
- * @param {'string' | 'text'} field
- *   Field.
- * @returns {InitialConstruct}
- *   Construct.
- */
-function initializeFactory(field) {
-  return {
-    resolveAll: createResolver(
-      field === 'text' ? resolveAllLineSuffixes : undefined
-    ),
-    tokenize: initializeText
-  }
-
-  /**
-   * @this {TokenizeContext}
-   *   Context.
-   * @type {Initializer}
-   */
-  function initializeText(effects) {
-    const self = this
-    const constructs = this.parser.constructs[field]
-    const text = effects.attempt(constructs, start, notText)
-
-    return start
-
-    /** @type {State} */
-    function start(code) {
-      return atBreak(code) ? text(code) : notText(code)
-    }
-
-    /** @type {State} */
-    function notText(code) {
-      if (code === codes.eof) {
-        effects.consume(code)
-        return
-      }
-
-      effects.enter(types.data)
-      effects.consume(code)
-      return data
-    }
-
-    /** @type {State} */
-    function data(code) {
-      if (atBreak(code)) {
-        effects.exit(types.data)
-        return text(code)
-      }
-
-      // Data.
-      effects.consume(code)
-      return data
-    }
-
-    /**
-     * @param {Code} code
-     *   Code.
-     * @returns {boolean}
-     *   Whether the code is a break.
-     */
-    function atBreak(code) {
-      if (code === codes.eof) {
-        return true
-      }
-
-      const list = constructs[code]
-      let index = -1
-
-      if (list) {
-        // Always populated by defaults.
-        assert(Array.isArray(list), 'expected `disable.null` to be populated')
-
-        while (++index < list.length) {
-          const item = list[index]
-          if (!item.previous || item.previous.call(self, self.previous)) {
-            return true
-          }
-        }
-      }
-
-      return false
-    }
-  }
-}
-
-/**
- * @param {Resolver | undefined} [extraResolver]
- *   Resolver.
- * @returns {Resolver}
- *   Resolver.
- */
-function createResolver(extraResolver) {
-  return resolveAllText
-
-  /** @type {Resolver} */
-  function resolveAllText(events, context) {
-    let index = -1
-    /** @type {number | undefined} */
-    let enter
-
-    // A rather boring computation (to merge adjacent `data` events) which
-    // improves mm performance by 29%.
-    while (++index <= events.length) {
-      if (enter === undefined) {
-        if (events[index] && events[index][1].type === types.data) {
-          enter = index
-          index++
-        }
-      } else if (!events[index] || events[index][1].type !== types.data) {
-        // Don’t do anything if there is one data token.
-        if (index !== enter + 2) {
-          events[enter][1].end = events[index - 1][1].end
-          events.splice(enter + 2, index - enter - 2)
-          index = enter + 2
-        }
-
-        enter = undefined
-      }
-    }
-
-    return extraResolver ? extraResolver(events, context) : events
-  }
-}
-
-/**
- * A rather ugly set of instructions which again looks at chunks in the input
- * stream.
- * The reason to do this here is that it is *much* faster to parse in reverse.
- * And that we can’t hook into `null` to split the line suffix before an EOF.
- * To do: figure out if we can make this into a clean utility, or even in core.
- * As it will be useful for GFMs literal autolink extension (and maybe even
- * tables?)
- *
- * @type {Resolver}
- */
-function resolveAllLineSuffixes(events, context) {
-  let eventIndex = 0 // Skip first.
-
-  while (++eventIndex <= events.length) {
-    if (
-      (eventIndex === events.length ||
-        events[eventIndex][1].type === types.lineEnding) &&
-      events[eventIndex - 1][1].type === types.data
-    ) {
-      const data = events[eventIndex - 1][1]
-      const chunks = context.sliceStream(data)
-      let index = chunks.length
-      let bufferIndex = -1
-      let size = 0
-      /** @type {boolean | undefined} */
-      let tabs
-
-      while (index--) {
-        const chunk = chunks[index]
-
-        if (typeof chunk === 'string') {
-          bufferIndex = chunk.length
-
-          while (chunk.charCodeAt(bufferIndex - 1) === codes.space) {
-            size++
-            bufferIndex--
-          }
-
-          if (bufferIndex) break
-          bufferIndex = -1
-        }
-        // Number
-        else if (chunk === codes.horizontalTab) {
-          tabs = true
-          size++
-        } else if (chunk === codes.virtualSpace) {
-          // Empty
-        } else {
-          // Replacement character, exit.
-          index++
-          break
-        }
-      }
-
-      // Allow final trailing whitespace.
-      if (context._contentTypeTextTrailing && eventIndex === events.length) {
-        size = 0
-      }
-
-      if (size) {
-        const token = {
-          type:
-            eventIndex === events.length ||
-            tabs ||
-            size < constants.hardBreakPrefixSizeMin
-              ? types.lineSuffix
-              : types.hardBreakTrailing,
-          start: {
-            _bufferIndex: index
-              ? bufferIndex
-              : data.start._bufferIndex + bufferIndex,
-            _index: data.start._index + index,
-            line: data.end.line,
-            column: data.end.column - size,
-            offset: data.end.offset - size
-          },
-          end: {...data.end}
-        }
-
-        data.end = {...token.start}
-
-        if (data.start.offset === data.end.offset) {
-          Object.assign(data, token)
-        } else {
-          events.splice(
-            eventIndex,
-            0,
-            ['enter', token, context],
-            ['exit', token, context]
-          )
-          eventIndex += 2
-        }
-      }
-
-      eventIndex++
-    }
-  }
-
-  return events
-}

package/plugin/node_modules/micromark/dev/lib/parse.d.ts

@@ -1,10 +0,0 @@
-/**
- * @param {ParseOptions | null | undefined} [options]
- *   Configuration (optional).
- * @returns {ParseContext}
- *   Parser.
- */
-export function parse(options?: ParseOptions | null | undefined): ParseContext;
-import type { ParseOptions } from 'micromark-util-types';
-import type { ParseContext } from 'micromark-util-types';
-//# sourceMappingURL=parse.d.ts.map

package/plugin/node_modules/micromark/dev/lib/parse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["parse.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,gCALW,YAAY,GAAG,IAAI,GAAG,SAAS,GAE7B,YAAY,CAoCxB;kCAlDS,sBAAsB;kCAAtB,sBAAsB"}

package/plugin/node_modules/micromark/dev/lib/parse.js

@@ -1,58 +0,0 @@
-/**
- * @import {
- *   Create,
- *   FullNormalizedExtension,
- *   InitialConstruct,
- *   ParseContext,
- *   ParseOptions
- * } from 'micromark-util-types'
- */
-
-import {combineExtensions} from 'micromark-util-combine-extensions'
-import {content} from './initialize/content.js'
-import {document} from './initialize/document.js'
-import {flow} from './initialize/flow.js'
-import {string, text} from './initialize/text.js'
-import * as defaultConstructs from './constructs.js'
-import {createTokenizer} from './create-tokenizer.js'
-
-/**
- * @param {ParseOptions | null | undefined} [options]
- *   Configuration (optional).
- * @returns {ParseContext}
- *   Parser.
- */
-export function parse(options) {
-  const settings = options || {}
-  const constructs = /** @type {FullNormalizedExtension} */ (
-    combineExtensions([defaultConstructs, ...(settings.extensions || [])])
-  )
-
-  /** @type {ParseContext} */
-  const parser = {
-    constructs,
-    content: create(content),
-    defined: [],
-    document: create(document),
-    flow: create(flow),
-    lazy: {},
-    string: create(string),
-    text: create(text)
-  }
-
-  return parser
-
-  /**
-   * @param {InitialConstruct} initial
-   *   Construct to start with.
-   * @returns {Create}
-   *   Create a tokenizer.
-   */
-  function create(initial) {
-    return creator
-    /** @type {Create} */
-    function creator(from) {
-      return createTokenizer(parser, initial, from)
-    }
-  }
-}

package/plugin/node_modules/micromark/dev/lib/postprocess.d.ts

@@ -1,9 +0,0 @@
-/**
- * @param {Array<Event>} events
- *   Events.
- * @returns {Array<Event>}
- *   Events.
- */
-export function postprocess(events: Array<Event>): Array<Event>;
-import type { Event } from 'micromark-util-types';
-//# sourceMappingURL=postprocess.d.ts.map

package/plugin/node_modules/micromark/dev/lib/postprocess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postprocess.d.ts","sourceRoot":"","sources":["postprocess.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,oCALW,KAAK,CAAC,KAAK,CAAC,GAEV,KAAK,CAAC,KAAK,CAAC,CASxB;2BAjBuB,sBAAsB"}

package/plugin/node_modules/micromark/dev/lib/postprocess.js

@@ -1,19 +0,0 @@
-/**
- * @import {Event} from 'micromark-util-types'
- */
-
-import {subtokenize} from 'micromark-util-subtokenize'
-
-/**
- * @param {Array<Event>} events
- *   Events.
- * @returns {Array<Event>}
- *   Events.
- */
-export function postprocess(events) {
-  while (!subtokenize(events)) {
-    // Empty
-  }
-
-  return events
-}

package/plugin/node_modules/micromark/dev/lib/preprocess.d.ts

@@ -1,13 +0,0 @@
-/**
- * @returns {Preprocessor}
- *   Preprocess a value.
- */
-export function preprocess(): Preprocessor;
-/**
- * Preprocess a value.
- */
-export type Preprocessor = (value: Value, encoding?: Encoding | null | undefined, end?: boolean | null | undefined) => Array<Chunk>;
-import type { Value } from 'micromark-util-types';
-import type { Encoding } from 'micromark-util-types';
-import type { Chunk } from 'micromark-util-types';
-//# sourceMappingURL=preprocess.d.ts.map

package/plugin/node_modules/micromark/dev/lib/preprocess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preprocess.d.ts","sourceRoot":"","sources":["preprocess.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,8BAHa,YAAY,CAsHxB;;;;mCArIU,KAAK,aAEL,QAAQ,GAAG,IAAI,GAAG,SAAS,QAE3B,OAAO,GAAG,IAAI,GAAG,SAAS,KAExB,KAAK,CAAC,KAAK,CAAC;2BAZsB,sBAAsB;8BAAtB,sBAAsB;2BAAtB,sBAAsB"}

package/plugin/node_modules/micromark/dev/lib/preprocess.js

@@ -1,141 +0,0 @@
-/**
- * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'
- */
-
-/**
- * @callback Preprocessor
- *   Preprocess a value.
- * @param {Value} value
- *   Value.
- * @param {Encoding | null | undefined} [encoding]
- *   Encoding when `value` is a typed array (optional).
- * @param {boolean | null | undefined} [end=false]
- *   Whether this is the last chunk (default: `false`).
- * @returns {Array<Chunk>}
- *   Chunks.
- */
-
-import {codes, constants} from 'micromark-util-symbol'
-
-const search = /[\0\t\n\r]/g
-
-/**
- * @returns {Preprocessor}
- *   Preprocess a value.
- */
-export function preprocess() {
-  let column = 1
-  let buffer = ''
-  /** @type {boolean | undefined} */
-  let start = true
-  /** @type {boolean | undefined} */
-  let atCarriageReturn
-
-  return preprocessor
-
-  /** @type {Preprocessor} */
-  // eslint-disable-next-line complexity
-  function preprocessor(value, encoding, end) {
-    /** @type {Array<Chunk>} */
-    const chunks = []
-    /** @type {RegExpMatchArray | null} */
-    let match
-    /** @type {number} */
-    let next
-    /** @type {number} */
-    let startPosition
-    /** @type {number} */
-    let endPosition
-    /** @type {Code} */
-    let code
-
-    value =
-      buffer +
-      (typeof value === 'string'
-        ? value.toString()
-        : new TextDecoder(encoding || undefined).decode(value))
-
-    startPosition = 0
-    buffer = ''
-
-    if (start) {
-      // To do: `markdown-rs` actually parses BOMs (byte order mark).
-      if (value.charCodeAt(0) === codes.byteOrderMarker) {
-        startPosition++
-      }
-
-      start = undefined
-    }
-
-    while (startPosition < value.length) {
-      search.lastIndex = startPosition
-      match = search.exec(value)
-      endPosition =
-        match && match.index !== undefined ? match.index : value.length
-      code = value.charCodeAt(endPosition)
-
-      if (!match) {
-        buffer = value.slice(startPosition)
-        break
-      }
-
-      if (
-        code === codes.lf &&
-        startPosition === endPosition &&
-        atCarriageReturn
-      ) {
-        chunks.push(codes.carriageReturnLineFeed)
-        atCarriageReturn = undefined
-      } else {
-        if (atCarriageReturn) {
-          chunks.push(codes.carriageReturn)
-          atCarriageReturn = undefined
-        }
-
-        if (startPosition < endPosition) {
-          chunks.push(value.slice(startPosition, endPosition))
-          column += endPosition - startPosition
-        }
-
-        switch (code) {
-          case codes.nul: {
-            chunks.push(codes.replacementCharacter)
-            column++
-
-            break
-          }
-
-          case codes.ht: {
-            next = Math.ceil(column / constants.tabSize) * constants.tabSize
-            chunks.push(codes.horizontalTab)
-            while (column++ < next) chunks.push(codes.virtualSpace)
-
-            break
-          }
-
-          case codes.lf: {
-            chunks.push(codes.lineFeed)
-            column = 1
-
-            break
-          }
-
-          default: {
-            atCarriageReturn = true
-            column = 1
-          }
-        }
-      }
-
-      startPosition = endPosition + 1
-    }
-
-    if (end) {
-      if (atCarriageReturn) chunks.push(codes.carriageReturn)
-      if (buffer) chunks.push(buffer)
-      chunks.push(codes.eof)
-    }
-
-    return chunks
-  }
-}

package/plugin/node_modules/micromark/dev/stream.d.ts

@@ -1,35 +0,0 @@
-/**
- * Create a duplex (readable and writable) stream.
- *
- * Some of the work to parse markdown can be done streaming, but in the
- * end buffering is required.
- *
- * micromark does not handle errors for you, so you must handle errors on whatever
- * streams you pipe into it.
- * As markdown does not know errors, `micromark` itself does not emit errors.
- *
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {MinimalDuplex}
- *   Duplex stream.
- */
-export function stream(options?: Options | null | undefined): MinimalDuplex;
-export type Options = import("micromark-util-types").Options;
-/**
- * Function called when write was successful.
- */
-export type Callback = () => undefined;
-/**
- * Configuration for piping.
- */
-export type PipeOptions = {
-    /**
-     * Whether to end the destination stream when the source stream ends.
-     */
-    end?: boolean | null | undefined;
-};
-/**
- * Duplex stream.
- */
-export type MinimalDuplex = Omit<NodeJS.ReadableStream & NodeJS.WritableStream, "isPaused" | "pause" | "read" | "resume" | "setEncoding" | "unpipe" | "unshift" | "wrap">;
-//# sourceMappingURL=stream.d.ts.map

package/plugin/node_modules/micromark/dev/stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["stream.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;GAcG;AACH,iCALW,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,aAAa,CAoOzB;sBAxQY,OAAO,sBAAsB,EAAE,OAAO;;;;6BAMtC,SAAS;;;;;;;;UAKR,OAAO,GAAG,IAAI,GAAG,SAAS;;;;;4BAG3B,IAAI,CAAC,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,EAAE,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC"}