tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/character-codes.d.ts

@@ -0,0 +1,161 @@
+import { LanguageVariant } from './types.js';
+/** UTF-16 code units the scanner tests for. */
+export declare const enum CharacterCodes {
+    EOF = -1,
+    nullCharacter = 0,
+    maxAsciiCharacter = 127,
+    lineFeed = 10,// \n
+    carriageReturn = 13,// \r
+    lineSeparator = 8232,
+    paragraphSeparator = 8233,
+    nextLine = 133,
+    space = 32,
+    nonBreakingSpace = 160,
+    enQuad = 8192,
+    emQuad = 8193,
+    enSpace = 8194,
+    emSpace = 8195,
+    threePerEmSpace = 8196,
+    fourPerEmSpace = 8197,
+    sixPerEmSpace = 8198,
+    figureSpace = 8199,
+    punctuationSpace = 8200,
+    thinSpace = 8201,
+    hairSpace = 8202,
+    zeroWidthSpace = 8203,
+    narrowNoBreakSpace = 8239,
+    ideographicSpace = 12288,
+    mathematicalSpace = 8287,
+    ogham = 5760,
+    replacementCharacter = 65533,
+    _ = 95,
+    $ = 36,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    ampersand = 38,// &
+    asterisk = 42,// *
+    at = 64,// @
+    backslash = 92,// \
+    backtick = 96,// `
+    bar = 124,// |
+    caret = 94,// ^
+    closeBrace = 125,// }
+    closeBracket = 93,// ]
+    closeParen = 41,// )
+    colon = 58,// :
+    comma = 44,// ,
+    dot = 46,// .
+    doubleQuote = 34,// "
+    equals = 61,// =
+    exclamation = 33,// !
+    greaterThan = 62,// >
+    hash = 35,// #
+    lessThan = 60,// <
+    minus = 45,// -
+    openBrace = 123,// {
+    openBracket = 91,// [
+    openParen = 40,// (
+    percent = 37,// %
+    plus = 43,// +
+    question = 63,// ?
+    semicolon = 59,// ;
+    singleQuote = 39,// '
+    slash = 47,// /
+    tilde = 126,// ~
+    backspace = 8,// \b
+    formFeed = 12,// \f
+    byteOrderMark = 65279,
+    tab = 9,// \t
+    verticalTab = 11
+}
+/** ECMAScript line terminators: LF, CR, LS and PS. */
+export declare function isLineBreak(ch: number): boolean;
+/** Whitespace other than line terminators. NEL (U+0085) counts as whitespace. */
+export declare function isWhiteSpaceSingleLine(ch: number): boolean;
+export declare function isWhiteSpaceLike(ch: number): boolean;
+/** Unicode White_Space, as Go's `unicode.IsSpace` defines it. Unlike `isWhiteSpaceLike`, excludes ZWSP and BOM. */
+export declare function isUnicodeWhiteSpace(ch: number): boolean;
+export declare function isDigit(ch: number): boolean;
+export declare function isOctalDigit(ch: number): boolean;
+export declare function isHexDigit(ch: number): boolean;
+export declare function isASCIILetter(ch: number): boolean;
+/** `[A-Za-z0-9_]`. */
+export declare function isWordCharacter(ch: number): boolean;
+export declare function isHighSurrogate(ch: number): boolean;
+export declare function isLowSurrogate(ch: number): boolean;
+/** Number of UTF-16 code units of a code point. */
+export declare function charSize(codePoint: number): number;
+/** The code point at `pos`, combining a surrogate pair; -1 at or past `end`. */
+export declare function codePointAt(text: string, pos: number, end: number): number;
+/** Length of `text` in UTF-8 bytes. A lone surrogate counts as U+FFFD, as `Buffer` encodes it. */
+export declare function utf8Length(text: string): number;
+/** The code point ending just before `pos`, combining a surrogate pair; -1 at the start. */
+export declare function codePointBefore(text: string, pos: number): number;
+/** Unicode ID_Start. */
+export declare function isUnicodeIdentifierStart(codePoint: number): boolean;
+/** Unicode ID_Continue. */
+export declare function isUnicodeIdentifierPart(codePoint: number): boolean;
+export declare function isIdentifierStart(codePoint: number): boolean;
+export declare function isIdentifierPart(codePoint: number, languageVariant?: LanguageVariant): boolean;
+/** UTF-8 offset of each UTF-16 offset of `text`; the middle of a surrogate pair maps to its start. */
+export declare function utf8Offsets(text: string): Int32Array;

