up n_m

node_modules/estree-util-to-js/index.d.ts

@@ -0,0 +1,7 @@
+export { toJs } from "./lib/index.js";
+export { jsx } from "./lib/jsx.js";
+export type Handler = import('./lib/index.js').Handler;
+export type Handlers = import('./lib/index.js').Handlers;
+export type Options = import('./lib/index.js').Options;
+export type Result = import('./lib/index.js').Result;
+export type State = import('./lib/index.js').State;

node_modules/estree-util-to-js/index.js

@@ -0,0 +1,10 @@
+/**
+ * @typedef {import('./lib/index.js').Handler} Handler
+ * @typedef {import('./lib/index.js').Handlers} Handlers
+ * @typedef {import('./lib/index.js').Options} Options
+ * @typedef {import('./lib/index.js').Result} Result
+ * @typedef {import('./lib/index.js').State} State
+ */
+
+export {toJs} from './lib/index.js'
+export {jsx} from './lib/jsx.js'

node_modules/estree-util-to-js/lib/index.d.ts

@@ -0,0 +1,133 @@
+export function toJs(tree: Program, options: OptionsWithSourceMapGenerator): ResultWithSourceMapGenerator;
+export function toJs(tree: Program, options: OptionsWithMaybeMapGenerator): ResultWithMaybeSourceMapGenerator;
+export function toJs(tree: Program, options?: OptionsWithoutSourceMapGenerator | null | undefined): ResultWithoutSourceMapGenerator;
+export type State = import('astring').State;
+export type Nodes = import('estree-jsx').Node;
+export type Program = import('estree-jsx').Program;
+export type SourceMapGenerator = typeof import('source-map').SourceMapGenerator;
+export type Map = import('source-map').RawSourceMap;
+export type Generator = Record<Nodes['type'], Handler>;
+/**
+ * Handle a particular node.
+ */
+export type Handler = (this: Generator, node: any, state: State) => undefined;
+export type Handlers = Partial<import('astring').Generator>;
+/**
+ * Configuration.
+ */
+export type Options = OptionsWithMaybeMapGenerator;
+/**
+ * Base shared option fields.
+ */
+export type OptionsFieldsBase = {
+    /**
+     * Object mapping node types to functions handling the corresponding nodes.
+     */
+    handlers?: Handlers | null | undefined;
+};
+/**
+ * Extra option fields where there’s definitely no source map generator.
+ */
+export type OptionsFieldsWithoutSourceMapGenerator = {
+    /**
+     * Generate a source map by passing a `SourceMapGenerator` from `source-map`
+     * in; this works if there is positional info on nodes.
+     */
+    SourceMapGenerator?: null | undefined;
+    /**
+     * Path to input file; only used in source map.
+     */
+    filePath?: null | undefined;
+};
+/**
+ * Extra option fields where there’s definitely a source map generator.
+ */
+export type OptionsFieldsWithSourceMapGenerator = {
+    /**
+     *   Generate a source map by passing a `SourceMapGenerator` from `source-map`
+     *   in; this works if there is positional info on nodes.
+     */
+    SourceMapGenerator: SourceMapGenerator;
+    /**
+     * Path to input file; only used in source map.
+     */
+    filePath?: string | null | undefined;
+};
+/**
+ * Extra option fields where there may or may not be a source map generator.
+ */
+export type OptionsFieldsMaybeSourceMapGenerator = {
+    /**
+     * Generate a source map by passing a `SourceMapGenerator` from `source-map`
+     * in; this works if there is positional info on nodes.
+     */
+    SourceMapGenerator?: SourceMapGenerator | null | undefined;
+    /**
+     * Path to input file; only used in source map.
+     */
+    filePath?: string | null | undefined;
+};
+/**
+ * Options where there’s definitely no source map generator.
+ */
+export type OptionsWithoutSourceMapGenerator = OptionsFieldsBase & OptionsFieldsWithoutSourceMapGenerator;
+/**
+ * Options where there’s definitely a source map generator.
+ */
+export type OptionsWithSourceMapGenerator = OptionsFieldsBase & OptionsFieldsWithSourceMapGenerator;
+/**
+ * Options where there may or may not be a source map generator.
+ */
+export type OptionsWithMaybeMapGenerator = OptionsFieldsBase & OptionsFieldsMaybeSourceMapGenerator;
+/**
+ * Result.
+ */
+export type Result = ResultWithMaybeSourceMapGenerator;
+/**
+ * Base shared result fields.
+ */
+export type ResultFieldsBase = {
+    /**
+     *   Serialized JavaScript.
+     */
+    value: string;
+};
+/**
+ * Extra result fields where there’s definitely no source map generator.
+ */
+export type ResultFieldsWithoutSourceMapGenerator = {
+    /**
+     *   Source map as (parsed) JSON, if `SourceMapGenerator` is passed.
+     */
+    map: undefined;
+};
+/**
+ * Extra result fields where there’s definitely a source map generator.
+ */
+export type ResultFieldsWithSourceMapGenerator = {
+    /**
+     *   Source map as (parsed) JSON, if `SourceMapGenerator` is not passed.
+     */
+    map: Map;
+};
+/**
+ * Extra result fields where there may or may not be a source map generator.
+ */
+export type ResultFieldsMaybeSourceMapGenerator = {
+    /**
+     *   Source map as (parsed) JSON, if `SourceMapGenerator` might be passed.
+     */
+    map: Map | undefined;
+};
+/**
+ * Result where there’s definitely no source map generator.
+ */
+export type ResultWithoutSourceMapGenerator = ResultFieldsBase & ResultFieldsWithoutSourceMapGenerator;
+/**
+ * Result where there’s definitely a source map generator.
+ */
+export type ResultWithSourceMapGenerator = ResultFieldsBase & ResultFieldsWithSourceMapGenerator;
+/**
+ * Result where there may or may not be a source map generator.
+ */
+export type ResultWithMaybeSourceMapGenerator = ResultFieldsBase & ResultFieldsMaybeSourceMapGenerator;

