typescript

filename?: string

Filename used for syntax-mode inference and diagnostics.

Extensions such as .ts, .tsx, .jsx, and .d.ts guide the parser when sourceType is omitted. The value is also carried into source-map and diagnostic metadata by the native parser.

import { parse } from 'fino:format/typescript';

parse('declare const x: string;', { filename: 'types.d.ts' });

sourceType?: 'js' | 'javascript' | 'script' | 'jsx' | 'ts' | 'typescript' | 'tsx' | 'dts' | 'definition'

Explicit source grammar. Defaults are inferred from filename when possible, falling back to TypeScript module grammar when neither is given.

Use this when parsing virtual source or when a filename extension does not match the syntax. The parser still reports diagnostics rather than throwing for syntax errors returned by OXC.

import { parse } from 'fino:format/typescript';

parse('const x: number = 1;', { sourceType: 'ts' });

tokens?: boolean

Include lexer tokens in the parse result. Defaults to false.

Tokens increase result size but are useful for formatters, linters, and source analysis that needs exact lexical spans.

import { parse } from 'fino:format/typescript';

const tokens = parse('let x = 1;', { tokens: true }).tokens;

kind: string

OXC token kind name.

The exact set of names follows the bundled OXC version and may grow as the JavaScript grammar evolves.

import { parse } from 'fino:format/typescript';

parse('const x = 1;', { tokens: true }).tokens[0]?.kind;

text: string

Source text matched by the token.

The text is not normalized, so whitespace and escape spelling remain as they appeared in the original source.

import { parse } from 'fino:format/typescript';

parse('const x = 1;', { tokens: true }).tokens[0]?.text;

start: number

Start offset of the token in the source string.

Use this with end to slice the original source. The offset is zero-based.

import { parse } from 'fino:format/typescript';

const source = 'const x = 1;';
const token = parse(source, { tokens: true }).tokens[0]!;
source.slice(token.start, token.end);

end: number

End offset of the token in the source string.

This is exclusive, matching JavaScript String.prototype.slice().

import { parse } from 'fino:format/typescript';

const token = parse('const x = 1;', { tokens: true }).tokens[0]!;
token.end - token.start;

onNewLine: boolean

Whether OXC observed a line break before this token.

This is useful for automatic-semicolon-insertion-sensitive tooling.

import { parse } from 'fino:format/typescript';

parse('a\nb', { tokens: true }).tokens.some((token) => token.onNewLine);

kind: 'line' | 'block'

Comment syntax kind.

line represents line comments and block represents block comments.

import { parse } from 'fino:format/typescript';

parse('// hi\nx').comments[0]?.kind;

text: string

Comment body text without delimiters.

The text is not HTML-escaped or otherwise sanitized.

import { parse } from 'fino:format/typescript';

parse('// hello\nx').comments[0]?.text;

start: number

Start offset of the full comment in the source string.

The offset includes the opening comment delimiter.

import { parse } from 'fino:format/typescript';

parse('// hi\nx').comments[0]?.start;

end: number

End offset of the full comment in the source string.

This is exclusive and includes the closing delimiter for block comments.

import { parse } from 'fino:format/typescript';

parse('// hi\nx').comments[0]?.end;

attachedTo: number

OXC node attachment identifier.

The value is parser metadata, not a stable public node ID. It may be 0 when no useful attachment exists.

import { parse } from 'fino:format/typescript';

parse('// doc\nconst x = 1;').comments[0]?.attachedTo;

leading: boolean

Whether the comment is considered leading for its attached node.

Leading comments appear before the associated syntax.

import { parse } from 'fino:format/typescript';

parse('// leading\nconst x = 1;').comments[0]?.leading;

trailing: boolean

Whether the comment is considered trailing for its attached node.

Trailing comments appear after nearby syntax on the same line or close region according to OXC's attachment rules.

import { parse } from 'fino:format/typescript';

parse('const x = 1; // trailing').comments[0]?.trailing;

jsdoc: boolean

Whether the comment is a JSDoc-style block comment.

