ember-repl 7.1.0 → 7.1.1

package/dist/index-DMSCybEq.js

@@ -1,2640 +0,0 @@
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BAGoDD49.js';
-import { s as stringifyPosition } from './index-Bxzjtr16.js';
-
-/**
- * Throw a given error.
- *
- * @param {Error|null|undefined} [error]
- *   Maybe error.
- * @returns {asserts error is null|undefined}
- */
-function bail(error) {
-  if (error) {
-    throw error;
-  }
-}
-
-var extend$1;
-var hasRequiredExtend;
-
-function requireExtend () {
-	if (hasRequiredExtend) return extend$1;
-	hasRequiredExtend = 1;
-
-	var hasOwn = Object.prototype.hasOwnProperty;
-	var toStr = Object.prototype.toString;
-	var defineProperty = Object.defineProperty;
-	var gOPD = Object.getOwnPropertyDescriptor;
-	var isArray = function isArray(arr) {
-	  if (typeof Array.isArray === 'function') {
-	    return Array.isArray(arr);
-	  }
-	  return toStr.call(arr) === '[object Array]';
-	};
-	var isPlainObject = function isPlainObject(obj) {
-	  if (!obj || toStr.call(obj) !== '[object Object]') {
-	    return false;
-	  }
-	  var hasOwnConstructor = hasOwn.call(obj, 'constructor');
-	  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
-	  // Not own constructor property must be Object
-	  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
-	    return false;
-	  }
-
-	  // Own properties are enumerated firstly, so to speed up,
-	  // if last one is own, then all properties are own.
-	  var key;
-	  for (key in obj) {/**/}
-	  return typeof key === 'undefined' || hasOwn.call(obj, key);
-	};
-
-	// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
-	var setProperty = function setProperty(target, options) {
-	  if (defineProperty && options.name === '__proto__') {
-	    defineProperty(target, options.name, {
-	      enumerable: true,
-	      configurable: true,
-	      value: options.newValue,
-	      writable: true
-	    });
-	  } else {
-	    target[options.name] = options.newValue;
-	  }
-	};
-
-	// Return undefined instead of __proto__ if '__proto__' is not an own property
-	var getProperty = function getProperty(obj, name) {
-	  if (name === '__proto__') {
-	    if (!hasOwn.call(obj, name)) {
-	      return void 0;
-	    } else if (gOPD) {
-	      // In early versions of node, obj['__proto__'] is buggy when obj has
-	      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
-	      return gOPD(obj, name).value;
-	    }
-	  }
-	  return obj[name];
-	};
-	extend$1 = function extend() {
-	  var options, name, src, copy, copyIsArray, clone;
-	  var target = arguments[0];
-	  var i = 1;
-	  var length = arguments.length;
-	  var deep = false;
-
-	  // Handle a deep copy situation
-	  if (typeof target === 'boolean') {
-	    deep = target;
-	    target = arguments[1] || {};
-	    // skip the boolean and the target
-	    i = 2;
-	  }
-	  if (target == null || typeof target !== 'object' && typeof target !== 'function') {
-	    target = {};
-	  }
-	  for (; i < length; ++i) {
-	    options = arguments[i];
-	    // Only deal with non-null/undefined values
-	    if (options != null) {
-	      // Extend the base object
-	      for (name in options) {
-	        src = getProperty(target, name);
-	        copy = getProperty(options, name);
-
-	        // Prevent never-ending loop
-	        if (target !== copy) {
-	          // Recurse if we're merging plain objects or arrays
-	          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
-	            if (copyIsArray) {
-	              copyIsArray = false;
-	              clone = src && isArray(src) ? src : [];
-	            } else {
-	              clone = src && isPlainObject(src) ? src : {};
-	            }
-
-	            // Never move original objects, clone them
-	            setProperty(target, {
-	              name: name,
-	              newValue: extend(deep, clone, copy)
-	            });
-
-	            // Don't bring in undefined values
-	          } else if (typeof copy !== 'undefined') {
-	            setProperty(target, {
-	              name: name,
-	              newValue: copy
-	            });
-	          }
-	        }
-	      }
-	    }
-	  }
-
-	  // Return the modified object
-	  return target;
-	};
-	return extend$1;
-}
-
-var extendExports = requireExtend();
-var extend = /*@__PURE__*/getDefaultExportFromCjs(extendExports);
-
-function isPlainObject(value) {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-}
-
-// To do: remove `void`s
-// To do: remove `null` from output of our APIs, allow it as user APIs.
-
-/**
- * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback
- *   Callback.
- *
- * @typedef {(...input: Array<any>) => any} Middleware
- *   Ware.
- *
- * @typedef Pipeline
- *   Pipeline.
- * @property {Run} run
- *   Run the pipeline.
- * @property {Use} use
- *   Add middleware.
- *
- * @typedef {(...input: Array<any>) => void} Run
- *   Call all middleware.
- *
- *   Calls `done` on completion with either an error or the output of the
- *   last middleware.
- *
- *   > 👉 **Note**: as the length of input defines whether async functions get a
- *   > `next` function,
- *   > it’s recommended to keep `input` at one value normally.
-
- *
- * @typedef {(fn: Middleware) => Pipeline} Use
- *   Add middleware.
- */
-
-/**
- * Create new middleware.
- *
- * @returns {Pipeline}
- *   Pipeline.
- */
-function trough() {
-  /** @type {Array<Middleware>} */
-  const fns = [];
-  /** @type {Pipeline} */
-  const pipeline = {
-    run,
-    use
-  };
-  return pipeline;
-
-  /** @type {Run} */
-  function run(...values) {
-    let middlewareIndex = -1;
-    /** @type {Callback} */
-    const callback = values.pop();
-    if (typeof callback !== 'function') {
-      throw new TypeError('Expected function as last argument, not ' + callback);
-    }
-    next(null, ...values);
-
-    /**
-     * Run the next `fn`, or we’re done.
-     *
-     * @param {Error | null | undefined} error
-     * @param {Array<any>} output
-     */
-    function next(error, ...output) {
-      const fn = fns[++middlewareIndex];
-      let index = -1;
-      if (error) {
-        callback(error);
-        return;
-      }
-
-      // Copy non-nullish input into values.
-      while (++index < values.length) {
-        if (output[index] === null || output[index] === undefined) {
-          output[index] = values[index];
-        }
-      }
-
-      // Save the newly created `output` for the next call.
-      values = output;
-
-      // Next or done.
-      if (fn) {
-        wrap(fn, next)(...output);
-      } else {
-        callback(null, ...output);
-      }
-    }
-  }
-
-  /** @type {Use} */
-  function use(middelware) {
-    if (typeof middelware !== 'function') {
-      throw new TypeError('Expected `middelware` to be a function, not ' + middelware);
-    }
-    fns.push(middelware);
-    return pipeline;
-  }
-}
-
-/**
- * Wrap `middleware` into a uniform interface.
- *
- * You can pass all input to the resulting function.
- * `callback` is then called with the output of `middleware`.
- *
- * If `middleware` accepts more arguments than the later given in input,
- * an extra `done` function is passed to it after that input,
- * which must be called by `middleware`.
- *
- * The first value in `input` is the main input value.
- * All other input values are the rest input values.
- * The values given to `callback` are the input values,
- * merged with every non-nullish output value.
- *
- * * if `middleware` throws an error,
- *   returns a promise that is rejected,
- *   or calls the given `done` function with an error,
- *   `callback` is called with that error
- * * if `middleware` returns a value or returns a promise that is resolved,
- *   that value is the main output value
- * * if `middleware` calls `done`,
- *   all non-nullish values except for the first one (the error) overwrite the
- *   output values
- *
- * @param {Middleware} middleware
- *   Function to wrap.
- * @param {Callback} callback
- *   Callback called with the output of `middleware`.
- * @returns {Run}
- *   Wrapped middleware.
- */
-function wrap(middleware, callback) {
-  /** @type {boolean} */
-  let called;
-  return wrapped;
-
-  /**
-   * Call `middleware`.
-   * @this {any}
-   * @param {Array<any>} parameters
-   * @returns {void}
-   */
-  function wrapped(...parameters) {
-    const fnExpectsCallback = middleware.length > parameters.length;
-    /** @type {any} */
-    let result;
-    if (fnExpectsCallback) {
-      parameters.push(done);
-    }
-    try {
-      result = middleware.apply(this, parameters);
-    } catch (error) {
-      const exception = /** @type {Error} */error;
-
-      // Well, this is quite the pickle.
-      // `middleware` received a callback and called it synchronously, but that
-      // threw an error.
-      // The only thing left to do is to throw the thing instead.
-      if (fnExpectsCallback && called) {
-        throw exception;
-      }
-      return done(exception);
-    }
-    if (!fnExpectsCallback) {
-      if (result && result.then && typeof result.then === 'function') {
-        result.then(then, done);
-      } else if (result instanceof Error) {
-        done(result);
-      } else {
-        then(result);
-      }
-    }
-  }
-
-  /**
-   * Call `callback`, only once.
-   *
-   * @type {Callback}
-   */
-  function done(error, ...output) {
-    if (!called) {
-      called = true;
-      callback(error, ...output);
-    }
-  }
-
-  /**
-   * Call `done` with one value.
-   *
-   * @param {any} [value]
-   */
-  function then(value) {
-    done(null, value);
-  }
-}
-
-/**
- * @import {Node, Point, Position} from 'unist'
- */
-
-
-/**
- * Message.
- */
-class VFileMessage extends Error {
-  /**
-   * Create a message for `reason`.
-   *
-   * > 🪦 **Note**: also has obsolete signatures.
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Options | null | undefined} [options]
-   * @returns
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @overload
-   * @param {string} reason
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {string | null | undefined} [origin]
-   * @returns
-   *
-   * @param {Error | VFileMessage | string} causeOrReason
-   *   Reason for message, should use markdown.
-   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-   *   Configuration (optional).
-   * @param {string | null | undefined} [origin]
-   *   Place in code where the message originates (example:
-   *   `'my-package:my-rule'` or `'my-rule'`).
-   * @returns
-   *   Instance of `VFileMessage`.
-   */
-  // eslint-disable-next-line complexity
-  constructor(causeOrReason, optionsOrParentOrPlace, origin) {
-    super();
-    if (typeof optionsOrParentOrPlace === 'string') {
-      origin = optionsOrParentOrPlace;
-      optionsOrParentOrPlace = undefined;
-    }
-
-    /** @type {string} */
-    let reason = '';
-    /** @type {Options} */
-    let options = {};
-    let legacyCause = false;
-    if (optionsOrParentOrPlace) {
-      // Point.
-      if ('line' in optionsOrParentOrPlace && 'column' in optionsOrParentOrPlace) {
-        options = {
-          place: optionsOrParentOrPlace
-        };
-      }
-      // Position.
-      else if ('start' in optionsOrParentOrPlace && 'end' in optionsOrParentOrPlace) {
-        options = {
-          place: optionsOrParentOrPlace
-        };
-      }
-      // Node.
-      else if ('type' in optionsOrParentOrPlace) {
-        options = {
-          ancestors: [optionsOrParentOrPlace],
-          place: optionsOrParentOrPlace.position
-        };
-      }
-      // Options.
-      else {
-        options = {
-          ...optionsOrParentOrPlace
-        };
-      }
-    }
-    if (typeof causeOrReason === 'string') {
-      reason = causeOrReason;
-    }
-    // Error.
-    else if (!options.cause && causeOrReason) {
-      legacyCause = true;
-      reason = causeOrReason.message;
-      options.cause = causeOrReason;
-    }
-    if (!options.ruleId && !options.source && typeof origin === 'string') {
-      const index = origin.indexOf(':');
-      if (index === -1) {
-        options.ruleId = origin;
-      } else {
-        options.source = origin.slice(0, index);
-        options.ruleId = origin.slice(index + 1);
-      }
-    }
-    if (!options.place && options.ancestors && options.ancestors) {
-      const parent = options.ancestors[options.ancestors.length - 1];
-      if (parent) {
-        options.place = parent.position;
-      }
-    }
-    const start = options.place && 'start' in options.place ? options.place.start : options.place;
-
-    /**
-     * Stack of ancestor nodes surrounding the message.
-     *
-     * @type {Array<Node> | undefined}
-     */
-    this.ancestors = options.ancestors || undefined;
-
-    /**
-     * Original error cause of the message.
-     *
-     * @type {Error | undefined}
-     */
-    this.cause = options.cause || undefined;
-
-    /**
-     * Starting column of message.
-     *
-     * @type {number | undefined}
-     */
-    this.column = start ? start.column : undefined;
-
-    /**
-     * State of problem.
-     *
-     * * `true` — error, file not usable
-     * * `false` — warning, change may be needed
-     * * `undefined` — change likely not needed
-     *
-     * @type {boolean | null | undefined}
-     */
-    this.fatal = undefined;
-
-    /**
-     * Path of a file (used throughout the `VFile` ecosystem).
-     *
-     * @type {string | undefined}
-     */
-    this.file = '';
-
-    // Field from `Error`.
-    /**
-     * Reason for message.
-     *
-     * @type {string}
-     */
-    this.message = reason;
-
-    /**
-     * Starting line of error.
-     *
-     * @type {number | undefined}
-     */
-    this.line = start ? start.line : undefined;
-
-    // Field from `Error`.
-    /**
-     * Serialized positional info of message.
-     *
-     * On normal errors, this would be something like `ParseError`, buit in
-     * `VFile` messages we use this space to show where an error happened.
-     */
-    this.name = stringifyPosition(options.place) || '1:1';
-
-    /**
-     * Place of message.
-     *
-     * @type {Point | Position | undefined}
-     */
-    this.place = options.place || undefined;
-
-    /**
-     * Reason for message, should use markdown.
-     *
-     * @type {string}
-     */
-    this.reason = this.message;
-
-    /**
-     * Category of message (example: `'my-rule'`).
-     *
-     * @type {string | undefined}
-     */
-    this.ruleId = options.ruleId || undefined;
-
-    /**
-     * Namespace of message (example: `'my-package'`).
-     *
-     * @type {string | undefined}
-     */
-    this.source = options.source || undefined;
-
-    // Field from `Error`.
-    /**
-     * Stack of message.
-     *
-     * This is used by normal errors to show where something happened in
-     * programming code, irrelevant for `VFile` messages,
-     *
-     * @type {string}
-     */
-    this.stack = legacyCause && options.cause && typeof options.cause.stack === 'string' ? options.cause.stack : '';
-
-    // The following fields are “well known”.
-    // Not standard.
-    // Feel free to add other non-standard fields to your messages.
-
-    /**
-     * Specify the source value that’s being reported, which is deemed
-     * incorrect.
-     *
-     * @type {string | undefined}
-     */
-    this.actual = undefined;
-
-    /**
-     * Suggest acceptable values that can be used instead of `actual`.
-     *
-     * @type {Array<string> | undefined}
-     */
-    this.expected = undefined;
-
-    /**
-     * Long form description of the message (you should use markdown).
-     *
-     * @type {string | undefined}
-     */
-    this.note = undefined;
-
-    /**
-     * Link to docs for the message.
-     *
-     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`
-     * > to `new URL(x)`.
-     *
-     * @type {string | undefined}
-     */
-    this.url = undefined;
-  }
-}
-VFileMessage.prototype.file = '';
-VFileMessage.prototype.name = '';
-VFileMessage.prototype.reason = '';
-VFileMessage.prototype.message = '';
-VFileMessage.prototype.stack = '';
-VFileMessage.prototype.column = undefined;
-VFileMessage.prototype.line = undefined;
-VFileMessage.prototype.ancestors = undefined;
-VFileMessage.prototype.cause = undefined;
-VFileMessage.prototype.fatal = undefined;
-VFileMessage.prototype.place = undefined;
-VFileMessage.prototype.ruleId = undefined;
-VFileMessage.prototype.source = undefined;
-
-// A derivative work based on:
-// <https://github.com/browserify/path-browserify>.
-// Which is licensed:
-//
-// MIT License
-//
-// Copyright (c) 2013 James Halliday
-//
-// 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.
-// A derivative work based on:
-//
-// Parts of that are extracted from Node’s internal `path` module:
-// <https://github.com/nodejs/node/blob/master/lib/path.js>.
-// Which is licensed:
-//
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// 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.
-
-const minpath = {
-  basename,
-  dirname,
-  extname,
-  join,
-  sep: '/'
-};
-
-/* eslint-disable max-depth, complexity */
-
-/**
- * Get the basename from a path.
- *
- * @param {string} path
- *   File path.
- * @param {string | null | undefined} [extname]
- *   Extension to strip.
- * @returns {string}
- *   Stem or basename.
- */
-function basename(path, extname) {
-  if (extname !== undefined && typeof extname !== 'string') {
-    throw new TypeError('"ext" argument must be a string');
-  }
-  assertPath$1(path);
-  let start = 0;
-  let end = -1;
-  let index = path.length;
-  /** @type {boolean | undefined} */
-  let seenNonSlash;
-  if (extname === undefined || extname.length === 0 || extname.length > path.length) {
-    while (index--) {
-      if (path.codePointAt(index) === 47 /* `/` */) {
-        // If we reached a path separator that was not part of a set of path
-        // separators at the end of the string, stop now.
-        if (seenNonSlash) {
-          start = index + 1;
-          break;
-        }
-      } else if (end < 0) {
-        // We saw the first non-path separator, mark this as the end of our
-        // path component.
-        seenNonSlash = true;
-        end = index + 1;
-      }
-    }
-    return end < 0 ? '' : path.slice(start, end);
-  }
-  if (extname === path) {
-    return '';
-  }
-  let firstNonSlashEnd = -1;
-  let extnameIndex = extname.length - 1;
-  while (index--) {
-    if (path.codePointAt(index) === 47 /* `/` */) {
-      // If we reached a path separator that was not part of a set of path
-      // separators at the end of the string, stop now.
-      if (seenNonSlash) {
-        start = index + 1;
-        break;
-      }
-    } else {
-      if (firstNonSlashEnd < 0) {
-        // We saw the first non-path separator, remember this index in case
-        // we need it if the extension ends up not matching.
-        seenNonSlash = true;
-        firstNonSlashEnd = index + 1;
-      }
-      if (extnameIndex > -1) {
-        // Try to match the explicit extension.
-        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {
-          if (extnameIndex < 0) {
-            // We matched the extension, so mark this as the end of our path
-            // component
-            end = index;
-          }
-        } else {
-          // Extension does not match, so our result is the entire path
-          // component
-          extnameIndex = -1;
-          end = firstNonSlashEnd;
-        }
-      }
-    }
-  }
-  if (start === end) {
-    end = firstNonSlashEnd;
-  } else if (end < 0) {
-    end = path.length;
-  }
-  return path.slice(start, end);
-}
-
-/**
- * Get the dirname from a path.
- *
- * @param {string} path
- *   File path.
- * @returns {string}
- *   File path.
- */
-function dirname(path) {
-  assertPath$1(path);
-  if (path.length === 0) {
-    return '.';
-  }
-  let end = -1;
-  let index = path.length;
-  /** @type {boolean | undefined} */
-  let unmatchedSlash;
-
-  // Prefix `--` is important to not run on `0`.
-  while (--index) {
-    if (path.codePointAt(index) === 47 /* `/` */) {
-      if (unmatchedSlash) {
-        end = index;
-        break;
-      }
-    } else if (!unmatchedSlash) {
-      // We saw the first non-path separator
-      unmatchedSlash = true;
-    }
-  }
-  return end < 0 ? path.codePointAt(0) === 47 /* `/` */ ? '/' : '.' : end === 1 && path.codePointAt(0) === 47 /* `/` */ ? '//' : path.slice(0, end);
-}
-
-/**
- * Get an extname from a path.
- *
- * @param {string} path
- *   File path.
- * @returns {string}
- *   Extname.
- */
-function extname(path) {
-  assertPath$1(path);
-  let index = path.length;
-  let end = -1;
-  let startPart = 0;
-  let startDot = -1;
-  // Track the state of characters (if any) we see before our first dot and
-  // after any path separator we find.
-  let preDotState = 0;
-  /** @type {boolean | undefined} */
-  let unmatchedSlash;
-  while (index--) {
-    const code = path.codePointAt(index);
-    if (code === 47 /* `/` */) {
-      // If we reached a path separator that was not part of a set of path
-      // separators at the end of the string, stop now.
-      if (unmatchedSlash) {
-        startPart = index + 1;
-        break;
-      }
-      continue;
-    }
-    if (end < 0) {
-      // We saw the first non-path separator, mark this as the end of our
-      // extension.
-      unmatchedSlash = true;
-      end = index + 1;
-    }
-    if (code === 46 /* `.` */) {
-      // If this is our first dot, mark it as the start of our extension.
-      if (startDot < 0) {
-        startDot = index;
-      } else if (preDotState !== 1) {
-        preDotState = 1;
-      }
-    } else if (startDot > -1) {
-      // We saw a non-dot and non-path separator before our dot, so we should
-      // have a good chance at having a non-empty extension.
-      preDotState = -1;
-    }
-  }
-  if (startDot < 0 || end < 0 ||
-  // We saw a non-dot character immediately before the dot.
-  preDotState === 0 ||
-  // The (right-most) trimmed path component is exactly `..`.
-  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-    return '';
-  }
-  return path.slice(startDot, end);
-}
-
-/**
- * Join segments from a path.
- *
- * @param {Array<string>} segments
- *   Path segments.
- * @returns {string}
- *   File path.
- */
-function join(...segments) {
-  let index = -1;
-  /** @type {string | undefined} */
-  let joined;
-  while (++index < segments.length) {
-    assertPath$1(segments[index]);
-    if (segments[index]) {
-      joined = joined === undefined ? segments[index] : joined + '/' + segments[index];
-    }
-  }
-  return joined === undefined ? '.' : normalize(joined);
-}
-
-/**
- * Normalize a basic file path.
- *
- * @param {string} path
- *   File path.
- * @returns {string}
- *   File path.
- */
-// Note: `normalize` is not exposed as `path.normalize`, so some code is
-// manually removed from it.
-function normalize(path) {
-  assertPath$1(path);
-  const absolute = path.codePointAt(0) === 47; /* `/` */
-
-  // Normalize the path according to POSIX rules.
-  let value = normalizeString(path, !absolute);
-  if (value.length === 0 && !absolute) {
-    value = '.';
-  }
-  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {
-    value += '/';
-  }
-  return absolute ? '/' + value : value;
-}
-
-/**
- * Resolve `.` and `..` elements in a path with directory names.
- *
- * @param {string} path
- *   File path.
- * @param {boolean} allowAboveRoot
- *   Whether `..` can move above root.
- * @returns {string}
- *   File path.
- */
-function normalizeString(path, allowAboveRoot) {
-  let result = '';
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let index = -1;
-  /** @type {number | undefined} */
-  let code;
-  /** @type {number} */
-  let lastSlashIndex;
-  while (++index <= path.length) {
-    if (index < path.length) {
-      code = path.codePointAt(index);
-    } else if (code === 47 /* `/` */) {
-      break;
-    } else {
-      code = 47; /* `/` */
-    }
-    if (code === 47 /* `/` */) {
-      if (lastSlash === index - 1 || dots === 1) ; else if (lastSlash !== index - 1 && dots === 2) {
-        if (result.length < 2 || lastSegmentLength !== 2 || result.codePointAt(result.length - 1) !== 46 /* `.` */ || result.codePointAt(result.length - 2) !== 46 /* `.` */) {
-          if (result.length > 2) {
-            lastSlashIndex = result.lastIndexOf('/');
-            if (lastSlashIndex !== result.length - 1) {
-              if (lastSlashIndex < 0) {
-                result = '';
-                lastSegmentLength = 0;
-              } else {
-                result = result.slice(0, lastSlashIndex);
-                lastSegmentLength = result.length - 1 - result.lastIndexOf('/');
-              }
-              lastSlash = index;
-              dots = 0;
-              continue;
-            }
-          } else if (result.length > 0) {
-            result = '';
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          result = result.length > 0 ? result + '/..' : '..';
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (result.length > 0) {
-          result += '/' + path.slice(lastSlash + 1, index);
-        } else {
-          result = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (code === 46 /* `.` */ && dots > -1) {
-      dots++;
-    } else {
-      dots = -1;
-    }
-  }
-  return result;
-}
-
-/**
- * Make sure `path` is a string.
- *
- * @param {string} path
- *   File path.
- * @returns {asserts path is string}
- *   Nothing.
- */
-function assertPath$1(path) {
-  if (typeof path !== 'string') {
-    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
-  }
-}
-
-/* eslint-enable max-depth, complexity */
-
-// Somewhat based on:
-// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.
-// But I don’t think one tiny line of code can be copyrighted. 😅
-const minproc = {
-  cwd
-};
-function cwd() {
-  return '/';
-}
-
-/**
- * Checks if a value has the shape of a WHATWG URL object.
- *
- * Using a symbol or instanceof would not be able to recognize URL objects
- * coming from other implementations (e.g. in Electron), so instead we are
- * checking some well known properties for a lack of a better test.
- *
- * We use `href` and `protocol` as they are the only properties that are
- * easy to retrieve and calculate due to the lazy nature of the getters.
- *
- * We check for auth attribute to distinguish legacy url instance with
- * WHATWG URL instance.
- *
- * @param {unknown} fileUrlOrPath
- *   File path or URL.
- * @returns {fileUrlOrPath is URL}
- *   Whether it’s a URL.
- */
-// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>
-function isUrl(fileUrlOrPath) {
-  return Boolean(fileUrlOrPath !== null && typeof fileUrlOrPath === 'object' && 'href' in fileUrlOrPath && fileUrlOrPath.href && 'protocol' in fileUrlOrPath && fileUrlOrPath.protocol &&
-  // @ts-expect-error: indexing is fine.
-  fileUrlOrPath.auth === undefined);
-}
-
-// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>
-
-/**
- * @param {URL | string} path
- *   File URL.
- * @returns {string}
- *   File URL.
- */
-function urlToPath(path) {
-  if (typeof path === 'string') {
-    path = new URL(path);
-  } else if (!isUrl(path)) {
-    /** @type {NodeJS.ErrnoException} */
-    const error = new TypeError('The "path" argument must be of type string or an instance of URL. Received `' + path + '`');
-    error.code = 'ERR_INVALID_ARG_TYPE';
-    throw error;
-  }
-  if (path.protocol !== 'file:') {
-    /** @type {NodeJS.ErrnoException} */
-    const error = new TypeError('The URL must be of scheme file');
-    error.code = 'ERR_INVALID_URL_SCHEME';
-    throw error;
-  }
-  return getPathFromURLPosix(path);
-}
-
-/**
- * Get a path from a POSIX URL.
- *
- * @param {URL} url
- *   URL.
- * @returns {string}
- *   File path.
- */
-function getPathFromURLPosix(url) {
-  if (url.hostname !== '') {
-    /** @type {NodeJS.ErrnoException} */
-    const error = new TypeError('File URL host must be "localhost" or empty on darwin');
-    error.code = 'ERR_INVALID_FILE_URL_HOST';
-    throw error;
-  }
-  const pathname = url.pathname;
-  let index = -1;
-  while (++index < pathname.length) {
-    if (pathname.codePointAt(index) === 37 /* `%` */ && pathname.codePointAt(index + 1) === 50 /* `2` */) {
-      const third = pathname.codePointAt(index + 2);
-      if (third === 70 /* `F` */ || third === 102 /* `f` */) {
-        /** @type {NodeJS.ErrnoException} */
-        const error = new TypeError('File URL path must not include encoded / characters');
-        error.code = 'ERR_INVALID_FILE_URL_PATH';
-        throw error;
-      }
-    }
-  }
-  return decodeURIComponent(pathname);
-}
-
-/**
- * @import {Node, Point, Position} from 'unist'
- * @import {Options as MessageOptions} from 'vfile-message'
- * @import {Compatible, Data, Map, Options, Value} from 'vfile'
- */
-
-
-/**
- * Order of setting (least specific to most), we need this because otherwise
- * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
- * stem can be set.
- */
-const order = /** @type {const} */['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
-class VFile {
-  /**
-   * Create a new virtual file.
-   *
-   * `options` is treated as:
-   *
-   * *   `string` or `Uint8Array` — `{value: options}`
-   * *   `URL` — `{path: options}`
-   * *   `VFile` — shallow copies its data over to the new file
-   * *   `object` — all fields are shallow copied over to the new file
-   *
-   * Path related fields are set in the following order (least specific to
-   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
-   * `dirname`.
-   *
-   * You cannot set `dirname` or `extname` without setting either `history`,
-   * `path`, `basename`, or `stem` too.
-   *
-   * @param {Compatible | null | undefined} [value]
-   *   File value.
-   * @returns
-   *   New instance.
-   */
-  constructor(value) {
-    /** @type {Options | VFile} */
-    let options;
-    if (!value) {
-      options = {};
-    } else if (isUrl(value)) {
-      options = {
-        path: value
-      };
-    } else if (typeof value === 'string' || isUint8Array$1(value)) {
-      options = {
-        value
-      };
-    } else {
-      options = value;
-    }
-
-    /* eslint-disable no-unused-expressions */
-
-    /**
-     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).
-     *
-     * @type {string}
-     */
-    // Prevent calling `cwd` (which could be expensive) if it’s not needed;
-    // the empty string will be overridden in the next block.
-    this.cwd = 'cwd' in options ? '' : minproc.cwd();
-
-    /**
-     * Place to store custom info (default: `{}`).
-     *
-     * It’s OK to store custom data directly on the file but moving it to
-     * `data` is recommended.
-     *
-     * @type {Data}
-     */
-    this.data = {};
-
-    /**
-     * List of file paths the file moved between.
-     *
-     * The first is the original path and the last is the current path.
-     *
-     * @type {Array<string>}
-     */
-    this.history = [];
-
-    /**
-     * List of messages associated with the file.
-     *
-     * @type {Array<VFileMessage>}
-     */
-    this.messages = [];
-
-    /**
-     * Raw value.
-     *
-     * @type {Value}
-     */
-    this.value;
-
-    // The below are non-standard, they are “well-known”.
-    // As in, used in several tools.
-    /**
-     * Source map.
-     *
-     * This type is equivalent to the `RawSourceMap` type from the `source-map`
-     * module.
-     *
-     * @type {Map | null | undefined}
-     */
-    this.map;
-
-    /**
-     * Custom, non-string, compiled, representation.
-     *
-     * This is used by unified to store non-string results.
-     * One example is when turning markdown into React nodes.
-     *
-     * @type {unknown}
-     */
-    this.result;
-
-    /**
-     * Whether a file was saved to disk.
-     *
-     * This is used by vfile reporters.
-     *
-     * @type {boolean}
-     */
-    this.stored;
-    /* eslint-enable no-unused-expressions */
-
-    // Set path related properties in the correct order.
-    let index = -1;
-    while (++index < order.length) {
-      const field = order[index];
-
-      // Note: we specifically use `in` instead of `hasOwnProperty` to accept
-      // `vfile`s too.
-      if (field in options && options[field] !== undefined && options[field] !== null) {
-        // @ts-expect-error: TS doesn’t understand basic reality.
-        this[field] = field === 'history' ? [...options[field]] : options[field];
-      }
-    }
-
-    /** @type {string} */
-    let field;
-
-    // Set non-path related properties.
-    for (field in options) {
-      // @ts-expect-error: fine to set other things.
-      if (!order.includes(field)) {
-        // @ts-expect-error: fine to set other things.
-        this[field] = options[field];
-      }
-    }
-  }
-
-  /**
-   * Get the basename (including extname) (example: `'index.min.js'`).
-   *
-   * @returns {string | undefined}
-   *   Basename.
-   */
-  get basename() {
-    return typeof this.path === 'string' ? minpath.basename(this.path) : undefined;
-  }
-
-  /**
-   * Set basename (including extname) (`'index.min.js'`).
-   *
-   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-   * on windows).
-   * Cannot be nullified (use `file.path = file.dirname` instead).
-   *
-   * @param {string} basename
-   *   Basename.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  set basename(basename) {
-    assertNonEmpty(basename, 'basename');
-    assertPart(basename, 'basename');
-    this.path = minpath.join(this.dirname || '', basename);
-  }
-
-  /**
-   * Get the parent path (example: `'~'`).
-   *
-   * @returns {string | undefined}
-   *   Dirname.
-   */
-  get dirname() {
-    return typeof this.path === 'string' ? minpath.dirname(this.path) : undefined;
-  }
-
-  /**
-   * Set the parent path (example: `'~'`).
-   *
-   * Cannot be set if there’s no `path` yet.
-   *
-   * @param {string | undefined} dirname
-   *   Dirname.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  set dirname(dirname) {
-    assertPath(this.basename, 'dirname');
-    this.path = minpath.join(dirname || '', this.basename);
-  }
-
-  /**
-   * Get the extname (including dot) (example: `'.js'`).
-   *
-   * @returns {string | undefined}
-   *   Extname.
-   */
-  get extname() {
-    return typeof this.path === 'string' ? minpath.extname(this.path) : undefined;
-  }
-
-  /**
-   * Set the extname (including dot) (example: `'.js'`).
-   *
-   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-   * on windows).
-   * Cannot be set if there’s no `path` yet.
-   *
-   * @param {string | undefined} extname
-   *   Extname.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  set extname(extname) {
-    assertPart(extname, 'extname');
-    assertPath(this.dirname, 'extname');
-    if (extname) {
-      if (extname.codePointAt(0) !== 46 /* `.` */) {
-        throw new Error('`extname` must start with `.`');
-      }
-      if (extname.includes('.', 1)) {
-        throw new Error('`extname` cannot contain multiple dots');
-      }
-    }
-    this.path = minpath.join(this.dirname, this.stem + (extname || ''));
-  }
-
-  /**
-   * Get the full path (example: `'~/index.min.js'`).
-   *
-   * @returns {string}
-   *   Path.
-   */
-  get path() {
-    return this.history[this.history.length - 1];
-  }
-
-  /**
-   * Set the full path (example: `'~/index.min.js'`).
-   *
-   * Cannot be nullified.
-   * You can set a file URL (a `URL` object with a `file:` protocol) which will
-   * be turned into a path with `url.fileURLToPath`.
-   *
-   * @param {URL | string} path
-   *   Path.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  set path(path) {
-    if (isUrl(path)) {
-      path = urlToPath(path);
-    }
-    assertNonEmpty(path, 'path');
-    if (this.path !== path) {
-      this.history.push(path);
-    }
-  }
-
-  /**
-   * Get the stem (basename w/o extname) (example: `'index.min'`).
-   *
-   * @returns {string | undefined}
-   *   Stem.
-   */
-  get stem() {
-    return typeof this.path === 'string' ? minpath.basename(this.path, this.extname) : undefined;
-  }
-
-  /**
-   * Set the stem (basename w/o extname) (example: `'index.min'`).
-   *
-   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
-   * on windows).
-   * Cannot be nullified (use `file.path = file.dirname` instead).
-   *
-   * @param {string} stem
-   *   Stem.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  set stem(stem) {
-    assertNonEmpty(stem, 'stem');
-    assertPart(stem, 'stem');
-    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''));
-  }
-
-  // Normal prototypal methods.
-  /**
-   * Create a fatal message for `reason` associated with the file.
-   *
-   * The `fatal` field of the message is set to `true` (error; file not usable)
-   * and the `file` field is set to the current file path.
-   * The message is added to the `messages` field on `file`.
-   *
-   * > 🪦 **Note**: also has obsolete signatures.
-   *
-   * @overload
-   * @param {string} reason
-   * @param {MessageOptions | null | undefined} [options]
-   * @returns {never}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {string | null | undefined} [origin]
-   * @returns {never}
-   *
-   * @param {Error | VFileMessage | string} causeOrReason
-   *   Reason for message, should use markdown.
-   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-   *   Configuration (optional).
-   * @param {string | null | undefined} [origin]
-   *   Place in code where the message originates (example:
-   *   `'my-package:my-rule'` or `'my-rule'`).
-   * @returns {never}
-   *   Never.
-   * @throws {VFileMessage}
-   *   Message.
-   */
-  fail(causeOrReason, optionsOrParentOrPlace, origin) {
-    // @ts-expect-error: the overloads are fine.
-    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
-    message.fatal = true;
-    throw message;
-  }
-
-  /**
-   * Create an info message for `reason` associated with the file.
-   *
-   * The `fatal` field of the message is set to `undefined` (info; change
-   * likely not needed) and the `file` field is set to the current file path.
-   * The message is added to the `messages` field on `file`.
-   *
-   * > 🪦 **Note**: also has obsolete signatures.
-   *
-   * @overload
-   * @param {string} reason
-   * @param {MessageOptions | null | undefined} [options]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @param {Error | VFileMessage | string} causeOrReason
-   *   Reason for message, should use markdown.
-   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-   *   Configuration (optional).
-   * @param {string | null | undefined} [origin]
-   *   Place in code where the message originates (example:
-   *   `'my-package:my-rule'` or `'my-rule'`).
-   * @returns {VFileMessage}
-   *   Message.
-   */
-  info(causeOrReason, optionsOrParentOrPlace, origin) {
-    // @ts-expect-error: the overloads are fine.
-    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin);
-    message.fatal = undefined;
-    return message;
-  }
-
-  /**
-   * Create a message for `reason` associated with the file.
-   *
-   * The `fatal` field of the message is set to `false` (warning; change may be
-   * needed) and the `file` field is set to the current file path.
-   * The message is added to the `messages` field on `file`.
-   *
-   * > 🪦 **Note**: also has obsolete signatures.
-   *
-   * @overload
-   * @param {string} reason
-   * @param {MessageOptions | null | undefined} [options]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {string} reason
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Node | NodeLike | null | undefined} parent
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {Point | Position | null | undefined} place
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @overload
-   * @param {Error | VFileMessage} cause
-   * @param {string | null | undefined} [origin]
-   * @returns {VFileMessage}
-   *
-   * @param {Error | VFileMessage | string} causeOrReason
-   *   Reason for message, should use markdown.
-   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
-   *   Configuration (optional).
-   * @param {string | null | undefined} [origin]
-   *   Place in code where the message originates (example:
-   *   `'my-package:my-rule'` or `'my-rule'`).
-   * @returns {VFileMessage}
-   *   Message.
-   */
-  message(causeOrReason, optionsOrParentOrPlace, origin) {
-    const message = new VFileMessage(
-    // @ts-expect-error: the overloads are fine.
-    causeOrReason, optionsOrParentOrPlace, origin);
-    if (this.path) {
-      message.name = this.path + ':' + message.name;
-      message.file = this.path;
-    }
-    message.fatal = false;
-    this.messages.push(message);
-    return message;
-  }
-
-  /**
-   * Serialize the file.
-   *
-   * > **Note**: which encodings are supported depends on the engine.
-   * > For info on Node.js, see:
-   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.
-   *
-   * @param {string | null | undefined} [encoding='utf8']
-   *   Character encoding to understand `value` as when it’s a `Uint8Array`
-   *   (default: `'utf-8'`).
-   * @returns {string}
-   *   Serialized file.
-   */
-  toString(encoding) {
-    if (this.value === undefined) {
-      return '';
-    }
-    if (typeof this.value === 'string') {
-      return this.value;
-    }
-    const decoder = new TextDecoder(encoding || undefined);
-    return decoder.decode(this.value);
-  }
-}
-
-/**
- * Assert that `part` is not a path (as in, does not contain `path.sep`).
- *
- * @param {string | null | undefined} part
- *   File path part.
- * @param {string} name
- *   Part name.
- * @returns {undefined}
- *   Nothing.
- */
-function assertPart(part, name) {
-  if (part && part.includes(minpath.sep)) {
-    throw new Error('`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`');
-  }
-}
-
-/**
- * Assert that `part` is not empty.
- *
- * @param {string | undefined} part
- *   Thing.
- * @param {string} name
- *   Part name.
- * @returns {asserts part is string}
- *   Nothing.
- */
-function assertNonEmpty(part, name) {
-  if (!part) {
-    throw new Error('`' + name + '` cannot be empty');
-  }
-}
-
-/**
- * Assert `path` exists.
- *
- * @param {string | undefined} path
- *   Path.
- * @param {string} name
- *   Dependency name.
- * @returns {asserts path is string}
- *   Nothing.
- */
-function assertPath(path, name) {
-  if (!path) {
-    throw new Error('Setting `' + name + '` requires `path` to be set too');
-  }
-}
-
-/**
- * Assert `value` is an `Uint8Array`.
- *
- * @param {unknown} value
- *   thing.
- * @returns {value is Uint8Array}
- *   Whether `value` is an `Uint8Array`.
- */
-function isUint8Array$1(value) {
-  return Boolean(value && typeof value === 'object' && 'byteLength' in value && 'byteOffset' in value);
-}
-
-const CallableInstance =
-/**
- * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}
- */
-
-/** @type {unknown} */
-
-/**
- * @this {Function}
- * @param {string | symbol} property
- * @returns {(...parameters: Array<unknown>) => unknown}
- */
-function (property) {
-  const self = this;
-  const constr = self.constructor;
-  const proto = /** @type {Record<string | symbol, Function>} */
-  // Prototypes do exist.
-  // type-coverage:ignore-next-line
-  constr.prototype;
-  const value = proto[property];
-  /** @type {(...parameters: Array<unknown>) => unknown} */
-  const apply = function () {
-    return value.apply(apply, arguments);
-  };
-  Object.setPrototypeOf(apply, proto);
-
-  // Not needed for us in `unified`: we only call this on the `copy`
-  // function,
-  // and we don't need to add its fields (`length`, `name`)
-  // over.
-  // See also: GH-246.
-  // const names = Object.getOwnPropertyNames(value)
-  //
-  // for (const p of names) {
-  //   const descriptor = Object.getOwnPropertyDescriptor(value, p)
-  //   if (descriptor) Object.defineProperty(apply, p, descriptor)
-  // }
-
-  return apply;
-};
-
-/**
- * @typedef {import('trough').Pipeline} Pipeline
- *
- * @typedef {import('unist').Node} Node
- *
- * @typedef {import('vfile').Compatible} Compatible
- * @typedef {import('vfile').Value} Value
- *
- * @typedef {import('../index.js').CompileResultMap} CompileResultMap
- * @typedef {import('../index.js').Data} Data
- * @typedef {import('../index.js').Settings} Settings
- */
-
-
-// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.
-
-// To do: we could start yielding `never` in TS when a parser is missing and
-// `parse` is called.
-// Currently, we allow directly setting `processor.parser`, which is untyped.
-
-const own = {}.hasOwnProperty;
-
-/**
- * @template {Node | undefined} [ParseTree=undefined]
- *   Output of `parse` (optional).
- * @template {Node | undefined} [HeadTree=undefined]
- *   Input for `run` (optional).
- * @template {Node | undefined} [TailTree=undefined]
- *   Output for `run` (optional).
- * @template {Node | undefined} [CompileTree=undefined]
- *   Input of `stringify` (optional).
- * @template {CompileResults | undefined} [CompileResult=undefined]
- *   Output of `stringify` (optional).
- * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}
- */
-class Processor extends CallableInstance {
-  /**
-   * Create a processor.
-   */
-  constructor() {
-    // If `Processor()` is called (w/o new), `copy` is called instead.
-    super('copy');
-
-    /**
-     * Compiler to use (deprecated).
-     *
-     * @deprecated
-     *   Use `compiler` instead.
-     * @type {(
-     *   Compiler<
-     *     CompileTree extends undefined ? Node : CompileTree,
-     *     CompileResult extends undefined ? CompileResults : CompileResult
-     *   > |
-     *   undefined
-     * )}
-     */
-    this.Compiler = undefined;
-
-    /**
-     * Parser to use (deprecated).
-     *
-     * @deprecated
-     *   Use `parser` instead.
-     * @type {(
-     *   Parser<ParseTree extends undefined ? Node : ParseTree> |
-     *   undefined
-     * )}
-     */
-    this.Parser = undefined;
-
-    // Note: the following fields are considered private.
-    // However, they are needed for tests, and TSC generates an untyped
-    // `private freezeIndex` field for, which trips `type-coverage` up.
-    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.
-    /**
-     * Internal list of configured plugins.
-     *
-     * @deprecated
-     *   This is a private internal property and should not be used.
-     * @type {Array<PluginTuple<Array<unknown>>>}
-     */
-    this.attachers = [];
-
-    /**
-     * Compiler to use.
-     *
-     * @type {(
-     *   Compiler<
-     *     CompileTree extends undefined ? Node : CompileTree,
-     *     CompileResult extends undefined ? CompileResults : CompileResult
-     *   > |
-     *   undefined
-     * )}
-     */
-    this.compiler = undefined;
-
-    /**
-     * Internal state to track where we are while freezing.
-     *
-     * @deprecated
-     *   This is a private internal property and should not be used.
-     * @type {number}
-     */
-    this.freezeIndex = -1;
-
-    /**
-     * Internal state to track whether we’re frozen.
-     *
-     * @deprecated
-     *   This is a private internal property and should not be used.
-     * @type {boolean | undefined}
-     */
-    this.frozen = undefined;
-
-    /**
-     * Internal state.
-     *
-     * @deprecated
-     *   This is a private internal property and should not be used.
-     * @type {Data}
-     */
-    this.namespace = {};
-
-    /**
-     * Parser to use.
-     *
-     * @type {(
-     *   Parser<ParseTree extends undefined ? Node : ParseTree> |
-     *   undefined
-     * )}
-     */
-    this.parser = undefined;
-
-    /**
-     * Internal list of configured transformers.
-     *
-     * @deprecated
-     *   This is a private internal property and should not be used.
-     * @type {Pipeline}
-     */
-    this.transformers = trough();
-  }
-
-  /**
-   * Copy a processor.
-   *
-   * @deprecated
-   *   This is a private internal method and should not be used.
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *   New *unfrozen* processor ({@linkcode Processor}) that is
-   *   configured to work the same as its ancestor.
-   *   When the descendant processor is configured in the future it does not
-   *   affect the ancestral processor.
-   */
-  copy() {
-    // Cast as the type parameters will be the same after attaching.
-    const destination = /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */
-    new Processor();
-    let index = -1;
-    while (++index < this.attachers.length) {
-      const attacher = this.attachers[index];
-      destination.use(...attacher);
-    }
-    destination.data(extend(true, {}, this.namespace));
-    return destination;
-  }
-
-  /**
-   * Configure the processor with info available to all plugins.
-   * Information is stored in an object.
-   *
-   * Typically, options can be given to a specific plugin, but sometimes it
-   * makes sense to have information shared with several plugins.
-   * For example, a list of HTML elements that are self-closing, which is
-   * needed during all phases.
-   *
-   * > **Note**: setting information cannot occur on *frozen* processors.
-   * > Call the processor first to create a new unfrozen processor.
-   *
-   * > **Note**: to register custom data in TypeScript, augment the
-   * > {@linkcode Data} interface.
-   *
-   * @example
-   *   This example show how to get and set info:
-   *
-   *   ```js
-   *   import {unified} from 'unified'
-   *
-   *   const processor = unified().data('alpha', 'bravo')
-   *
-   *   processor.data('alpha') // => 'bravo'
-   *
-   *   processor.data() // => {alpha: 'bravo'}
-   *
-   *   processor.data({charlie: 'delta'})
-   *
-   *   processor.data() // => {charlie: 'delta'}
-   *   ```
-   *
-   * @template {keyof Data} Key
-   *
-   * @overload
-   * @returns {Data}
-   *
-   * @overload
-   * @param {Data} dataset
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *
-   * @overload
-   * @param {Key} key
-   * @returns {Data[Key]}
-   *
-   * @overload
-   * @param {Key} key
-   * @param {Data[Key]} value
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *
-   * @param {Data | Key} [key]
-   *   Key to get or set, or entire dataset to set, or nothing to get the
-   *   entire dataset (optional).
-   * @param {Data[Key]} [value]
-   *   Value to set (optional).
-   * @returns {unknown}
-   *   The current processor when setting, the value at `key` when getting, or
-   *   the entire dataset when getting without key.
-   */
-  data(key, value) {
-    if (typeof key === 'string') {
-      // Set `key`.
-      if (arguments.length === 2) {
-        assertUnfrozen('data', this.frozen);
-        this.namespace[key] = value;
-        return this;
-      }
-
-      // Get `key`.
-      return own.call(this.namespace, key) && this.namespace[key] || undefined;
-    }
-
-    // Set space.
-    if (key) {
-      assertUnfrozen('data', this.frozen);
-      this.namespace = key;
-      return this;
-    }
-
-    // Get space.
-    return this.namespace;
-  }
-
-  /**
-   * Freeze a processor.
-   *
-   * Frozen processors are meant to be extended and not to be configured
-   * directly.
-   *
-   * When a processor is frozen it cannot be unfrozen.
-   * New processors working the same way can be created by calling the
-   * processor.
-   *
-   * It’s possible to freeze processors explicitly by calling `.freeze()`.
-   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,
-   * `.stringify()`, `.process()`, or `.processSync()` are called.
-   *
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *   The current processor.
-   */
-  freeze() {
-    if (this.frozen) {
-      return this;
-    }
-
-    // Cast so that we can type plugins easier.
-    // Plugins are supposed to be usable on different processors, not just on
-    // this exact processor.
-    const self = /** @type {Processor} */ /** @type {unknown} */this;
-    while (++this.freezeIndex < this.attachers.length) {
-      const [attacher, ...options] = this.attachers[this.freezeIndex];
-      if (options[0] === false) {
-        continue;
-      }
-      if (options[0] === true) {
-        options[0] = undefined;
-      }
-      const transformer = attacher.call(self, ...options);
-      if (typeof transformer === 'function') {
-        this.transformers.use(transformer);
-      }
-    }
-    this.frozen = true;
-    this.freezeIndex = Number.POSITIVE_INFINITY;
-    return this;
-  }
-
-  /**
-   * Parse text to a syntax tree.
-   *
-   * > **Note**: `parse` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `parse` performs the parse phase, not the run phase or other
-   * > phases.
-   *
-   * @param {Compatible | undefined} [file]
-   *   file to parse (optional); typically `string` or `VFile`; any value
-   *   accepted as `x` in `new VFile(x)`.
-   * @returns {ParseTree extends undefined ? Node : ParseTree}
-   *   Syntax tree representing `file`.
-   */
-  parse(file) {
-    this.freeze();
-    const realFile = vfile(file);
-    const parser = this.parser || this.Parser;
-    assertParser('parse', parser);
-    return parser(String(realFile), realFile);
-  }
-
-  /**
-   * Process the given file as configured on the processor.
-   *
-   * > **Note**: `process` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `process` performs the parse, run, and stringify phases.
-   *
-   * @overload
-   * @param {Compatible | undefined} file
-   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done
-   * @returns {undefined}
-   *
-   * @overload
-   * @param {Compatible | undefined} [file]
-   * @returns {Promise<VFileWithOutput<CompileResult>>}
-   *
-   * @param {Compatible | undefined} [file]
-   *   File (optional); typically `string` or `VFile`]; any value accepted as
-   *   `x` in `new VFile(x)`.
-   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]
-   *   Callback (optional).
-   * @returns {Promise<VFile> | undefined}
-   *   Nothing if `done` is given.
-   *   Otherwise a promise, rejected with a fatal error or resolved with the
-   *   processed file.
-   *
-   *   The parsed, transformed, and compiled value is available at
-   *   `file.value` (see note).
-   *
-   *   > **Note**: unified typically compiles by serializing: most
-   *   > compilers return `string` (or `Uint8Array`).
-   *   > Some compilers, such as the one configured with
-   *   > [`rehype-react`][rehype-react], return other values (in this case, a
-   *   > React tree).
-   *   > If you’re using a compiler that doesn’t serialize, expect different
-   *   > result values.
-   *   >
-   *   > To register custom results in TypeScript, add them to
-   *   > {@linkcode CompileResultMap}.
-   *
-   *   [rehype-react]: https://github.com/rehypejs/rehype-react
-   */
-  process(file, done) {
-    const self = this;
-    this.freeze();
-    assertParser('process', this.parser || this.Parser);
-    assertCompiler('process', this.compiler || this.Compiler);
-    return done ? executor(undefined, done) : new Promise(executor);
-
-    // Note: `void`s needed for TS.
-    /**
-     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve
-     * @param {(error: Error | undefined) => undefined | void} reject
-     * @returns {undefined}
-     */
-    function executor(resolve, reject) {
-      const realFile = vfile(file);
-      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the
-      // input of the first transform).
-      const parseTree = /** @type {HeadTree extends undefined ? Node : HeadTree} */
-      /** @type {unknown} */self.parse(realFile);
-      self.run(parseTree, realFile, function (error, tree, file) {
-        if (error || !tree || !file) {
-          return realDone(error);
-        }
-
-        // Assume `TailTree` (the output of the last transform) matches
-        // `CompileTree` (the input of the compiler).
-        const compileTree = /** @type {CompileTree extends undefined ? Node : CompileTree} */
-        /** @type {unknown} */tree;
-        const compileResult = self.stringify(compileTree, file);
-        if (looksLikeAValue(compileResult)) {
-          file.value = compileResult;
-        } else {
-          file.result = compileResult;
-        }
-        realDone(error, /** @type {VFileWithOutput<CompileResult>} */file);
-      });
-
-      /**
-       * @param {Error | undefined} error
-       * @param {VFileWithOutput<CompileResult> | undefined} [file]
-       * @returns {undefined}
-       */
-      function realDone(error, file) {
-        if (error || !file) {
-          reject(error);
-        } else if (resolve) {
-          resolve(file);
-        } else {
-          done(undefined, file);
-        }
-      }
-    }
-  }
-
-  /**
-   * Process the given file as configured on the processor.
-   *
-   * An error is thrown if asynchronous transforms are configured.
-   *
-   * > **Note**: `processSync` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `processSync` performs the parse, run, and stringify phases.
-   *
-   * @param {Compatible | undefined} [file]
-   *   File (optional); typically `string` or `VFile`; any value accepted as
-   *   `x` in `new VFile(x)`.
-   * @returns {VFileWithOutput<CompileResult>}
-   *   The processed file.
-   *
-   *   The parsed, transformed, and compiled value is available at
-   *   `file.value` (see note).
-   *
-   *   > **Note**: unified typically compiles by serializing: most
-   *   > compilers return `string` (or `Uint8Array`).
-   *   > Some compilers, such as the one configured with
-   *   > [`rehype-react`][rehype-react], return other values (in this case, a
-   *   > React tree).
-   *   > If you’re using a compiler that doesn’t serialize, expect different
-   *   > result values.
-   *   >
-   *   > To register custom results in TypeScript, add them to
-   *   > {@linkcode CompileResultMap}.
-   *
-   *   [rehype-react]: https://github.com/rehypejs/rehype-react
-   */
-  processSync(file) {
-    /** @type {boolean} */
-    let complete = false;
-    /** @type {VFileWithOutput<CompileResult> | undefined} */
-    let result;
-    this.freeze();
-    assertParser('processSync', this.parser || this.Parser);
-    assertCompiler('processSync', this.compiler || this.Compiler);
-    this.process(file, realDone);
-    assertDone('processSync', 'process', complete);
-    return result;
-
-    /**
-     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}
-     */
-    function realDone(error, file) {
-      complete = true;
-      bail(error);
-      result = file;
-    }
-  }
-
-  /**
-   * Run *transformers* on a syntax tree.
-   *
-   * > **Note**: `run` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `run` performs the run phase, not other phases.
-   *
-   * @overload
-   * @param {HeadTree extends undefined ? Node : HeadTree} tree
-   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
-   * @returns {undefined}
-   *
-   * @overload
-   * @param {HeadTree extends undefined ? Node : HeadTree} tree
-   * @param {Compatible | undefined} file
-   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done
-   * @returns {undefined}
-   *
-   * @overload
-   * @param {HeadTree extends undefined ? Node : HeadTree} tree
-   * @param {Compatible | undefined} [file]
-   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}
-   *
-   * @param {HeadTree extends undefined ? Node : HeadTree} tree
-   *   Tree to transform and inspect.
-   * @param {(
-   *   RunCallback<TailTree extends undefined ? Node : TailTree> |
-   *   Compatible
-   * )} [file]
-   *   File associated with `node` (optional); any value accepted as `x` in
-   *   `new VFile(x)`.
-   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]
-   *   Callback (optional).
-   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}
-   *   Nothing if `done` is given.
-   *   Otherwise, a promise rejected with a fatal error or resolved with the
-   *   transformed tree.
-   */
-  run(tree, file, done) {
-    assertNode(tree);
-    this.freeze();
-    const transformers = this.transformers;
-    if (!done && typeof file === 'function') {
-      done = file;
-      file = undefined;
-    }
-    return done ? executor(undefined, done) : new Promise(executor);
-
-    // Note: `void`s needed for TS.
-    /**
-     * @param {(
-     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |
-     *   undefined
-     * )} resolve
-     * @param {(error: Error) => undefined | void} reject
-     * @returns {undefined}
-     */
-    function executor(resolve, reject) {
-      const realFile = vfile(file);
-      transformers.run(tree, realFile, realDone);
-
-      /**
-       * @param {Error | undefined} error
-       * @param {Node} outputTree
-       * @param {VFile} file
-       * @returns {undefined}
-       */
-      function realDone(error, outputTree, file) {
-        const resultingTree = /** @type {TailTree extends undefined ? Node : TailTree} */
-        outputTree || tree;
-        if (error) {
-          reject(error);
-        } else if (resolve) {
-          resolve(resultingTree);
-        } else {
-          done(undefined, resultingTree, file);
-        }
-      }
-    }
-  }
-
-  /**
-   * Run *transformers* on a syntax tree.
-   *
-   * An error is thrown if asynchronous transforms are configured.
-   *
-   * > **Note**: `runSync` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `runSync` performs the run phase, not other phases.
-   *
-   * @param {HeadTree extends undefined ? Node : HeadTree} tree
-   *   Tree to transform and inspect.
-   * @param {Compatible | undefined} [file]
-   *   File associated with `node` (optional); any value accepted as `x` in
-   *   `new VFile(x)`.
-   * @returns {TailTree extends undefined ? Node : TailTree}
-   *   Transformed tree.
-   */
-  runSync(tree, file) {
-    /** @type {boolean} */
-    let complete = false;
-    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */
-    let result;
-    this.run(tree, file, realDone);
-    assertDone('runSync', 'run', complete);
-    return result;
-
-    /**
-     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}
-     */
-    function realDone(error, tree) {
-      bail(error);
-      result = tree;
-      complete = true;
-    }
-  }
-
-  /**
-   * Compile a syntax tree.
-   *
-   * > **Note**: `stringify` freezes the processor if not already *frozen*.
-   *
-   * > **Note**: `stringify` performs the stringify phase, not the run phase
-   * > or other phases.
-   *
-   * @param {CompileTree extends undefined ? Node : CompileTree} tree
-   *   Tree to compile.
-   * @param {Compatible | undefined} [file]
-   *   File associated with `node` (optional); any value accepted as `x` in
-   *   `new VFile(x)`.
-   * @returns {CompileResult extends undefined ? Value : CompileResult}
-   *   Textual representation of the tree (see note).
-   *
-   *   > **Note**: unified typically compiles by serializing: most compilers
-   *   > return `string` (or `Uint8Array`).
-   *   > Some compilers, such as the one configured with
-   *   > [`rehype-react`][rehype-react], return other values (in this case, a
-   *   > React tree).
-   *   > If you’re using a compiler that doesn’t serialize, expect different
-   *   > result values.
-   *   >
-   *   > To register custom results in TypeScript, add them to
-   *   > {@linkcode CompileResultMap}.
-   *
-   *   [rehype-react]: https://github.com/rehypejs/rehype-react
-   */
-  stringify(tree, file) {
-    this.freeze();
-    const realFile = vfile(file);
-    const compiler = this.compiler || this.Compiler;
-    assertCompiler('stringify', compiler);
-    assertNode(tree);
-    return compiler(tree, realFile);
-  }
-
-  /**
-   * Configure the processor to use a plugin, a list of usable values, or a
-   * preset.
-   *
-   * If the processor is already using a plugin, the previous plugin
-   * configuration is changed based on the options that are passed in.
-   * In other words, the plugin is not added a second time.
-   *
-   * > **Note**: `use` cannot be called on *frozen* processors.
-   * > Call the processor first to create a new unfrozen processor.
-   *
-   * @example
-   *   There are many ways to pass plugins to `.use()`.
-   *   This example gives an overview:
-   *
-   *   ```js
-   *   import {unified} from 'unified'
-   *
-   *   unified()
-   *     // Plugin with options:
-   *     .use(pluginA, {x: true, y: true})
-   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):
-   *     .use(pluginA, {y: false, z: true})
-   *     // Plugins:
-   *     .use([pluginB, pluginC])
-   *     // Two plugins, the second with options:
-   *     .use([pluginD, [pluginE, {}]])
-   *     // Preset with plugins and settings:
-   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})
-   *     // Settings only:
-   *     .use({settings: {position: false}})
-   *   ```
-   *
-   * @template {Array<unknown>} [Parameters=[]]
-   * @template {Node | string | undefined} [Input=undefined]
-   * @template [Output=Input]
-   *
-   * @overload
-   * @param {Preset | null | undefined} [preset]
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *
-   * @overload
-   * @param {PluggableList} list
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *
-   * @overload
-   * @param {Plugin<Parameters, Input, Output>} plugin
-   * @param {...(Parameters | [boolean])} parameters
-   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}
-   *
-   * @param {PluggableList | Plugin | Preset | null | undefined} value
-   *   Usable value.
-   * @param {...unknown} parameters
-   *   Parameters, when a plugin is given as a usable value.
-   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}
-   *   Current processor.
-   */
-  use(value, ...parameters) {
-    const attachers = this.attachers;
-    const namespace = this.namespace;
-    assertUnfrozen('use', this.frozen);
-    if (value === null || value === undefined) ; else if (typeof value === 'function') {
-      addPlugin(value, parameters);
-    } else if (typeof value === 'object') {
-      if (Array.isArray(value)) {
-        addList(value);
-      } else {
-        addPreset(value);
-      }
-    } else {
-      throw new TypeError('Expected usable value, not `' + value + '`');
-    }
-    return this;
-
-    /**
-     * @param {Pluggable} value
-     * @returns {undefined}
-     */
-    function add(value) {
-      if (typeof value === 'function') {
-        addPlugin(value, []);
-      } else if (typeof value === 'object') {
-        if (Array.isArray(value)) {
-          const [plugin, ...parameters] = /** @type {PluginTuple<Array<unknown>>} */value;
-          addPlugin(plugin, parameters);
-        } else {
-          addPreset(value);
-        }
-      } else {
-        throw new TypeError('Expected usable value, not `' + value + '`');
-      }
-    }
-
-    /**
-     * @param {Preset} result
-     * @returns {undefined}
-     */
-    function addPreset(result) {
-      if (!('plugins' in result) && !('settings' in result)) {
-        throw new Error('Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither');
-      }
-      addList(result.plugins);
-      if (result.settings) {
-        namespace.settings = extend(true, namespace.settings, result.settings);
-      }
-    }
-
-    /**
-     * @param {PluggableList | null | undefined} plugins
-     * @returns {undefined}
-     */
-    function addList(plugins) {
-      let index = -1;
-      if (plugins === null || plugins === undefined) ; else if (Array.isArray(plugins)) {
-        while (++index < plugins.length) {
-          const thing = plugins[index];
-          add(thing);
-        }
-      } else {
-        throw new TypeError('Expected a list of plugins, not `' + plugins + '`');
-      }
-    }
-
-    /**
-     * @param {Plugin} plugin
-     * @param {Array<unknown>} parameters
-     * @returns {undefined}
-     */
-    function addPlugin(plugin, parameters) {
-      let index = -1;
-      let entryIndex = -1;
-      while (++index < attachers.length) {
-        if (attachers[index][0] === plugin) {
-          entryIndex = index;
-          break;
-        }
-      }
-      if (entryIndex === -1) {
-        attachers.push([plugin, ...parameters]);
-      }
-      // Only set if there was at least a `primary` value, otherwise we’d change
-      // `arguments.length`.
-      else if (parameters.length > 0) {
-        let [primary, ...rest] = parameters;
-        const currentPrimary = attachers[entryIndex][1];
-        if (isPlainObject(currentPrimary) && isPlainObject(primary)) {
-          primary = extend(true, currentPrimary, primary);
-        }
-        attachers[entryIndex] = [plugin, primary, ...rest];
-      }
-    }
-  }
-}
-
-// Note: this returns a *callable* instance.
-// That’s why it’s documented as a function.
-/**
- * Create a new processor.
- *
- * @example
- *   This example shows how a new processor can be created (from `remark`) and linked
- *   to **stdin**(4) and **stdout**(4).
- *
- *   ```js
- *   import process from 'node:process'
- *   import concatStream from 'concat-stream'
- *   import {remark} from 'remark'
- *
- *   process.stdin.pipe(
- *     concatStream(function (buf) {
- *       process.stdout.write(String(remark().processSync(buf)))
- *     })
- *   )
- *   ```
- *
- * @returns
- *   New *unfrozen* processor (`processor`).
- *
- *   This processor is configured to work the same as its ancestor.
- *   When the descendant processor is configured in the future it does not
- *   affect the ancestral processor.
- */
-const unified = new Processor().freeze();
-
-/**
- * Assert a parser is available.
- *
- * @param {string} name
- * @param {unknown} value
- * @returns {asserts value is Parser}
- */
-function assertParser(name, value) {
-  if (typeof value !== 'function') {
-    throw new TypeError('Cannot `' + name + '` without `parser`');
-  }
-}
-
-/**
- * Assert a compiler is available.
- *
- * @param {string} name
- * @param {unknown} value
- * @returns {asserts value is Compiler}
- */
-function assertCompiler(name, value) {
-  if (typeof value !== 'function') {
-    throw new TypeError('Cannot `' + name + '` without `compiler`');
-  }
-}
-
-/**
- * Assert the processor is not frozen.
- *
- * @param {string} name
- * @param {unknown} frozen
- * @returns {asserts frozen is false}
- */
-function assertUnfrozen(name, frozen) {
-  if (frozen) {
-    throw new Error('Cannot call `' + name + '` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.');
-  }
-}
-
-/**
- * Assert `node` is a unist node.
- *
- * @param {unknown} node
- * @returns {asserts node is Node}
- */
-function assertNode(node) {
-  // `isPlainObj` unfortunately uses `any` instead of `unknown`.
-  // type-coverage:ignore-next-line
-  if (!isPlainObject(node) || typeof node.type !== 'string') {
-    throw new TypeError('Expected node, got `' + node + '`');
-    // Fine.
-  }
-}
-
-/**
- * Assert that `complete` is `true`.
- *
- * @param {string} name
- * @param {string} asyncName
- * @param {unknown} complete
- * @returns {asserts complete is true}
- */
-function assertDone(name, asyncName, complete) {
-  if (!complete) {
-    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');
-  }
-}
-
-/**
- * @param {Compatible | undefined} [value]
- * @returns {VFile}
- */
-function vfile(value) {
-  return looksLikeAVFile(value) ? value : new VFile(value);
-}
-
-/**
- * @param {Compatible | undefined} [value]
- * @returns {value is VFile}
- */
-function looksLikeAVFile(value) {
-  return Boolean(value && typeof value === 'object' && 'message' in value && 'messages' in value);
-}
-
-/**
- * @param {unknown} [value]
- * @returns {value is Value}
- */
-function looksLikeAValue(value) {
-  return typeof value === 'string' || isUint8Array(value);
-}
-
-/**
- * Assert `value` is an `Uint8Array`.
- *
- * @param {unknown} value
- *   thing.
- * @returns {value is Uint8Array}
- *   Whether `value` is an `Uint8Array`.
- */
-function isUint8Array(value) {
-  return Boolean(value && typeof value === 'object' && 'byteLength' in value && 'byteOffset' in value);
-}
-
-export { unified };
-//# sourceMappingURL=index-DMSCybEq.js.map