package/dist/api/compiler/character-codes.js

@@ -0,0 +1,160 @@
+import { identifierPartRanges, identifierStartRanges } from './unicode-identifiers.js';
+/** ECMAScript line terminators: LF, CR, LS and PS. */
+export function isLineBreak(ch) {
+    return (ch === 10 /* CharacterCodes.lineFeed */ ||
+        ch === 13 /* CharacterCodes.carriageReturn */ ||
+        ch === 8232 /* CharacterCodes.lineSeparator */ ||
+        ch === 8233 /* CharacterCodes.paragraphSeparator */);
+}
+/** Whitespace other than line terminators. NEL (U+0085) counts as whitespace. */
+export function isWhiteSpaceSingleLine(ch) {
+    if (ch < 0x80) {
+        return (ch === 32 /* CharacterCodes.space */ ||
+            ch === 9 /* CharacterCodes.tab */ ||
+            ch === 11 /* CharacterCodes.verticalTab */ ||
+            ch === 12 /* CharacterCodes.formFeed */);
+    }
+    return (ch === 133 /* CharacterCodes.nextLine */ ||
+        ch === 160 /* CharacterCodes.nonBreakingSpace */ ||
+        ch === 5760 /* CharacterCodes.ogham */ ||
+        (ch >= 8192 /* CharacterCodes.enQuad */ && ch <= 8203 /* CharacterCodes.zeroWidthSpace */) ||
+        ch === 8239 /* CharacterCodes.narrowNoBreakSpace */ ||
+        ch === 8287 /* CharacterCodes.mathematicalSpace */ ||
+        ch === 12288 /* CharacterCodes.ideographicSpace */ ||
+        ch === 65279 /* CharacterCodes.byteOrderMark */);
+}
+export function isWhiteSpaceLike(ch) {
+    return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
+}
+/** Unicode White_Space, as Go's `unicode.IsSpace` defines it. Unlike `isWhiteSpaceLike`, excludes ZWSP and BOM. */
+export function isUnicodeWhiteSpace(ch) {
+    return ((ch >= 9 /* CharacterCodes.tab */ && ch <= 13 /* CharacterCodes.carriageReturn */) ||
+        ch === 32 /* CharacterCodes.space */ ||
+        ch === 133 /* CharacterCodes.nextLine */ ||
+        ch === 160 /* CharacterCodes.nonBreakingSpace */ ||
+        ch === 5760 /* CharacterCodes.ogham */ ||
+        (ch >= 8192 /* CharacterCodes.enQuad */ && ch <= 8202 /* CharacterCodes.hairSpace */) ||
+        ch === 8232 /* CharacterCodes.lineSeparator */ ||
+        ch === 8233 /* CharacterCodes.paragraphSeparator */ ||
+        ch === 8239 /* CharacterCodes.narrowNoBreakSpace */ ||
+        ch === 8287 /* CharacterCodes.mathematicalSpace */ ||
+        ch === 12288 /* CharacterCodes.ideographicSpace */);
+}
+export function isDigit(ch) {
+    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
+}
+export function isOctalDigit(ch) {
+    return ch >= 48 /* CharacterCodes._0 */ && ch <= 55 /* CharacterCodes._7 */;
+}
+export function isHexDigit(ch) {
+    return ((ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) ||
+        (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) ||
+        (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */));
+}
+export function isASCIILetter(ch) {
+    return (ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */) || (ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */);
+}
+/** `[A-Za-z0-9_]`. */
+export function isWordCharacter(ch) {
+    return isASCIILetter(ch) || isDigit(ch) || ch === 95 /* CharacterCodes._ */;
+}
+export function isHighSurrogate(ch) {
+    return ch >= 0xd800 && ch <= 0xdbff;
+}
+export function isLowSurrogate(ch) {
+    return ch >= 0xdc00 && ch <= 0xdfff;
+}
+/** Number of UTF-16 code units of a code point. */
+export function charSize(codePoint) {
+    return codePoint >= 0x10000 ? 2 : 1;
+}
+/** The code point at `pos`, combining a surrogate pair; -1 at or past `end`. */
+export function codePointAt(text, pos, end) {
+    if (pos >= end)
+        return -1 /* CharacterCodes.EOF */;
+    const ch = text.charCodeAt(pos);
+    if (ch >= 0xd800 && ch <= 0xdbff && pos + 1 < end) {
+        const low = text.charCodeAt(pos + 1);
+        if (low >= 0xdc00 && low <= 0xdfff)
+            return (ch - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+    }
+    return ch;
+}
+/** Length of `text` in UTF-8 bytes. A lone surrogate counts as U+FFFD, as `Buffer` encodes it. */
+export function utf8Length(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+/** The code point ending just before `pos`, combining a surrogate pair; -1 at the start. */
+export function codePointBefore(text, pos) {
+    if (pos <= 0)
+        return -1 /* CharacterCodes.EOF */;
+    const ch = text.charCodeAt(pos - 1);
+    if (ch >= 0xdc00 && ch <= 0xdfff && pos >= 2) {
+        const high = text.charCodeAt(pos - 2);
+        if (high >= 0xd800 && high <= 0xdbff)
+            return (high - 0xd800) * 0x400 + (ch - 0xdc00) + 0x10000;
+    }
+    return ch;
+}
+function inRanges(ranges, codePoint) {
+    let low = 0;
+    let high = (ranges.length >> 1) - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        if (codePoint < ranges[middle * 2])
+            high = middle - 1;
+        else if (codePoint > ranges[middle * 2 + 1])
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+}
+/** Unicode ID_Start. */
+export function isUnicodeIdentifierStart(codePoint) {
+    return inRanges(identifierStartRanges, codePoint);
+}
+/** Unicode ID_Continue. */
+export function isUnicodeIdentifierPart(codePoint) {
+    return inRanges(identifierPartRanges, codePoint);
+}
+export function isIdentifierStart(codePoint) {
+    return (isASCIILetter(codePoint) ||
+        codePoint === 95 /* CharacterCodes._ */ ||
+        codePoint === 36 /* CharacterCodes.$ */ ||
+        (codePoint > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierStart(codePoint)));
+}
+export function isIdentifierPart(codePoint, languageVariant = 0 /* LanguageVariant.Standard */) {
+    return (isWordCharacter(codePoint) ||
+        codePoint === 36 /* CharacterCodes.$ */ ||
+        (codePoint > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierPart(codePoint)) ||
+        (languageVariant === 1 /* LanguageVariant.JSX */ &&
+            (codePoint === 45 /* CharacterCodes.minus */ || codePoint === 58 /* CharacterCodes.colon */)));
+}
+/** UTF-8 offset of each UTF-16 offset of `text`; the middle of a surrogate pair maps to its start. */
+export function utf8Offsets(text) {
+    const offsets = new Int32Array(text.length + 1);
+    let bytes = 0;
+    for (let i = 0; i < text.length; i++) {
+        offsets[i] = bytes;
+        const ch = text.charCodeAt(i);
+        if (ch < 0x80)
+            bytes += 1;
+        else if (ch < 0x800)
+            bytes += 2;
+        else if (ch >= 0xd800 && ch <= 0xdbff && i + 1 < text.length) {
+            const low = text.charCodeAt(i + 1);
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                offsets[i + 1] = bytes;
+                bytes += 4;
+                i++;
+            }
+            else
+                bytes += 3;
+        }
+        else
+            bytes += 3;
+    }
+    offsets[text.length] = bytes;
+    return offsets;
+}

package/dist/api/compiler/checker-calls.d.ts

@@ -0,0 +1,46 @@
+import { type CallExpression, NodeVisitor, Node } from './ast.js';
+import { type DiagnosticMessage } from './diagnostics.js';
+import { type Checker } from './checker.js';
+import { CheckMode, type Signature, SignatureFlags, type Type } from './checker-types.js';
+/** The type of an optional chain's expression with the chain's `undefined` removed. */
+export declare function getOptionalExpressionType(c: Checker, exprType: Type, expression: Node): Type;
+export declare function propagateOptionalTypeMarker(c: Checker, t: Type, node: Node, wasOptional: boolean): Type;
+export declare function checkCallExpression(c: Checker, node: Node, checkMode: CheckMode): Type;
+/** Whether `node` calls the global `Symbol` or `Symbol.for`. */
+export declare function isSymbolOrSymbolForCall(c: Checker, node: CallExpression): boolean;
+export declare function checkNewExpression(c: Checker, node: Node, checkMode: CheckMode): Type;
+export declare function checkTaggedTemplateExpression(c: Checker, node: Node, checkMode: CheckMode): Type;
+/** The signature `node` resolves to, computed once. */
+export declare function getResolvedSignature(c: Checker, node: Node, checkMode: CheckMode): Signature;
+/** The signature argument contextual types come from while `call` is checked. */
+export declare function resolveCallSignatureForContext(c: Checker, call: Node): Signature;
+/** Whether a call is untyped: to `any`, or to a `Function` without signatures. */
+export declare function isUntypedFunctionCall(c: Checker, funcType: Type, apparentFuncType: Type, numCallSignatures: number, numConstructSignatures: number): boolean;
+export declare function resolveUntypedCall(c: Checker, node: Node): Signature;
+export declare function resolveErrorCall(c: Checker, node: Node): Signature;
+/** An argument with a known type: a tagged template's strings, or an element of a spread tuple. */
+export declare class SyntheticExpression extends Node {
+    readonly type: Type;
+    readonly isSpread: boolean;
+    readonly tupleNameSource: Node | undefined;
+    constructor(parent: Node, type: Type, isSpread: boolean, tupleNameSource: Node | undefined);
+    forEachChild(_visitor: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+}
+/** The arguments of a call, with spreads of tuples expanded and a tagged template's strings first. */
+export declare function getEffectiveCallArguments(c: Checker, node: Node): Node[];
+/** The type of the arguments from `index` on, for the rest parameter of an immediately invoked function. */
+export declare function getRestArgumentsType(c: Checker, call: Node, args: Node[], index: number): Type;
+export declare function resolveCall(c: Checker, node: Node, signatures: Signature[], checkMode: CheckMode, callChainFlags: SignatureFlags, headMessage: DiagnosticMessage | undefined): Signature;
+export declare function reorderCandidates(c: Checker, signatures: Signature[], callChainFlags: SignatureFlags): Signature[];
+export declare function tryGetRestTypeOfSignature(c: Checker, signature: Signature): Type | undefined;
+/**
+ * Under inferential typing, a generic function argument whose contextual type is a non-generic
+ * function is instantiated in the context of that function type.
+ */
+export declare function instantiateTypeWithSingleGenericCallSignature(c: Checker, node: Node, t: Type, checkMode: CheckMode): Type;
+/** Checks `f<T>` in an expression, or `typeof f<T>`. */
+export declare function checkExpressionWithTypeArguments(c: Checker, node: Node): Type;
+/** The type of an expression with type arguments: its generic signatures instantiated with them. */
+export declare function getInstantiationExpressionType(c: Checker, exprType: Type, node: Node): Type;