tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/side-state.d.ts

@@ -0,0 +1,16 @@
+import type { Checker } from './checker.js';
+import { ObjectFlags, Signature, Type } from './checker-types.js';
+/**
+ * The object that holds the lazily computed state of `t`: `t` itself, or for a type with side
+ * state the checker's holder of it, an object of the same class created on first use. The holder's
+ * identity fields are copies or unset: nothing may use it as a type, only as a holder of state.
+ */
+export declare function sideOf<T extends Type>(c: Checker, t: T): T;
+/** The holder of `t`'s state if `t` has side state and its checker created one, else `t`. */
+export declare function sideOfIfAny<T extends Type>(c: Checker, t: T): T | undefined;
+/** The `objectFlags` of `t` that are computed lazily (resolution state and memo bits). */
+export declare function lazyObjectFlags(c: Checker, t: Type): ObjectFlags;
+/** Like `sideOf`, for a signature with side state. */
+export declare function signatureSideOf(c: Checker, s: Signature): Signature;
+/** The resolved return type of `s`: set when it was created, or resolved since (`getReturnTypeOfSignature`). */
+export declare function resolvedReturnTypeOf(c: Checker, s: Signature): Type | undefined;

package/dist/api/compiler/side-state.js

@@ -0,0 +1,89 @@
+import { ConditionalType, EvolvingArrayType, InstantiationExpressionType, InterfaceType, IntersectionType, LiteralType, MappedType, ObjectType, ReverseMappedType, Signature, StructuredType, TupleType, Type, TypeParameter, TypeReference, UnionType, emptySymbols, emptyTypes, } from './checker-types.js';
+/**
+ * The object that holds the lazily computed state of `t`: `t` itself, or for a type with side
+ * state the checker's holder of it, an object of the same class created on first use. The holder's
+ * identity fields are copies or unset: nothing may use it as a type, only as a holder of state.
+ */
+export function sideOf(c, t) {
+    // Small enough to inline: the holder is found out of line.
+    return (t.objectFlags & -2147483648 /* ObjectFlags.SideState */) === 0 ? t : sideHolder(c, t);
+}
+function sideHolder(c, t) {
+    let holder = c.sideHolders.get(t.id);
+    if (holder === undefined) {
+        holder = newSideHolder(t);
+        holder.objectFlags = 0 /* ObjectFlags.None */;
+        holder.symbol = t.symbol;
+        c.sideHolders.set(t.id, holder);
+    }
+    return holder;
+}
+/** The holder of `t`'s state if `t` has side state and its checker created one, else `t`. */
+export function sideOfIfAny(c, t) {
+    if ((t.objectFlags & -2147483648 /* ObjectFlags.SideState */) === 0)
+        return t;
+    return c.sideHolders.get(t.id);
+}
+/** The `objectFlags` of `t` that are computed lazily (resolution state and memo bits). */
+export function lazyObjectFlags(c, t) {
+    const flags = t.objectFlags;
+    return (flags & -2147483648 /* ObjectFlags.SideState */) === 0 ? flags : sideHolderFlags(c, t);
+}
+function sideHolderFlags(c, t) {
+    const holder = c.sideHolders.get(t.id);
+    return holder !== undefined ? holder.objectFlags : 0 /* ObjectFlags.None */;
+}
+function newSideHolder(t) {
+    const id = t.id;
+    const symbol = t.symbol;
+    if (t instanceof TupleType)
+        return new TupleType(0 /* ObjectFlags.None */, id);
+    if (t instanceof InterfaceType)
+        return new InterfaceType(0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof TypeReference)
+        return new TypeReference(0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof MappedType)
+        return new MappedType(0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof ReverseMappedType)
+        return new ReverseMappedType(0 /* ObjectFlags.None */, id);
+    if (t instanceof EvolvingArrayType)
+        return new EvolvingArrayType(0 /* ObjectFlags.None */, id);
+    if (t instanceof InstantiationExpressionType)
+        return new InstantiationExpressionType(0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof ObjectType)
+        return new ObjectType(0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof UnionType)
+        return new UnionType(0 /* ObjectFlags.None */, id, emptyTypes);
+    if (t instanceof IntersectionType)
+        return new IntersectionType(0 /* ObjectFlags.None */, id, emptyTypes);
+    if (t instanceof StructuredType)
+        return new StructuredType(t.flags, 0 /* ObjectFlags.None */, id, symbol);
+    if (t instanceof LiteralType)
+        return new LiteralType(t.flags, id, symbol, '', 0);
+    if (t instanceof TypeParameter)
+        return new TypeParameter(id, symbol);
+    if (t instanceof ConditionalType) {
+        const conditional = t;
+        return new ConditionalType(id, conditional.root, conditional.checkType, conditional.extendsType, undefined, undefined);
+    }
+    return new Type(t.flags, 0 /* ObjectFlags.None */, id, symbol);
+}
+/** Like `sideOf`, for a signature with side state. */
+export function signatureSideOf(c, s) {
+    return (s.flags & 512 /* SignatureFlags.SideState */) === 0 ? s : signatureSideHolder(c, s);
+}
+function signatureSideHolder(c, s) {
+    let holder = c.signatureSideHolders.get(s.id);
+    if (holder === undefined) {
+        holder = new Signature(s.id, 0 /* SignatureFlags.None */, undefined, emptyTypes, undefined, emptySymbols, undefined, undefined, 0);
+        c.signatureSideHolders.set(s.id, holder);
+    }
+    return holder;
+}
+/** The resolved return type of `s`: set when it was created, or resolved since (`getReturnTypeOfSignature`). */
+export function resolvedReturnTypeOf(c, s) {
+    if (s.resolvedReturnType !== undefined || (s.flags & 512 /* SignatureFlags.SideState */) === 0)
+        return s.resolvedReturnType;
+    const holder = c.signatureSideHolders.get(s.id);
+    return holder !== undefined ? holder.resolvedReturnType : undefined;
+}