node_modules/estree-util-to-js/lib/index.js

@@ -0,0 +1,145 @@
+/**
+ * @typedef {import('astring').State} State
+ * @typedef {import('estree-jsx').Node} Nodes
+ * @typedef {import('estree-jsx').Program} Program
+ * @typedef {typeof import('source-map').SourceMapGenerator} SourceMapGenerator
+ * @typedef {import('source-map').RawSourceMap} Map
+ */
+
+/**
+ * @typedef {Record<Nodes['type'], Handler>} Generator
+ *
+ * @callback Handler
+ *  Handle a particular node.
+ * @param {Generator} this
+ *   `astring` generator.
+ * @param {any} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @typedef {Partial<import('astring').Generator>} Handlers
+ */
+
+/**
+ * @typedef {OptionsWithMaybeMapGenerator} Options
+ *   Configuration.
+ *
+ * @typedef OptionsFieldsBase
+ *   Base shared option fields.
+ * @property {Handlers | null | undefined} [handlers]
+ *   Object mapping node types to functions handling the corresponding nodes.
+ *
+ * @typedef OptionsFieldsWithoutSourceMapGenerator
+ *   Extra option fields where there’s definitely no source map generator.
+ * @property {null | undefined} [SourceMapGenerator]
+ *   Generate a source map by passing a `SourceMapGenerator` from `source-map`
+ *   in; this works if there is positional info on nodes.
+ * @property {null | undefined} [filePath]
+ *   Path to input file; only used in source map.
+ *
+ * @typedef OptionsFieldsWithSourceMapGenerator
+ *   Extra option fields where there’s definitely a source map generator.
+ * @property {SourceMapGenerator} SourceMapGenerator
+ *   Generate a source map by passing a `SourceMapGenerator` from `source-map`
+ *   in; this works if there is positional info on nodes.
+ * @property {string | null | undefined} [filePath]
+ *   Path to input file; only used in source map.
+ *
+ * @typedef OptionsFieldsMaybeSourceMapGenerator
+ *   Extra option fields where there may or may not be a source map generator.
+ * @property {SourceMapGenerator | null | undefined} [SourceMapGenerator]
+ *   Generate a source map by passing a `SourceMapGenerator` from `source-map`
+ *   in; this works if there is positional info on nodes.
+ * @property {string | null | undefined} [filePath]
+ *   Path to input file; only used in source map.
+ *
+ * @typedef {OptionsFieldsBase & OptionsFieldsWithoutSourceMapGenerator} OptionsWithoutSourceMapGenerator
+ *   Options where there’s definitely no source map generator.
+ * @typedef {OptionsFieldsBase & OptionsFieldsWithSourceMapGenerator} OptionsWithSourceMapGenerator
+ *   Options where there’s definitely a source map generator.
+ * @typedef {OptionsFieldsBase & OptionsFieldsMaybeSourceMapGenerator} OptionsWithMaybeMapGenerator
+ *   Options where there may or may not be a source map generator.
+ *
+ * @typedef {ResultWithMaybeSourceMapGenerator} Result
+ *   Result.
+ *
+ * @typedef ResultFieldsBase
+ *   Base shared result fields.
+ * @property {string} value
+ *   Serialized JavaScript.
+ *
+ * @typedef ResultFieldsWithoutSourceMapGenerator
+ *   Extra result fields where there’s definitely no source map generator.
+ * @property {undefined} map
+ *   Source map as (parsed) JSON, if `SourceMapGenerator` is passed.
+ *
+ * @typedef ResultFieldsWithSourceMapGenerator
+ *   Extra result fields where there’s definitely a source map generator.
+ * @property {Map} map
+ *   Source map as (parsed) JSON, if `SourceMapGenerator` is not passed.
+ *
+ * @typedef ResultFieldsMaybeSourceMapGenerator
+ *   Extra result fields where there may or may not be a source map generator.
+ * @property {Map | undefined} map
+ *   Source map as (parsed) JSON, if `SourceMapGenerator` might be passed.
+ *
+ * @typedef {ResultFieldsBase & ResultFieldsWithoutSourceMapGenerator} ResultWithoutSourceMapGenerator
+ *   Result where there’s definitely no source map generator.
+ * @typedef {ResultFieldsBase & ResultFieldsWithSourceMapGenerator} ResultWithSourceMapGenerator
+ *   Result where there’s definitely a source map generator.
+ * @typedef {ResultFieldsBase & ResultFieldsMaybeSourceMapGenerator} ResultWithMaybeSourceMapGenerator
+ *   Result where there may or may not be a source map generator.
+ */
+
+import {GENERATOR, generate} from 'astring'
+
+/** @type {Options} */
+const emptyOptions = {}
+
+/**
+ * Serialize an estree as JavaScript.
+ *
+ * @overload
+ * @param {Program} tree
+ * @param {OptionsWithSourceMapGenerator} options
+ * @returns {ResultWithSourceMapGenerator}
+ *
+ * @overload
+ * @param {Program} tree
+ * @param {OptionsWithMaybeMapGenerator} options
+ * @returns {ResultWithMaybeSourceMapGenerator}
+ *
+ * @overload
+ * @param {Program} tree
+ * @param {OptionsWithoutSourceMapGenerator | null | undefined} [options]
+ * @returns {ResultWithoutSourceMapGenerator}
+ *
+ * @param {Program} tree
+ *   Estree (esast).
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {Result}
+ *   Result, optionally with source map.
+ */
+export function toJs(tree, options) {
+  const {SourceMapGenerator, filePath, handlers} = options || emptyOptions
+  const sourceMap = SourceMapGenerator
+    ? new SourceMapGenerator({file: filePath || '<unknown>.js'})
+    : undefined
+
+  const value = generate(
+    tree,
+    // @ts-expect-error: `sourceMap` can be undefined, `astring` types are buggy.
+    {
+      comments: true,
+      generator: {...GENERATOR, ...handlers},
+      sourceMap: sourceMap || undefined
+    }
+  )
+  const map = sourceMap ? sourceMap.toJSON() : undefined
+
+  return {value, map}
+}

