rich_harris

conduitry

code-red

		"build": "tsc && esbuild --bundle --external:acorn --external:estree-walker --external:is-reference --external:periscopic --external:sourcemap-codec --format=cjs --outfile=dist/code-red.cjs src/index.js",

		"prepublishOnly": "npm test && npm run build",

		"repl": "node -e \"const { x, b, print } = require('./dist/code-red.cjs')\" -i"

import { get_comment_handlers } from './utils/comments.js';

/** @typedef {import('estree').Expression} Expression */

/** @typedef {import('estree').Node} Node */

/** @typedef {import('estree').ObjectExpression} ObjectExpression */

/** @typedef {import('estree').Property} Property */

/** @typedef {import('estree').SpreadElement} SpreadElement */

/** @typedef {import('./utils/comments').CommentWithLocation} CommentWithLocation */

/** @param {TemplateStringsArray} strings */

	for (let i = 1; i < strings.length; i += 1) {

		str += `_${id}_${i - 1}_${strings[i]}`;

		(_m, sigil, name) => `_${id}_${sigils[sigil]}_${name}`

const flatten_body = (array, target) => {

	for (let i = 0; i < array.length; i += 1) {

		if (statement.type === 'ExpressionStatement') {

			if (statement.expression === EMPTY) continue;

			if (Array.isArray(statement.expression)) {

				while (Array.isArray(node)) node = node[0];

				if (node) node.leadingComments = statement.leadingComments;

				flatten_body(statement.expression, target);

			if (/(Expression|Literal)$/.test(statement.expression.type)) {

				statement.expression.leadingComments = statement.leadingComments;

				statement.expression.trailingComments = statement.trailingComments;

const flatten_properties = (array, target) => {

		if (property.value === EMPTY) continue;

		if (property.key === property.value && Array.isArray(property.key)) {

			flatten_properties(property.key, target);

									leadingComments: node.leadingComments,

									trailingComments: node.trailingComments

							} else if (typeof value === 'number') {

						node.name = `${match[2] ? `@` : `#`}${match[4]}`;

				if (typeof node.value === 'string') {

					const new_value = /** @type {string} */ (node.value).replace(

						(m, i) => (+i in values ? values[+i] : m)

					const has_changed = new_value !== node.value;

						node.raw = `${node.raw[0]}${JSON.stringify(node.value).slice(

						)}${node.raw[node.raw.length - 1]}`;

			if (node.type === 'TemplateElement') {

				node.value.raw = /** @type {string} */ (node.value.raw).replace(

					(m, i) => (+i in values ? values[+i] : m)

			if (node.type === 'Program' || node.type === 'BlockStatement') {

				node.body = flatten_body(node.body, []);

			if (node.type === 'ObjectExpression' || node.type === 'ObjectPattern') {

				node.properties = flatten_properties(node.properties, []);

			if (node.type === 'ArrayExpression' || node.type === 'ArrayPattern') {

				node.elements = flatten(node.elements, []);

				node.type === 'FunctionExpression' ||

				node.type === 'FunctionDeclaration' ||

				node.type === 'ArrowFunctionExpression'

				node.params = flatten(node.params, []);

			if (node.type === 'CallExpression' || node.type === 'NewExpression') {

				node.arguments = flatten(node.arguments, []);

				node.type === 'ExportNamedDeclaration'

				node.specifiers = flatten(node.specifiers, []);

				node.init = node.init === EMPTY ? null : node.init;

				node.test = node.test === EMPTY ? null : node.test;

				node.update = node.update === EMPTY ? null : node.update;

			acorn.parse(str, acorn_opts(comments, str))

		ast = inject(str, ast, values, comments);

 * @returns {Expression & { start: Number, end: number }}

			/** @type {Expression & { start: Number, end: number }} */ (

				acorn.parseExpressionAt(str, 0, acorn_opts(comments, str))

		const match = /\S+/.exec(str.slice(expression.end));

			throw new Error(`Unexpected token '${match[0]}'`);

		inject(str, expression, values, comments);

		expression = /** @type {Expression & { start: Number, end: number }} */ (

			inject(str, expression, values, comments)

 * @returns {(Property | SpreadElement) & { start: Number, end: number }}

		const expression = /** @type {any} */ (

			acorn.parseExpressionAt(str, 0, acorn_opts(comments, str))

		expression = inject(str, expression, values, comments);

	str = str.replace(re, (m, i, at, hash, name) => {

	console.log(`failed to parse:\n${str}`);

export { print } from './print/index.js';

	const { onComment, enter, leave } = get_comment_handlers(comments, source);

	const ast = /** @type {any} */ (acorn.parse(source, { onComment, ...opts }));

export const parseExpressionAt = (source, index, opts) => {

		acorn.parseExpressionAt(source, index, { onComment, ...opts })

// heavily based on https://github.com/davidbonnet/astring

// released under MIT license https://github.com/davidbonnet/astring/blob/master/LICENSE

/** @typedef {import('estree').ArrowFunctionExpression} ArrowFunctionExpression */

/** @typedef {import('estree').BinaryExpression} BinaryExpression */

/** @typedef {import('estree').CallExpression} CallExpression */

/** @typedef {import('estree').Comment} Comment */

/** @typedef {import('estree').ExportSpecifier} ExportSpecifier */

/** @typedef {import('estree').FunctionDeclaration} FunctionDeclaration */

/** @typedef {import('estree').ImportDeclaration} ImportDeclaration */

/** @typedef {import('estree').ImportSpecifier} ImportSpecifier */

/** @typedef {import('estree').Literal} Literal */

/** @typedef {import('estree').LogicalExpression} LogicalExpression */

/** @typedef {import('estree').NewExpression} NewExpression */

/** @typedef {import('estree').Pattern} Pattern */

/** @typedef {import('estree').SequenceExpression} SequenceExpression */

/** @typedef {import('estree').SimpleCallExpression} SimpleCallExpression */

/** @typedef {import('estree').SwitchStatement} SwitchStatement */

/** @typedef {import('estree').VariableDeclaration} VariableDeclaration */

 *     start: { line: number; column: number; };

 *     end: { line: number; column: number; };

 * @typedef {(node: any, state: State) => Chunk[]} Handler

 *   scope: any; // TODO import from periscopic

 *   deconflicted: WeakMap<Node, Map<string, string>>;

		throw new Error(`Not implemented ${node.type}`);

		result.unshift(c(node.leadingComments.map(comment => comment.type === 'Block'

			? `/*${comment.value}*/${/** @type {any} */ (comment).has_trailing_newline ? `\n${state.indent}` : ` `}`

			: `//${comment.value}${/** @type {any} */ (comment).has_trailing_newline ? `\n${state.indent}` : ` `}`).join(``)));

		state.comments.push(node.trailingComments[0]); // there is only ever one

			node.expression.type === 'AssignmentExpression' &&

			node.expression.left.type === 'ObjectPattern'

			// is an AssignmentExpression to an ObjectPattern

			? [c('break '), ...handle(node.label, state), c(';')]

			? [c('continue '), ...handle(node.label, state), c(';')]

	SwitchStatement(/** @type {SwitchStatement} */ node, state) {

					...handle(block.test, { ...state, indent: `${state.indent}\t` }),

				chunks.push(c(`\n${state.indent}\tdefault:`))

			block.consequent.forEach(statement => {

					...handle(statement, { ...state, indent: `${state.indent}\t\t` })

			const contains_comment = node.argument.leadingComments && node.argument.leadingComments.some((/** @type import('../utils/comments.js').CommentWithLocation */ comment) => comment.has_trailing_newline);

				c(contains_comment ? 'return (' : 'return '),

					...handle(node.handler.param, state),

			chunks.push(...handle(node.handler.body, state));

			chunks.push(c(' finally '), ...handle(node.finalizer, state));

			if (node.init.type === 'VariableDeclaration') {

				chunks.push(...handle_var_declaration(node.init, state));

				chunks.push(...handle(node.init, state));

		if (node.test) chunks.push(...handle(node.test, state));

		if (node.update) chunks.push(...handle(node.update, state));

	ForInStatement: scoped((node, state) => {

			c(`for ${node.await ? 'await ' : ''}(`)

		if (node.left.type === 'VariableDeclaration') {

			chunks.push(...handle_var_declaration(node.left, state));

			chunks.push(...handle(node.left, state));

			c(node.type === 'ForInStatement' ? ` in ` : ` of `),

		{
		"name": "code-red",
		"description": "code-red",
		"version": "0.2.2",
		"version": "0.2.3",
		"repository": "Rich-Harris/code-red",
		@@ -6,0 +6,0 @@ "main": "dist/code-red.cjs",

		@@ -384,3 +384,3 @@ // heavily based on https://github.com/davidbonnet/astring
		EmptyStatement(node, state) {
		return [];
		return [c(';')];
		},
		@@ -491,6 +491,7 @@
		if (node.argument) {
		const contains_comment = node.argument.leadingComments && node.argument.leadingComments.some((/** @type import('../utils/comments.js').CommentWithLocation */ comment) => comment.has_trailing_newline);
		return [
		c('return '),
		c(contains_comment ? 'return (' : 'return '),
		...handle(node.argument, state),
		c(';')
		c(contains_comment ? ');' : ';')
		];
		@@ -497,0 +498,0 @@ } else {

Improved metrics

Worsened metrics

		@@ -154,3 +154,3 @@ import * as acorn from 'acorn';

		walk(node, {
		return walk(node, {
		enter,
		@@ -257,3 +257,2 @@

		// @ts-ignore
		leave(node);
		@@ -277,7 +276,7 @@ }
		try {
		const ast = /** @type {any} */ (
		let ast = /** @type {any} */ (
		acorn.parse(str, acorn_opts(comments, str))
		);

		inject(str, ast, values, comments);
		ast = inject(str, ast, values, comments);

		@@ -303,3 +302,3 @@ return ast.body;
		try {
		const expression =
		let expression =
		/** @type {Expression & { start: Number, end: number }} */ (
		@@ -313,3 +312,5 @@ acorn.parseExpressionAt(str, 0, acorn_opts(comments, str))

		inject(str, expression, values, comments);
		expression = /** @type {Expression & { start: Number, end: number }} */ (
		inject(str, expression, values, comments)
		);

		@@ -335,7 +336,7 @@ return expression;
		try {
		const expression = /** @type {any} */ (
		let expression = /** @type {any} */ (
		acorn.parseExpressionAt(str, 0, acorn_opts(comments, str))
		);

		inject(str, expression, values, comments);
		expression = inject(str, expression, values, comments);

		@@ -342,0 +343,0 @@ return expression.properties[0];