This is true only for block comments that OXC recognizes as documentation comments (those opening with /**); line comments are never JSDoc.

import { parse } from 'fino:format/typescript';

const source = '/** docs *' + '/\nconst x = 1;';
parse(source).comments[0]?.jsdoc;

code?: string

Stable diagnostic code from the parser, transformer, formatter, or linter.

message: string

Human-readable diagnostic message from OXC.

The message is suitable for logs but should not be treated as a stable machine-readable code.

import { parse } from 'fino:format/typescript';

const message = parse('const =').errors[0]?.message;

severity?: 'error' | 'warning'

Diagnostic severity.

line?: number

One-based source line for the diagnostic start when available.

column?: number

One-based source column for the diagnostic start when available.

endLine?: number

One-based source line for the diagnostic end when available.

endColumn?: number

One-based source column for the diagnostic end when available.

ok: boolean

Whether OXC parsed the source without diagnostics that mark failure.

false means inspect errors. The AST may be incomplete or unsuitable for downstream transformations when parsing failed.

import { parse } from 'fino:format/typescript';

if (!parse('const =').ok) console.error('invalid source');

ast: any

Serialized ESTree-compatible AST from OXC.

The exact node shape follows the bundled OXC version. Treat this as parser output, not as a stable schema guaranteed by Fino.

import { parse } from 'fino:format/typescript';

const ast = parse('const x = 1;').ast;

comments: ParseComment[]

Comments collected from the source.

Comments are always returned as an array, empty when none were found.

import { parse } from 'fino:format/typescript';

const comments = parse('// note\nconst x = 1;').comments;

tokens: ParseToken[]

Lexer tokens collected from the source.

This array is empty unless ParseOptions.tokens is true.

import { parse } from 'fino:format/typescript';

const tokens = parse('const x = 1;', { tokens: true }).tokens;

errors: ParseDiagnostic[]

Parser diagnostics.

The array is empty on a clean parse. Diagnostics are returned rather than thrown for normal syntax errors.

import { parse } from 'fino:format/typescript';

const errors = parse('const =').errors;

sourceType: { language: 'typescript' | 'javascript'; moduleKind: 'module' | 'script' | 'unambiguous' | 'commonjs'; jsx: boolean; typescriptDefinition: boolean; }

Source mode detected or selected by OXC.

The nested object describes language, module mode, JSX support, and declaration-file parsing. It is useful when filename inference was used.

import { parse } from 'fino:format/typescript';

const mode = parse('export {}', { filename: 'x.ts' }).sourceType;

filename?: string

Filename used for syntax-mode inference and source map metadata.

The file is not read from disk. For transpile() this is the only grammar control: use a .tsx, .jsx, or .d.ts extension to select those modes. Without a filename, transpilation assumes TypeScript module grammar (source maps then reference module.ts).

import { transpile } from 'fino:format/typescript';

transpile('const x: number = 1;', { filename: 'example.ts' });

sourceType?: ParseOptions['sourceType']

Explicit source grammar for the functions that honor it.

format() and lint() resolve grammar from this field before falling back to filename inference. transpile() itself ignores this field and derives grammar from filename alone, so pass a filename with a matching extension to transpile JSX or declaration-file input.

import { format, transpile } from 'fino:format/typescript';

format('const el = <div />;', { sourceType: 'tsx' });
transpile('const el = <div />;', { filename: 'component.tsx' });

ok: boolean

Whether transpilation completed without failure diagnostics.

false means inspect errors before using code.

import { transpile } from 'fino:format/typescript';

const ok = transpile('const x: number = 1;', { filename: 'x.ts' }).ok;

code: string

Transpiled JavaScript source code.

Type syntax is removed or lowered according to OXC's transformer behavior. The result is not bundled or minified. Empty when transpilation failed.

import { transpile } from 'fino:format/typescript';

const code = transpile('const x: number = 1;', { filename: 'x.ts' }).code;

map: string

Source map text emitted by OXC.

The map references filename (or the module.ts default) as its source. Empty when transpilation failed.

import { transpile } from 'fino:format/typescript';

const map = transpile('const x: number = 1;', { filename: 'x.ts' }).map;

errors: ParseDiagnostic[]

Transpiler diagnostics.

The array is empty on success. Diagnostics use the same shape as parser diagnostics and should not be treated as stable machine-readable codes.

import { transpile } from 'fino:format/typescript';

const errors = transpile('const =', { filename: 'x.ts' }).errors;

ok: boolean

Whether formatting succeeded without diagnostics.

code: string

Formatted source text, or the empty string on failure.

errors: ParseDiagnostic[]

Parse or formatter diagnostics.

fix?: boolean

Request automatically fixed source text in fixedCode.

The input string is never modified. The default rule set currently has no auto-fixable rules, so fixedCode comes back null even with fix: true.

ok: boolean

Whether linting completed with no diagnostics.

diagnostics: ParseDiagnostic[]

Parse and lint diagnostics from the default rule set.

fixedCode?: string

Rewritten source when automatic fixes were applied; null otherwise.

prefix?: string

URL path prefix to serve from. Defaults to /.