package/dist/api/compiler/sourcemap.d.ts

@@ -0,0 +1,55 @@
+/** The path of `path` relative to `directory`, with absolute results as `file://` URLs. */
+export declare function getRelativePathToDirectoryOrUrl(directory: string, path: string, useCaseSensitiveFileNames: boolean, currentDirectory: string): string;
+export declare class SourceMapGenerator {
+    readonly file: string;
+    readonly sourceRoot: string;
+    private readonly sourcesDirectoryPath;
+    private readonly useCaseSensitiveFileNames;
+    private readonly currentDirectory;
+    /** Source file names as added. */
+    readonly rawSources: string[];
+    private readonly sources;
+    private readonly sourceIndices;
+    private readonly sourcesContent;
+    private readonly names;
+    /** The mappings as ASCII bytes; the first `mappingsLength` are used. */
+    private mappings;
+    private mappingsLength;
+    private lastGeneratedLine;
+    private lastGeneratedCharacter;
+    private lastSourceIndex;
+    private lastSourceLine;
+    private lastSourceCharacter;
+    private lastNameIndex;
+    private hasLast;
+    private pendingGeneratedLine;
+    private pendingGeneratedCharacter;
+    private pendingSourceIndex;
+    private pendingSourceLine;
+    private pendingSourceCharacter;
+    private pendingNameIndex;
+    private hasPending;
+    private hasPendingSource;
+    private hasPendingName;
+    constructor(file: string, sourceRoot: string, sourcesDirectoryPath: string, useCaseSensitiveFileNames: boolean, currentDirectory: string);
+    addSource(fileName: string): number;
+    setSourceContent(sourceIndex: number, content: string): boolean;
+    addName(name: string): number;
+    /** Appends the ASCII character `code` to the mappings. */
+    private appendMapping;
+    private appendBase64VLQ;
+    private shouldCommitMapping;
+    private commitPendingMapping;
+    private addMapping;
+    addSourceMapping(generatedLine: number, generatedCharacter: number, sourceIndex: number, sourceLine: number, sourceCharacter: number): boolean;
+    /** The mappings string. */
+    getMappings(): string;
+    /** The source map as JSON, with keys in tsgo's order. */
+    toJSON(): string;
+    toBase64DataURL(): string;
+}
+/** A JSON string literal, escaped as Go's encoding/json/v2 does by default. */
+export declare function jsonString(s: string): string;
+/** UTF-8 bytes of `s`; lone surrogates become U+FFFD. */
+export declare function utf8Bytes(s: string): Uint8Array;
+export declare function base64Encode(bytes: Uint8Array): string;