node_modules/estree-util-to-js/lib/jsx.d.ts

@@ -0,0 +1,213 @@
+export namespace jsx {
+    export { jsxAttribute as JSXAttribute };
+    export { jsxClosingElement as JSXClosingElement };
+    export { jsxClosingFragment as JSXClosingFragment };
+    export { jsxElement as JSXElement };
+    export { jsxEmptyExpression as JSXEmptyExpression };
+    export { jsxExpressionContainer as JSXExpressionContainer };
+    export { jsxFragment as JSXFragment };
+    export { jsxIdentifier as JSXIdentifier };
+    export { jsxMemberExpression as JSXMemberExpression };
+    export { jsxNamespacedName as JSXNamespacedName };
+    export { jsxOpeningElement as JSXOpeningElement };
+    export { jsxOpeningFragment as JSXOpeningFragment };
+    export { jsxSpreadAttribute as JSXSpreadAttribute };
+    export { jsxText as JSXText };
+}
+export type JsxAttribute = import('estree-jsx').JSXAttribute;
+export type JsxClosingElement = import('estree-jsx').JSXClosingElement;
+export type JsxClosingFragment = import('estree-jsx').JSXClosingFragment;
+export type JsxElement = import('estree-jsx').JSXElement;
+export type JsxExpressionContainer = import('estree-jsx').JSXExpressionContainer;
+export type JsxFragment = import('estree-jsx').JSXFragment;
+export type JsxIdentifier = import('estree-jsx').JSXIdentifier;
+export type JsxMemberExpression = import('estree-jsx').JSXMemberExpression;
+export type JsxNamespacedName = import('estree-jsx').JSXNamespacedName;
+export type JsxOpeningElement = import('estree-jsx').JSXOpeningElement;
+export type JsxOpeningFragment = import('estree-jsx').JSXOpeningFragment;
+export type JsxSpreadAttribute = import('estree-jsx').JSXSpreadAttribute;
+export type JsxText = import('estree-jsx').JSXText;
+export type Generator = import('./index.js').Generator;
+export type State = import('./index.js').State;
+/**
+ * `attr`
+ * `attr="something"`
+ * `attr={1}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxAttribute} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxAttribute(this: import("./index.js").Generator, node: JsxAttribute, state: State): undefined;
+/**
+ * `</div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxClosingElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxClosingElement(this: import("./index.js").Generator, node: JsxClosingElement, state: State): undefined;
+/**
+ * `</>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxClosingFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxClosingFragment(this: import("./index.js").Generator, node: JsxClosingFragment, state: State): undefined;
+/**
+ * `<div />`
+ * `<div></div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxElement(this: import("./index.js").Generator, node: JsxElement, state: State): undefined;
+/**
+ * `{}` (always in a `JSXExpressionContainer`, which does the curlies)
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxEmptyExpression(this: import("./index.js").Generator): undefined;
+/**
+ * `{expression}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxExpressionContainer} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxExpressionContainer(this: import("./index.js").Generator, node: JsxExpressionContainer, state: State): undefined;
+/**
+ * `<></>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxFragment(this: import("./index.js").Generator, node: JsxFragment, state: State): undefined;
+/**
+ * `div`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxIdentifier} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxIdentifier(this: import("./index.js").Generator, node: JsxIdentifier, state: State): undefined;
+/**
+ * `member.expression`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxMemberExpression} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxMemberExpression(this: import("./index.js").Generator, node: JsxMemberExpression, state: State): undefined;
+/**
+ * `ns:name`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxNamespacedName} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxNamespacedName(this: import("./index.js").Generator, node: JsxNamespacedName, state: State): undefined;
+/**
+ * `<div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxOpeningElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxOpeningElement(this: import("./index.js").Generator, node: JsxOpeningElement, state: State): undefined;
+/**
+ * `<>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxOpeningFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxOpeningFragment(this: import("./index.js").Generator, node: JsxOpeningFragment, state: State): undefined;
+/**
+ * `{...argument}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxSpreadAttribute} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxSpreadAttribute(this: import("./index.js").Generator, node: JsxSpreadAttribute, state: State): undefined;
+/**
+ * `!`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxText} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+declare function jsxText(this: import("./index.js").Generator, node: JsxText, state: State): undefined;
+export {};

node_modules/estree-util-to-js/lib/jsx.js

@@ -0,0 +1,364 @@
+/**
+ * @typedef {import('estree-jsx').JSXAttribute} JsxAttribute
+ * @typedef {import('estree-jsx').JSXClosingElement} JsxClosingElement
+ * @typedef {import('estree-jsx').JSXClosingFragment} JsxClosingFragment
+ * @typedef {import('estree-jsx').JSXElement} JsxElement
+ * @typedef {import('estree-jsx').JSXExpressionContainer} JsxExpressionContainer
+ * @typedef {import('estree-jsx').JSXFragment} JsxFragment
+ * @typedef {import('estree-jsx').JSXIdentifier} JsxIdentifier
+ * @typedef {import('estree-jsx').JSXMemberExpression} JsxMemberExpression
+ * @typedef {import('estree-jsx').JSXNamespacedName} JsxNamespacedName
+ * @typedef {import('estree-jsx').JSXOpeningElement} JsxOpeningElement
+ * @typedef {import('estree-jsx').JSXOpeningFragment} JsxOpeningFragment
+ * @typedef {import('estree-jsx').JSXSpreadAttribute} JsxSpreadAttribute
+ * @typedef {import('estree-jsx').JSXText} JsxText
+ *
+ * @typedef {import('./index.js').Generator} Generator
+ * @typedef {import('./index.js').State} State
+ */
+
+export const jsx = {
+  JSXAttribute: jsxAttribute,
+  JSXClosingElement: jsxClosingElement,
+  JSXClosingFragment: jsxClosingFragment,
+  JSXElement: jsxElement,
+  JSXEmptyExpression: jsxEmptyExpression,
+  JSXExpressionContainer: jsxExpressionContainer,
+  JSXFragment: jsxFragment,
+  JSXIdentifier: jsxIdentifier,
+  JSXMemberExpression: jsxMemberExpression,
+  JSXNamespacedName: jsxNamespacedName,
+  JSXOpeningElement: jsxOpeningElement,
+  JSXOpeningFragment: jsxOpeningFragment,
+  JSXSpreadAttribute: jsxSpreadAttribute,
+  JSXText: jsxText
+}
+
+/**
+ * `attr`
+ * `attr="something"`
+ * `attr={1}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxAttribute} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxAttribute(node, state) {
+  this[node.name.type](node.name, state)
+
+  if (node.value !== null && node.value !== undefined) {
+    state.write('=')
+
+    // Encode double quotes in attribute values.
+    if (node.value.type === 'Literal') {
+      state.write(
+        '"' + encodeJsx(String(node.value.value)).replace(/"/g, '"') + '"',
+        node
+      )
+    } else {
+      this[node.value.type](node.value, state)
+    }
+  }
+}
+
+/**
+ * `</div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxClosingElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxClosingElement(node, state) {
+  state.write('</')
+  this[node.name.type](node.name, state)
+  state.write('>')
+}
+
+/**
+ * `</>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxClosingFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxClosingFragment(node, state) {
+  state.write('</>', node)
+}
+
+/**
+ * `<div />`
+ * `<div></div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxElement(node, state) {
+  let index = -1
+
+  this[node.openingElement.type](node.openingElement, state)
+
+  if (node.children) {
+    while (++index < node.children.length) {
+      const child = node.children[index]
+
+      // Supported in types but not by Acorn.
+      /* c8 ignore next 3 */
+      if (child.type === 'JSXSpreadChild') {
+        throw new Error('JSX spread children are not supported')
+      }
+
+      this[child.type](child, state)
+    }
+  }
+
+  if (node.closingElement) {
+    this[node.closingElement.type](node.closingElement, state)
+  }
+}
+
+/**
+ * `{}` (always in a `JSXExpressionContainer`, which does the curlies)
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxEmptyExpression() {}
+
+/**
+ * `{expression}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxExpressionContainer} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxExpressionContainer(node, state) {
+  state.write('{')
+  this[node.expression.type](node.expression, state)
+  state.write('}')
+}
+
+/**
+ * `<></>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxFragment(node, state) {
+  let index = -1
+
+  this[node.openingFragment.type](node.openingFragment, state)
+
+  if (node.children) {
+    while (++index < node.children.length) {
+      const child = node.children[index]
+
+      // Supported in types but not by Acorn.
+      /* c8 ignore next 3 */
+      if (child.type === 'JSXSpreadChild') {
+        throw new Error('JSX spread children are not supported')
+      }
+
+      this[child.type](child, state)
+    }
+  }
+
+  this[node.closingFragment.type](node.closingFragment, state)
+}
+
+/**
+ * `div`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxIdentifier} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxIdentifier(node, state) {
+  state.write(node.name, node)
+}
+
+/**
+ * `member.expression`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxMemberExpression} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxMemberExpression(node, state) {
+  this[node.object.type](node.object, state)
+  state.write('.')
+  this[node.property.type](node.property, state)
+}
+
+/**
+ * `ns:name`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxNamespacedName} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxNamespacedName(node, state) {
+  this[node.namespace.type](node.namespace, state)
+  state.write(':')
+  this[node.name.type](node.name, state)
+}
+
+/**
+ * `<div>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxOpeningElement} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxOpeningElement(node, state) {
+  let index = -1
+
+  state.write('<')
+  this[node.name.type](node.name, state)
+
+  if (node.attributes) {
+    while (++index < node.attributes.length) {
+      state.write(' ')
+      this[node.attributes[index].type](node.attributes[index], state)
+    }
+  }
+
+  state.write(node.selfClosing ? ' />' : '>')
+}
+
+/**
+ * `<>`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxOpeningFragment} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxOpeningFragment(node, state) {
+  state.write('<>', node)
+}
+
+/**
+ * `{...argument}`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxSpreadAttribute} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxSpreadAttribute(node, state) {
+  state.write('{')
+  // eslint-disable-next-line new-cap
+  this.SpreadElement(node, state)
+  state.write('}')
+}
+
+/**
+ * `!`
+ *
+ * @this {Generator}
+ *   `astring` generator.
+ * @param {JsxText} node
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function jsxText(node, state) {
+  state.write(encodeJsx(node.value).replace(/[<>{}]/g, replaceJsxChar), node)
+}
+
+/**
+ * Make sure that character references don’t pop up.
+ *
+ * For example, the text `&copy;` should stay that way, and not turn into `©`.
+ * We could encode all `&` (easy but verbose) or look for actual valid
+ * references (complex but cleanest output).
+ * Looking for the 2nd character gives us a middle ground.
+ * The `#` is for (decimal and hexadecimal) numeric references, the letters
+ * are for the named references.
+ *
+ * @param {string} value
+ *   Value to encode.
+ * @returns {string}
+ *   Encoded value.
+ */
+function encodeJsx(value) {
+  return value.replace(/&(?=[#a-z])/gi, '&amp;')
+}
+
+/**
+ * @param {string} $0
+ * @returns {string}
+ */
+function replaceJsxChar($0) {
+  return $0 === '<'
+    ? '&lt;'
+    : $0 === '>'
+    ? '&gt;'
+    : $0 === '{'
+    ? '&#123;'
+    : '&#125;'
+}

node_modules/estree-util-to-js/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2022 Titus Wormer <tituswormer@gmail.com>
+
+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.

node_modules/estree-util-to-js/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "estree-util-to-js",
+  "version": "2.0.0",
+  "description": "estree (and esast) utility to serialize to JavaScript",
+  "license": "MIT",
+  "keywords": [
+    "unist",
+    "estree",
+    "estree-util",
+    "esast",
+    "esast-util",
+    "util",
+    "utility",
+    "js",
+    "serialize",
+    "stringify",
+    "tostring",
+    "astring"
+  ],
+  "repository": "syntax-tree/estree-util-to-js",
+  "bugs": "https://github.com/syntax-tree/estree-util-to-js/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/estree-jsx": "^1.0.0",
+    "astring": "^1.8.0",
+    "source-map": "^0.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^8.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^11.0.0",
+    "remark-preset-wooorm": "^9.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.55.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "test-api": "node --conditions development test/index.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "#": "needed `any`s",
+    "ignoreFiles": [
+      "lib/index.d.ts"
+    ],
+    "strict": true
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-string-replace-all": "off"
+    }
+  }
+}

