bare-type-stripper

Heuristic lexer for stripping TypeScript type syntax to produce plain JavaScript. Stripped regions are replaced with spaces so source positions and line numbers are preserved.

Usage

const strip = require('bare-type-stripper')

strip(`
  const x: number = 1
  function f<T>(xs: T[]): T { return xs[0] }
`).toString()

// '
//   const x         = 1
//   function f   (xs   )    { return xs[0] }
// '

API

const output = strip(source[, encoding][, options])

Strip TypeScript-only syntax from source and return plain JavaScript as a Buffer. Stripped regions are replaced with spaces (newlines preserved) so the output has the same byte length as the input, keeping stack traces and source positions aligned.

source may be a string or a Buffer. When a string, encoding selects the character encoding (defaults to 'utf8').

Throws a SyntaxError when the source contains non-erasable TypeScript syntax (see below).

Options are reserved.

const ranges = strip.lex(source[, encoding][, options])

Return the raw [start, end, flags?] ranges that strip() would erase, without applying them. The optional third element is a bitmap of flags from strip.constants that controls how a single byte in the range is rewritten (instead of being blanked to a space).

strip.lex('const x: number = 1')
// [ [ 7, 16 ] ]

strip.constants

Constant	Description
SEMI	The first byte of the range becomes ; instead of a space. Used on whole-statement strips (type, interface, declare, import type, export type/interface) and on the first stripped modifier of a class member to keep ASI from folding the preceding statement or field into what follows.
PAREN	The first byte of the range becomes ) instead of a space. Used together with a wider strip range to relocate an arrow function's closing ) down to the line where => lives, when the (now stripped) return-type annotation spanned newlines.
ERROR	The range marks non-erasable TypeScript syntax that cannot be stripped to valid JavaScript. strip() throws a SyntaxError when a lexed range carries this flag; lex() returns the range so callers can implement their own handling.

What gets stripped

Construct	Example
Type annotations	const x: number = 1
Type aliases	type Foo = number
Interfaces	interface Foo { x: number }
Type-only imports/exports	import type { Foo } from 'mod'
Generics at declarations	function f<T>(x: T): T
Generics at call sites	foo<number>()
Generic arrow functions	<T>(x: T) => x
Type assertions	x as Foo, x satisfies Foo
Non-null assertion	obj!.foo
Optional parameter marker	function f(x?: T)
Definite assignment	let x!: number
Class member modifiers	public, private, readonly, etc.
implements clauses	class C implements I
declare statements	declare const x: number
Overload signatures	function f(x: string): void
Abstract members	abstract foo(): void

What is left alone

• Decorators - they emit runtime code and are valid JavaScript syntax.

What throws

Constructs with runtime semantics that a purely lexical stripper cannot reproduce are marked with the ERROR flag, and strip() throws a SyntaxError when it meets one:

• enum / const enum declarations - they emit a runtime object.
• namespace / module declarations with bodies - they emit runtime code.
• Parameter properties - constructor(public x: number) implies a this.x = x assignment that stripping the modifier would silently lose.
• Old-style angle-bracket type assertions (<Foo>expr) - indistinguishable from JSX, which is not supported.

Limitations

The stripper targets plain .ts sources; JSX (.tsx) is not supported and is reported as non-erasable syntax.

License

Apache-2.0