package/dist/api/compiler/sourcemap.js

@@ -0,0 +1,340 @@
+// Source map v3 generation: base64 VLQ mappings and the JSON document, as tsgo writes them.
+import { getPathComponentsRelativeTo, getPathFromPathComponents, isRootedDiskPath } from './path.js';
+const base64Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64DigitCodes = new Uint8Array(64);
+for (let i = 0; i < 64; i++)
+    base64DigitCodes[i] = base64Digits.charCodeAt(i);
+const mappingsDecoder = new TextDecoder();
+/** The path of `path` relative to `directory`, with absolute results as `file://` URLs. */
+export function getRelativePathToDirectoryOrUrl(directory, path, useCaseSensitiveFileNames, currentDirectory) {
+    const components = getPathComponentsRelativeTo(directory, path, useCaseSensitiveFileNames, currentDirectory);
+    const first = components[0];
+    if (isRootedDiskPath(first))
+        components[0] = (first.charCodeAt(0) === 0x2f ? 'file://' : 'file:///') + first;
+    return getPathFromPathComponents(components);
+}
+export class SourceMapGenerator {
+    file;
+    sourceRoot;
+    sourcesDirectoryPath;
+    useCaseSensitiveFileNames;
+    currentDirectory;
+    /** Source file names as added. */
+    rawSources;
+    sources;
+    sourceIndices;
+    sourcesContent;
+    names;
+    /** The mappings as ASCII bytes; the first `mappingsLength` are used. */
+    mappings;
+    mappingsLength;
+    lastGeneratedLine;
+    lastGeneratedCharacter;
+    lastSourceIndex;
+    lastSourceLine;
+    lastSourceCharacter;
+    lastNameIndex;
+    hasLast;
+    pendingGeneratedLine;
+    pendingGeneratedCharacter;
+    pendingSourceIndex;
+    pendingSourceLine;
+    pendingSourceCharacter;
+    pendingNameIndex;
+    hasPending;
+    hasPendingSource;
+    hasPendingName;
+    constructor(file, sourceRoot, sourcesDirectoryPath, useCaseSensitiveFileNames, currentDirectory) {
+        this.file = file;
+        this.sourceRoot = sourceRoot;
+        this.sourcesDirectoryPath = sourcesDirectoryPath;
+        this.useCaseSensitiveFileNames = useCaseSensitiveFileNames;
+        this.currentDirectory = currentDirectory;
+        this.rawSources = [];
+        this.sources = [];
+        this.sourceIndices = new Map();
+        this.sourcesContent = [];
+        this.names = [];
+        this.mappings = new Uint8Array(1024);
+        this.mappingsLength = 0;
+        this.lastGeneratedLine = 0;
+        this.lastGeneratedCharacter = 0;
+        this.lastSourceIndex = 0;
+        this.lastSourceLine = 0;
+        this.lastSourceCharacter = 0;
+        this.lastNameIndex = 0;
+        this.hasLast = false;
+        this.pendingGeneratedLine = 0;
+        this.pendingGeneratedCharacter = 0;
+        this.pendingSourceIndex = 0;
+        this.pendingSourceLine = 0;
+        this.pendingSourceCharacter = 0;
+        this.pendingNameIndex = 0;
+        this.hasPending = false;
+        this.hasPendingSource = false;
+        this.hasPendingName = false;
+    }
+    addSource(fileName) {
+        const source = getRelativePathToDirectoryOrUrl(this.sourcesDirectoryPath, fileName, this.useCaseSensitiveFileNames, this.currentDirectory);
+        const existing = this.sourceIndices.get(source);
+        if (existing !== undefined)
+            return existing;
+        const index = this.sources.length;
+        this.sources.push(source);
+        this.rawSources.push(fileName);
+        this.sourceIndices.set(source, index);
+        return index;
+    }
+    setSourceContent(sourceIndex, content) {
+        if (sourceIndex < 0 || sourceIndex >= this.sources.length)
+            throw new Error('sourceIndex is out of range');
+        while (this.sourcesContent.length <= sourceIndex)
+            this.sourcesContent.push(undefined);
+        this.sourcesContent[sourceIndex] = content;
+        return true;
+    }
+    addName(name) {
+        const index = this.names.indexOf(name);
+        if (index >= 0)
+            return index;
+        this.names.push(name);
+        return this.names.length - 1;
+    }
+    /** Appends the ASCII character `code` to the mappings. */
+    appendMapping(code) {
+        const length = this.mappingsLength;
+        if (length === this.mappings.length) {
+            const grown = new Uint8Array(length * 2);
+            grown.set(this.mappings);
+            this.mappings = grown;
+        }
+        this.mappings[length] = code;
+        this.mappingsLength = length + 1;
+        return true;
+    }
+    appendBase64VLQ(value) {
+        value = value < 0 ? (-value << 1) + 1 : value << 1;
+        do {
+            let digit = value & 31;
+            value = value >> 5;
+            if (value > 0)
+                digit |= 32;
+            this.appendMapping(base64DigitCodes[digit]);
+        } while (value > 0);
+        return true;
+    }
+    shouldCommitMapping() {
+        return (this.hasPending &&
+            (!this.hasLast ||
+                this.lastGeneratedLine !== this.pendingGeneratedLine ||
+                this.lastGeneratedCharacter !== this.pendingGeneratedCharacter ||
+                this.lastSourceIndex !== this.pendingSourceIndex ||
+                this.lastSourceLine !== this.pendingSourceLine ||
+                this.lastSourceCharacter !== this.pendingSourceCharacter ||
+                this.lastNameIndex !== this.pendingNameIndex));
+    }
+    commitPendingMapping() {
+        if (!this.shouldCommitMapping())
+            return false;
+        if (this.lastGeneratedLine < this.pendingGeneratedLine) {
+            do {
+                this.appendMapping(0x3b); // ;
+                this.lastGeneratedLine++;
+            } while (this.lastGeneratedLine < this.pendingGeneratedLine);
+            this.lastGeneratedCharacter = 0;
+        }
+        else {
+            if (this.lastGeneratedLine !== this.pendingGeneratedLine)
+                throw new Error('generatedLine cannot backtrack');
+            if (this.hasLast)
+                this.appendMapping(0x2c); // ,
+        }
+        this.appendBase64VLQ(this.pendingGeneratedCharacter - this.lastGeneratedCharacter);
+        this.lastGeneratedCharacter = this.pendingGeneratedCharacter;
+        if (this.hasPendingSource) {
+            this.appendBase64VLQ(this.pendingSourceIndex - this.lastSourceIndex);
+            this.lastSourceIndex = this.pendingSourceIndex;
+            this.appendBase64VLQ(this.pendingSourceLine - this.lastSourceLine);
+            this.lastSourceLine = this.pendingSourceLine;
+            this.appendBase64VLQ(this.pendingSourceCharacter - this.lastSourceCharacter);
+            this.lastSourceCharacter = this.pendingSourceCharacter;
+            if (this.hasPendingName) {
+                this.appendBase64VLQ(this.pendingNameIndex - this.lastNameIndex);
+                this.lastNameIndex = this.pendingNameIndex;
+            }
+        }
+        this.hasLast = true;
+        return true;
+    }
+    addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, nameIndex) {
+        const backtracking = sourceIndex >= 0 &&
+            sourceLine >= 0 &&
+            sourceCharacter >= 0 &&
+            this.pendingSourceIndex === sourceIndex &&
+            (this.pendingSourceLine > sourceLine ||
+                (this.pendingSourceLine === sourceLine && this.pendingSourceCharacter > sourceCharacter));
+        if (!this.hasPending ||
+            this.pendingGeneratedLine !== generatedLine ||
+            this.pendingGeneratedCharacter !== generatedCharacter ||
+            backtracking) {
+            this.commitPendingMapping();
+            this.pendingGeneratedLine = generatedLine;
+            this.pendingGeneratedCharacter = generatedCharacter;
+            this.hasPendingSource = false;
+            this.hasPendingName = false;
+            this.hasPending = true;
+        }
+        if (sourceIndex >= 0 && sourceLine >= 0 && sourceCharacter >= 0) {
+            this.pendingSourceIndex = sourceIndex;
+            this.pendingSourceLine = sourceLine;
+            this.pendingSourceCharacter = sourceCharacter;
+            this.hasPendingSource = true;
+            if (nameIndex >= 0) {
+                this.pendingNameIndex = nameIndex;
+                this.hasPendingName = true;
+            }
+        }
+        return true;
+    }
+    addSourceMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter) {
+        if (generatedLine < this.pendingGeneratedLine)
+            throw new Error('generatedLine cannot backtrack');
+        if (generatedCharacter < 0)
+            throw new Error('generatedCharacter cannot be negative');
+        if (sourceIndex < 0 || sourceIndex >= this.sources.length)
+            throw new Error('sourceIndex is out of range');
+        if (sourceLine < 0)
+            throw new Error('sourceLine cannot be negative');
+        if (sourceCharacter < 0)
+            throw new Error('sourceCharacter cannot be negative');
+        return this.addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, -1);
+    }
+    /** The mappings string. */
+    getMappings() {
+        this.commitPendingMapping();
+        return mappingsDecoder.decode(this.mappings.subarray(0, this.mappingsLength));
+    }
+    /** The source map as JSON, with keys in tsgo's order. */
+    toJSON() {
+        const mappings = this.getMappings();
+        let json = '{"version":3,"file":' +
+            jsonString(this.file) +
+            ',"sourceRoot":' +
+            jsonString(this.sourceRoot) +
+            ',"sources":' +
+            jsonStrings(this.sources) +
+            ',"names":' +
+            jsonStrings(this.names) +
+            // Base64 digits, `;` and `,` need no escaping.
+            ',"mappings":"' +
+            mappings +
+            '"';
+        if (this.sourcesContent.length > 0) {
+            json += ',"sourcesContent":[';
+            let separator = '';
+            for (const content of this.sourcesContent) {
+                json += separator + (content === undefined ? 'null' : jsonString(content));
+                separator = ',';
+            }
+            json += ']';
+        }
+        return json + '}';
+    }
+    toBase64DataURL() {
+        return 'data:application/json;base64,' + base64Encode(utf8Bytes(this.toJSON()));
+    }
+}
+const hex = '0123456789abcdef';
+/** A JSON string literal, escaped as Go's encoding/json/v2 does by default. */
+export function jsonString(s) {
+    let out = '"';
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s.charCodeAt(i);
+        let escape;
+        if (ch === 0x22)
+            escape = '\\"';
+        else if (ch === 0x5c)
+            escape = '\\\\';
+        else if (ch >= 0x20)
+            continue;
+        else if (ch === 0x08)
+            escape = '\\b';
+        else if (ch === 0x0c)
+            escape = '\\f';
+        else if (ch === 0x0a)
+            escape = '\\n';
+        else if (ch === 0x0d)
+            escape = '\\r';
+        else if (ch === 0x09)
+            escape = '\\t';
+        else
+            escape = '\\u00' + hex.charAt(ch >> 4) + hex.charAt(ch & 15);
+        out += s.substring(start, i) + escape;
+        start = i + 1;
+    }
+    return out + s.substring(start) + '"';
+}
+function jsonStrings(values) {
+    let out = '[';
+    for (let i = 0; i < values.length; i++) {
+        if (i > 0)
+            out += ',';
+        out += jsonString(values[i]);
+    }
+    return out + ']';
+}
+/** UTF-8 bytes of `s`; lone surrogates become U+FFFD. */
+export function utf8Bytes(s) {
+    const bytes = [];
+    for (let i = 0; i < s.length; i++) {
+        let c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
+            const low = s.charCodeAt(i + 1);
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                c = (c - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+                i++;
+            }
+        }
+        if (c >= 0xd800 && c <= 0xdfff)
+            c = 0xfffd;
+        if (c < 0x80)
+            bytes.push(c);
+        else if (c < 0x800)
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+        else if (c < 0x10000)
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+        else
+            bytes.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    }
+    return Uint8Array.from(bytes);
+}
+export function base64Encode(bytes) {
+    const parts = [];
+    let chunk = '';
+    let i = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        chunk +=
+            base64Digits.charAt(n >> 18) +
+                base64Digits.charAt((n >> 12) & 63) +
+                base64Digits.charAt((n >> 6) & 63) +
+                base64Digits.charAt(n & 63);
+        if (chunk.length >= 4096) {
+            parts.push(chunk);
+            chunk = '';
+        }
+    }
+    const rest = bytes.length - i;
+    if (rest === 1) {
+        const n = bytes[i] << 16;
+        chunk += base64Digits.charAt(n >> 18) + base64Digits.charAt((n >> 12) & 63) + '==';
+    }
+    else if (rest === 2) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        chunk +=
+            base64Digits.charAt(n >> 18) + base64Digits.charAt((n >> 12) & 63) + base64Digits.charAt((n >> 6) & 63) + '=';
+    }
+    parts.push(chunk);
+    return parts.join('');
+}