node_modules/estree-util-to-js/readme.md

@@ -0,0 +1,423 @@
+# estree-util-to-js
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+[![Sponsors][sponsors-badge]][collective]
+[![Backers][backers-badge]][collective]
+[![Chat][chat-badge]][chat]
+
+[estree][] (and [esast][]) utility to serialize estrees as JavaScript.
+
+## Contents
+
+*   [What is this?](#what-is-this)
+*   [When should I use this?](#when-should-i-use-this)
+*   [Install](#install)
+*   [Use](#use)
+*   [API](#api)
+    *   [`toJs(tree[, options])`](#tojstree-options)
+    *   [`jsx`](#jsx)
+    *   [`Handler`](#handler)
+    *   [`Handlers`](#handlers)
+    *   [`Map`](#map)
+    *   [`Options`](#options)
+    *   [`Result`](#result)
+    *   [`State`](#state)
+*   [Examples](#examples)
+    *   [Example: source maps](#example-source-maps)
+    *   [Example: comments](#example-comments)
+    *   [Example: JSX](#example-jsx)
+*   [Types](#types)
+*   [Compatibility](#compatibility)
+*   [Contribute](#contribute)
+*   [License](#license)
+
+## What is this?
+
+This package is a utility that turns an estree syntax tree into a string of
+JavaScript.
+
+## When should I use this?
+
+You can use this utility when you want to get the serialized JavaScript that is
+represented by the syntax tree, either because you’re done with the syntax tree,
+or because you’re integrating with another tool that does not support syntax
+trees.
+
+This utility is particularly useful when integrating with other unified tools,
+such as unist and vfile.
+
+The utility [`esast-util-from-js`][esast-util-from-js] does the inverse of this
+utility.
+It turns JS into esast.
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 16+), install with [npm][]:
+
+```sh
+npm install estree-util-to-js
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {toJs} from 'https://esm.sh/estree-util-to-js@2'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {toJs} from 'https://esm.sh/estree-util-to-js@2?bundle'
+</script>
+```
+
+## Use
+
+```js
+import fs from 'node:fs/promises'
+import {parse} from 'acorn'
+import {toJs} from 'estree-util-to-js'
+
+const file = String(await fs.readFile('index.js'))
+
+const tree = parse(file, {ecmaVersion: 2022, sourceType: 'module', locations: true})
+
+// @ts-expect-error: acorn is funky but it works fine.
+console.log(toJs(tree))
+```
+
+Yields:
+
+```js
+{
+  value: "export {toJs} from './lib/index.js';\nexport {jsx} from './lib/jsx.js';\n",
+  map: undefined
+}
+```
+
+## API
+
+This package exports the identifiers [`jsx`][api-jsx] and [`toJs`][api-to-js].
+There is no default export.
+
+### `toJs(tree[, options])`
+
+Serialize an estree as JavaScript.
+
+###### Parameters
+
+*   `tree` ([`Program`][program])
+    — estree
+*   `options` ([`Options`][api-options])
+    — configuration
+
+###### Returns
+
+Result, optionally with source map ([`Result`][api-result]).
+
+### `jsx`
+
+Map of handlers to handle the nodes of JSX extensions in JavaScript
+([`Handlers`][api-handlers]).
+
+### `Handler`
+
+Handle a particular node (TypeScript type).
+
+###### Parameters
+
+*   `this` (`Generator`)
+    — `astring` generator
+*   `node` ([`Node`][node])
+    — node to serialize
+*   `state` ([`State`][api-state])
+    — info passed around
+
+###### Returns
+
+Nothing (`undefined`).
+
+### `Handlers`
+
+Handlers of nodes (TypeScript type).
+
+###### Type
+
+```ts
+type Handlers = Partial<Record<Node['type'], Handler>>
+```
+
+### `Map`
+
+Raw source map from `source-map` (TypeScript type).
+
+### `Options`
+
+Configuration (TypeScript type).
+
+###### Fields
+
+*   `SourceMapGenerator` ([`SourceMapGenerator`][source-map])
+    — generate a source map with this class
+*   `filePath` (`string`)
+    — path to original input file
+*   `handlers` ([`Handlers`][api-handlers])
+    — extra handlers
+
+### `Result`
+
+Result (TypeScript type).
+
+###### Fields
+
+*   `value` (`string`)
+    — serialized JavaScript
+*   `map` ([`Map`][api-map] or `undefined`)
+    — source map as (parsed) JSON
+
+### `State`
+
+State from `astring` (TypeScript type).
+
+## Examples
+
+### Example: source maps
+
+Source maps are supported when passing the `SourceMapGenerator` class from
+[`source-map`][source-map].
+You should also pass `filePath`.
+Modified example from § Use above:
+
+```diff
+ import fs from 'node:fs/promises'
+ import {parse} from 'acorn'
++import {SourceMapGenerator} from 'source-map'
+ import {toJs} from 'estree-util-to-js'
+
+-const file = String(await fs.readFile('index.js'))
++const filePath = 'index.js'
++const file = String(await fs.readFile(filePath))
+
+ const tree = parse(file, {
+   ecmaVersion: 2022,
+@@ -11,4 +13,4 @@ const tree = parse(file, {
+ })
+
+ // @ts-expect-error: acorn is funky but it works fine.
+-console.log(toJs(tree))
++console.log(toJs(tree, {filePath, SourceMapGenerator}))
+```
+
+Yields:
+
+```js
+{
+  value: "export {toJs} from './lib/index.js';\nexport {jsx} from './lib/jsx.js';\n",
+  map: {
+    version: 3,
+    sources: [ 'index.js' ],
+    names: [],
+    mappings: 'QAOQ,WAAW;QACX,UAAU',
+    file: 'index.js'
+  }
+}
+```
+
+### Example: comments
+
+To get comments to work, they have to be inside the tree.
+This is not done by Acorn.
+[`estree-util-attach-comments`][estree-util-attach-comments] can do that.
+Modified example from § Use above:
+
+```diff
+ import fs from 'node:fs/promises'
+ import {parse} from 'acorn'
++import {attachComments} from 'estree-util-attach-comments'
+ import {toJs} from 'estree-util-to-js'
+
+ const file = String(await fs.readFile('index.js'))
+
++/** @type {Array<import('estree-jsx').Comment>} */
++const comments = []
+ const tree = parse(file, {
+   ecmaVersion: 2022,
+   sourceType: 'module',
+-  locations: true
++  locations: true,
++  // @ts-expect-error: acorn is funky these comments are fine.
++  onComment: comments
+ })
++attachComments(tree, comments)
+
+ // @ts-expect-error: acorn is funky but it works fine.
+ console.log(toJs(tree))
+```
+
+Yields:
+
+```js
+{
+  value: '/**\n' +
+    "* @typedef {import('./lib/index.js').Options} Options\n" +
+    "* @typedef {import('./lib/types.js').Handler} Handler\n" +
+    "* @typedef {import('./lib/types.js').Handlers} Handlers\n" +
+    "* @typedef {import('./lib/types.js').State} State\n" +
+    '*/\n' +
+    "export {toJs} from './lib/index.js';\n" +
+    "export {jsx} from './lib/jsx.js';\n",
+  map: undefined
+}
+```
+
+### Example: JSX
+
+To get JSX to work, handlers need to be registered.
+This is not done by default, but they are exported as `jsx` and can be passed.
+Modified example from § Use above:
+
+```diff
+ import fs from 'node:fs/promises'
+-import {parse} from 'acorn'
+-import {toJs} from 'estree-util-to-js'
++import {Parser} from 'acorn'
++import acornJsx from 'acorn-jsx'
++import {jsx, toJs} from 'estree-util-to-js'
+
+-const file = String(await fs.readFile('index.js'))
++const file = '<>{1 + 1}</>'
+
+-const tree = parse(file, {
++const tree = Parser.extend(acornJsx()).parse(file, {
+   ecmaVersion: 2022,
+   sourceType: 'module',
+   locations: true
+ })
+
+ // @ts-expect-error: acorn is funky but it works fine.
+-console.log(toJs(tree))
++console.log(toJs(tree, {handlers: jsx}))
+```
+
+Yields:
+
+```js
+{ value: '<>{1 + 1}</>;\n', map: undefined }
+```
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional types [`Handler`][api-handler],
+[`Handlers`][api-handlers],
+[`Map`][api-map],
+[`Options`][api-options],
+[`Result`][api-result], and
+[`State`][api-state].
+
+## Compatibility
+
+Projects maintained by the unified collective are compatible with maintained
+versions of Node.js.
+
+When we cut a new major release, we drop support for unmaintained versions of
+Node.
+This means we try to keep the current release line, `estree-util-to-js@^2`,
+compatible with Node.js 16.
+
+## Contribute
+
+See [`contributing.md`][contributing] in [`syntax-tree/.github`][health] for
+ways to get started.
+See [`support.md`][support] for ways to get help.
+
+This project has a [code of conduct][coc].
+By interacting with this repository, organization, or community you agree to
+abide by its terms.
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/syntax-tree/estree-util-to-js/workflows/main/badge.svg
+
+[build]: https://github.com/syntax-tree/estree-util-to-js/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/estree-util-to-js.svg
+
+[coverage]: https://codecov.io/github/syntax-tree/estree-util-to-js
+
+[downloads-badge]: https://img.shields.io/npm/dm/estree-util-to-js.svg
+
+[downloads]: https://www.npmjs.com/package/estree-util-to-js
+
+[size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=estree-util-to-js
+
+[size]: https://bundlejs.com/?q=estree-util-to-js
+
+[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg
+
+[backers-badge]: https://opencollective.com/unified/backers/badge.svg
+
+[collective]: https://opencollective.com/unified
+
+[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg
+
+[chat]: https://github.com/syntax-tree/unist/discussions
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[esmsh]: https://esm.sh
+
+[typescript]: https://www.typescriptlang.org
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[health]: https://github.com/syntax-tree/.github
+
+[contributing]: https://github.com/syntax-tree/.github/blob/main/contributing.md
+
+[support]: https://github.com/syntax-tree/.github/blob/main/support.md
+
+[coc]: https://github.com/syntax-tree/.github/blob/main/code-of-conduct.md
+
+[esast]: https://github.com/syntax-tree/esast
+
+[esast-util-from-js]: https://github.com/syntax-tree/esast-util-from-js
+
+[estree]: https://github.com/estree/estree
+
+[estree-util-attach-comments]: https://github.com/syntax-tree/estree-util-attach-comments
+
+[program]: https://github.com/estree/estree/blob/master/es2015.md#programs
+
+[node]: https://github.com/estree/estree/blob/master/es5.md#node-objects
+
+[source-map]: https://github.com/mozilla/source-map
+
+[api-jsx]: #jsx
+
+[api-to-js]: #tojstree-options
+
+[api-handler]: #handler
+
+[api-handlers]: #handlers
+
+[api-map]: #map
+
+[api-options]: #options
+
+[api-state]: #state
+
+[api-result]: #result