package/dist/api/compiler/spelling.d.ts

@@ -0,0 +1,14 @@
+/** The code points of a string and their lowercase forms, in arrays reused from one string to the next. */
+export declare class CodePoints {
+    codes: Int32Array<ArrayBuffer>;
+    lower: Int32Array<ArrayBuffer>;
+    length: number;
+    /** Takes the code points of `text`. */
+    set(text: string): void;
+}
+/** The distance from `name` to `candidate` (levenshteinWithMax), -1 if above `max`. */
+export declare function distanceToCandidate(name: CodePoints, candidate: string, max: number): number;
+/** The candidate closest to `name` by edit distance, or `''`; ties go to the lexicographically smaller. */
+export declare function getSpellingSuggestion(name: string, candidates: readonly string[]): string;
+/** The length of `s` in UTF-8 bytes. */
+export declare function utf8Length(s: string): number;

package/dist/api/compiler/spelling.js

@@ -0,0 +1,128 @@
+function toLower(ch) {
+    if (ch < 0x80)
+        return ch >= 0x41 && ch <= 0x5a ? ch + 0x20 : ch;
+    const lower = String.fromCodePoint(ch).toLowerCase();
+    return lower.length === 0 ? ch : lower.codePointAt(0);
+}
+/** The code points of a string and their lowercase forms, in arrays reused from one string to the next. */
+export class CodePoints {
+    codes = new Int32Array(16);
+    lower = new Int32Array(16);
+    length = 0;
+    /** Takes the code points of `text`. */
+    set(text) {
+        if (this.codes.length < text.length) {
+            this.codes = new Int32Array(text.length * 2);
+            this.lower = new Int32Array(text.length * 2);
+        }
+        let n = 0;
+        for (let i = 0; i < text.length;) {
+            const ch = text.codePointAt(i);
+            this.codes[n] = ch;
+            this.lower[n] = toLower(ch);
+            n++;
+            i += ch >= 0x10000 ? 2 : 1;
+        }
+        this.length = n;
+    }
+}
+/** The candidate of the current comparison; a nested search compares its own candidates before it is set. */
+const candidateCodePoints = new CodePoints();
+let previousRow = new Float64Array(32);
+let currentRow = new Float64Array(32);
+/** Levenshtein distance where a case-only substitution costs 0.1; -1 if above `max`. */
+function levenshteinWithMax(s1, s2, max) {
+    const length2 = s2.length;
+    if (previousRow.length <= length2) {
+        previousRow = new Float64Array(length2 * 2 + 1);
+        currentRow = new Float64Array(length2 * 2 + 1);
+    }
+    let previous = previousRow;
+    let current = currentRow;
+    for (let i = 0; i <= length2; i++)
+        previous[i] = i;
+    const big = max + 0.01;
+    for (let i = 1; i <= s1.length; i++) {
+        const c1 = s1.codes[i - 1];
+        const lower1 = s1.lower[i - 1];
+        const minJ = Math.max(Math.ceil(i - max), 1);
+        const maxJ = Math.min(Math.floor(max + i), length2);
+        let colMin = i;
+        current[0] = i;
+        for (let j = 1; j < minJ; j++)
+            current[j] = big;
+        for (let j = minJ; j <= maxJ; j++) {
+            let dist = previous[j - 1];
+            if (c1 !== s2.codes[j - 1]) {
+                const substitution = dist + (lower1 === s2.lower[j - 1] ? 0.1 : 2);
+                dist = Math.min(previous[j] + 1, current[j - 1] + 1, substitution);
+            }
+            current[j] = dist;
+            colMin = Math.min(colMin, dist);
+        }
+        for (let j = maxJ + 1; j <= length2; j++)
+            current[j] = big;
+        if (colMin > max)
+            return -1;
+        const swap = previous;
+        previous = current;
+        current = swap;
+    }
+    const result = previous[length2];
+    return result > max ? -1 : result;
+}
+/** The distance from `name` to `candidate` (levenshteinWithMax), -1 if above `max`. */
+export function distanceToCandidate(name, candidate, max) {
+    candidateCodePoints.set(candidate);
+    return levenshteinWithMax(name, candidateCodePoints, max);
+}
+/** The candidate closest to `name` by edit distance, or `''`; ties go to the lexicographically smaller. */
+export function getSpellingSuggestion(name, candidates) {
+    const nameCodePoints = new CodePoints();
+    nameCodePoints.set(name);
+    const maximumLengthDifference = Math.max(2, Math.floor(nameCodePoints.length * 0.34));
+    let bestDistance = Math.floor(nameCodePoints.length * 0.4) + 0.9;
+    let best = '';
+    let hasBest = false;
+    const lowerName = name.toLowerCase();
+    for (const candidate of candidates) {
+        const maxLength = Math.max(candidate.length, nameCodePoints.length);
+        const minLength = Math.min(candidate.length, nameCodePoints.length);
+        if (candidate === '' || maxLength - minLength > maximumLengthDifference || candidate === name)
+            continue;
+        // Short candidates only count when they differ by case.
+        if (candidate.length < 3 && candidate.toLowerCase() !== lowerName)
+            continue;
+        const distance = distanceToCandidate(nameCodePoints, candidate, bestDistance);
+        if (distance < 0)
+            continue;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = candidate;
+            hasBest = true;
+        }
+        else if (!hasBest || candidate < best) {
+            best = candidate;
+            hasBest = true;
+        }
+    }
+    return best;
+}
+/** The length of `s` in UTF-8 bytes. */
+export function utf8Length(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s.charCodeAt(i);
+        if (ch < 0x80)
+            n += 1;
+        else if (ch < 0x800)
+            n += 2;
+        else if (ch >= 0xd800 && ch <= 0xdbff) {
+            n += 4;
+            i++;
+        }
+        else
+            n += 3;
+    }
+    return n;
+}