@esportsplus/typescript 0.29.6 → 0.31.0

package/build/compiler/language-service.js

@@ -1,73 +1,235 @@
+import { API, DiagnosticCategory } from 'typescript/unstable/sync';
 import { PACKAGE_NAME } from '../constants.js';
-import { ts } from '../index.js';
+import fs from 'fs';
 import path from 'path';
-let cache = new Map();
-function create(root) {
-    let tsconfig = ts.findConfigFile(root, ts.sys.fileExists, 'tsconfig.json');
-    if (!tsconfig) {
+const backslashes = /\\/g;
+let cache = new Map(), scratchEntry = null;
+function advance(entry, changed) {
+    let snapshot = entry.api.updateSnapshot({ fileChanges: { changed } });
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.clearSourceFileCache();
+    entry.project = resolveProject(snapshot, entry.configFileName);
+    entry.snapshot = snapshot;
+}
+function advanceScratch(id, content) {
+    if (!scratchEntry) {
+        scratchEntry = createScratch(id);
+    }
+    else if (scratchEntry.file !== id) {
+        reseedScratch(scratchEntry, id);
+    }
+    let entry = scratchEntry;
+    entry.contents.set(id, content);
+    let snapshot = entry.api.updateSnapshot({ fileChanges: { changed: [id] } });
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.clearSourceFileCache();
+    entry.project = resolveProject(snapshot, entry.config);
+    entry.snapshot = snapshot;
+    return entry;
+}
+function createEntry(root) {
+    let configFileName = findConfig(root);
+    if (!configFileName) {
         throw new Error(`${PACKAGE_NAME}: tsconfig.json not found`);
     }
-    let file = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (file.error) {
-        throw new Error(`${PACKAGE_NAME}: error reading tsconfig.json ${file.error.messageText}`);
-    }
-    let parsed = ts.parseJsonConfigFileContent(file.config, ts.sys, path.dirname(tsconfig));
-    if (parsed.errors.length > 0) {
-        throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${parsed.errors[0].messageText}`);
-    }
-    let contents = new Map(), rootFiles = new Set(parsed.fileNames.map(f => f.replace(/\\/g, '/'))), versions = new Map();
-    for (let fileName of rootFiles) {
-        versions.set(fileName, 0);
-    }
-    let host = {
-        fileExists: ts.sys.fileExists,
-        getCompilationSettings: () => parsed.options,
-        getCurrentDirectory: () => root,
-        getDefaultLibFileName: ts.getDefaultLibFilePath,
-        getScriptFileNames: () => [...rootFiles],
-        getScriptSnapshot: (fileName) => {
-            let content = contents.get(fileName);
-            if (content !== undefined) {
-                return ts.ScriptSnapshot.fromString(content);
-            }
-            if (!ts.sys.fileExists(fileName)) {
-                return undefined;
-            }
-            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName) || '');
-        },
-        getScriptVersion: (fileName) => String(versions.get(fileName) || 0),
-        readFile: ts.sys.readFile
-    };
-    return { contents, host, rootFiles, service: ts.createLanguageService(host), versions };
+    let contents = new Map(), api = new API({ cwd: root, fs: overlayFileSystem(contents) }), snapshot = api.updateSnapshot({ openProjects: [configFileName] }), project = resolveProject(snapshot, configFileName);
+    for (let diagnostic of project.program.getConfigFileParsingDiagnostics()) {
+        if (diagnostic.category === DiagnosticCategory.Error) {
+            snapshot.dispose();
+            api.close();
+            throw new Error(`${PACKAGE_NAME}: error parsing tsconfig.json ${diagnostic.text}`);
+        }
+    }
+    return { api, configFileName, contents, pending: new Set(), project, root, seen: seed(project.program), snapshot };
+}
+function createScratch(file) {
+    let config = normalize(process.cwd()) + '/tsconfig.tsparse.json', contents = new Map();
+    contents.set(config, scratchConfig(file));
+    let api = new API({ cwd: process.cwd(), fs: overlayFileSystem(contents) }), snapshot = api.updateSnapshot({ openProjects: [config] }), project = resolveProject(snapshot, config);
+    return { api, config, contents, file, project, snapshot };
+}
+function disposeEntry(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+}
+function disposeScratch(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
 }
 function getEntry(root) {
     let entry = cache.get(root);
     if (!entry) {
-        entry = create(root);
+        entry = createEntry(root);
         cache.set(root, entry);
     }
     return entry;
 }
-const invalidate = (root, fileName) => {
+function normalize(fileName) {
+    return fileName.replace(backslashes, '/');
+}
+function overlayFileSystem(contents) {
+    return {
+        fileExists: (fileName) => {
+            if (contents.has(normalize(fileName))) {
+                return true;
+            }
+            return undefined;
+        },
+        getAccessibleEntries: (directoryName) => {
+            let directory = normalize(directoryName), extra = [];
+            for (let key of contents.keys()) {
+                if (key.slice(0, key.lastIndexOf('/')) === directory) {
+                    extra.push(key.slice(key.lastIndexOf('/') + 1));
+                }
+            }
+            if (extra.length === 0) {
+                return undefined;
+            }
+            let directories = [], files = [];
+            try {
+                for (let entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                    (entry.isDirectory() ? directories : files).push(entry.name);
+                }
+            }
+            catch {
+            }
+            return { directories, files: [...files, ...extra] };
+        },
+        readFile: (fileName) => {
+            let content = contents.get(normalize(fileName));
+            if (content !== undefined) {
+                return content;
+            }
+            return undefined;
+        }
+    };
+}
+function recreate(entry) {
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+    entry.api = new API({ cwd: entry.root, fs: overlayFileSystem(entry.contents) });
+    entry.snapshot = entry.api.updateSnapshot({ openProjects: [entry.configFileName] });
+    entry.project = resolveProject(entry.snapshot, entry.configFileName);
+    entry.seen = seed(entry.project.program);
+}
+function reseedScratch(entry, file) {
+    entry.contents.delete(entry.file);
+    entry.contents.set(entry.config, scratchConfig(file));
+    if (!entry.snapshot.isDisposed()) {
+        entry.snapshot.dispose();
+    }
+    entry.api.close();
+    entry.api = new API({ cwd: process.cwd(), fs: overlayFileSystem(entry.contents) });
+    entry.file = file;
+    entry.snapshot = entry.api.updateSnapshot({ openProjects: [entry.config] });
+    entry.project = resolveProject(entry.snapshot, entry.config);
+}
+function resolveProject(snapshot, configFileName) {
+    let project = snapshot.getProject(configFileName);
+    if (!project) {
+        throw new Error(`${PACKAGE_NAME}: project not found for ${configFileName}`);
+    }
+    return project;
+}
+function scratchConfig(file) {
+    return JSON.stringify({
+        compilerOptions: {
+            allowJs: true,
+            module: 'esnext',
+            moduleResolution: 'bundler',
+            skipLibCheck: true,
+            target: 'es2024'
+        },
+        files: [file]
+    });
+}
+function seed(program) {
+    let seen = new Set();
+    for (let name of program.getSourceFileNames()) {
+        seen.add(normalize(name));
+    }
+    return seen;
+}
+const dispose = (root) => {
+    if (root === undefined) {
+        for (let entry of cache.values()) {
+            disposeEntry(entry);
+        }
+        cache.clear();
+        if (scratchEntry) {
+            disposeScratch(scratchEntry);
+            scratchEntry = null;
+        }
+        return;
+    }
     let entry = cache.get(root);
     if (entry) {
-        let normalized = fileName.replace(/\\/g, '/');
-        entry.contents.delete(normalized);
-        entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
+        disposeEntry(entry);
+        cache.delete(root);
+    }
+};
+const findConfig = (startDir) => {
+    let current = path.resolve(startDir);
+    while (true) {
+        let candidate = path.join(current, 'tsconfig.json');
+        if (fs.existsSync(candidate)) {
+            return normalize(candidate);
+        }
+        let parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
     }
 };
+const invalidate = (root, fileName) => {
+    let entry = cache.get(root);
+    if (!entry) {
+        return;
+    }
+    let id = normalize(fileName);
+    entry.contents.delete(id);
+    entry.pending.add(id);
+};
+const parse = (fileName, content) => {
+    return scratch(fileName, content).sourceFile;
+};
+const scratch = (fileName, content) => {
+    let id = normalize(fileName), entry = advanceScratch(id, content), source = entry.project.program.getSourceFile(id);
+    if (!source) {
+        throw new Error(`${PACKAGE_NAME}: failed to parse ${fileName}`);
+    }
+    return { checker: entry.project.checker, program: entry.project.program, sourceFile: source };
+};
 const update = (root, fileName, content) => {
-    let entry = getEntry(root), normalized = fileName.replace(/\\/g, '/');
-    if (!entry.rootFiles.has(normalized)) {
-        entry.rootFiles.add(normalized);
+    let entry = getEntry(root), id = normalize(fileName);
+    entry.contents.set(id, content);
+    if (entry.seen.has(id)) {
+        entry.pending.add(id);
+        let changed = [...entry.pending];
+        entry.pending.clear();
+        advance(entry, changed);
+    }
+    else {
+        recreate(entry);
+        entry.pending.clear();
+        entry.seen.add(id);
     }
-    entry.contents.set(normalized, content);
-    entry.versions.set(normalized, (entry.versions.get(normalized) || 0) + 1);
-    let program = entry.service.getProgram();
-    if (!program) {
-        throw new Error(`${PACKAGE_NAME}: failed to get program from language service`);
+    let source = entry.project.program.getSourceFile(id);
+    if (!source || source.text !== content) {
+        throw new Error(`${PACKAGE_NAME}: failed to load ${fileName} into the program`);
     }
-    return program;
+    return { checker: entry.project.checker, program: entry.project.program };
 };
-export default { invalidate, update };
-export { invalidate, update };
+export default { dispose, findConfig, invalidate, parse, scratch, update };
+export { dispose, findConfig, invalidate, parse, scratch, update };

package/build/compiler/plugins/index.d.ts

@@ -7,12 +7,14 @@ declare const _default: {
     }) => ({ root }?: {
         root?: string;
     }) => {
+        closeBundle: () => void;
+        closeWatcher: () => void;
         configResolved: (config: unknown) => void;
-        enforce: "pre";
+        enforce: 'pre';
         name: string;
         transform: (code: string, id: string) => {
             code: string;
-            map: null;
+            map: import("../index.js").SourceMapV3;
         } | null;
         watchChange: (id: string) => void;
     };

package/build/compiler/plugins/tsc.d.ts

@@ -1,3 +1,3 @@
 import type { Plugin } from '../types.js';
-declare const _default: (plugins: Plugin[]) => () => Plugin[];
 export default _default;
+declare function _default(plugins: Plugin[]): () => Plugin[];

package/build/compiler/plugins/vite.d.ts

@@ -1,11 +1,14 @@
 import type { Plugin } from '../types.js';
+import type { SourceMapV3 } from '../sourcemap.js';
 type VitePlugin = {
+    closeBundle: () => void;
+    closeWatcher: () => void;
     configResolved: (config: unknown) => void;
     enforce: 'pre';
     name: string;
     transform: (code: string, id: string) => {
         code: string;
-        map: null;
+        map: SourceMapV3;
     } | null;
     watchChange: (id: string) => void;
 };
@@ -14,7 +17,7 @@ type VitePluginOptions = {
     onWatchChange?: () => void;
     plugins: Plugin[];
 };
-declare const _default: ({ name, onWatchChange, plugins }: VitePluginOptions) => ({ root }?: {
+export default _default;
+declare function _default({ name, onWatchChange, plugins }: VitePluginOptions): ({ root }?: {
     root?: string;
 }) => VitePlugin;
-export default _default;

package/build/compiler/plugins/vite.js

@@ -1,12 +1,20 @@
-import { ts } from '../../index.js';
 import coordinator from '../coordinator.js';
 import languageService from '../language-service.js';
+import sourcemap from '../sourcemap.js';
 const DIRECTORY_SEPARATOR_REGEX = /\\/g;
 const FILE_REGEX = /\.[tj]sx?$/;
 let contexts = new Map();
 export default ({ name, onWatchChange, plugins }) => {
     return ({ root } = {}) => {
         return {
+            closeBundle() {
+                languageService.dispose(root || '');
+                contexts.delete(root || '');
+            },
+            closeWatcher() {
+                languageService.dispose(root || '');
+                contexts.delete(root || '');
+            },
             configResolved(config) {
                 root ??= config.root;
             },
@@ -17,20 +25,17 @@ export default ({ name, onWatchChange, plugins }) => {
                     return null;
                 }
                 try {
-                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), prog = languageService.update(root || '', normalizedId, code), sourceFile = prog.getSourceFile(normalizedId);
-                    if (!sourceFile) {
-                        sourceFile = ts.createSourceFile(normalizedId, code, ts.ScriptTarget.Latest, true);
-                    }
+                    let normalizedId = id.replace(DIRECTORY_SEPARATOR_REGEX, '/'), { checker, program } = languageService.update(root || '', normalizedId, code), sourceFile = program.getSourceFile(normalizedId) ?? languageService.parse(normalizedId, code);
                     let key = root || '', ctx = contexts.get(key);
                     if (!ctx) {
                         ctx = new Map();
                         contexts.set(key, ctx);
                     }
-                    let result = coordinator.transform(plugins, code, sourceFile, prog, key, ctx);
+                    let result = coordinator.transform(plugins, code, sourceFile, { checker, program }, key, ctx);
                     if (!result.changed) {
                         return null;
                     }
-                    return { code: result.code, map: null };
+                    return { code: result.code, map: sourcemap.toSourceMapV3(result.map, result.code, code, normalizedId) };
                 }
                 catch (error) {
                     console.error(`${name}: error transforming ${id}:`, error);

package/build/compiler/sourcemap.d.ts

@@ -0,0 +1,50 @@
+type Edit = {
+    end: number;
+    newText: string;
+    start: number;
+};
+type OffsetAnchor = {
+    afterEnd: number;
+    afterStart: number;
+    beforeStart: number;
+    identity: boolean;
+};
+type PositionMapping = {
+    generations: OffsetAnchor[][];
+};
+type Segment = {
+    genColumn: number;
+    name?: number;
+    originalColumn?: number;
+    originalLine?: number;
+    source?: number;
+};
+type SourceMapV3 = {
+    file?: string;
+    mappings: string;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+};
+declare const buildGeneration: (beforeText: string, edits: Edit[]) => OffsetAnchor[];
+declare const composeEmittedMap: (map: SourceMapV3, mapping: PositionMapping, transformedText: string, originalText: string) => SourceMapV3;
+declare const decode: (mappings: string) => number[][][];
+declare const encode: (decoded: number[][][]) => string;
+declare const originalPositionFor: (mapping: PositionMapping, transformedText: string, originalText: string, line: number, column: number) => {
+    column: number;
+    line: number;
+};
+declare const toSourceMapV3: (mapping: PositionMapping, transformedText: string, originalText: string, source: string) => SourceMapV3;
+declare const _default: {
+    buildGeneration: typeof buildGeneration;
+    composeEmittedMap: typeof composeEmittedMap;
+    decode: typeof decode;
+    encode: typeof encode;
+    originalPositionFor: typeof originalPositionFor;
+    toSourceMapV3: typeof toSourceMapV3;
+};
+export default _default;
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };
+export type { Edit, OffsetAnchor, PositionMapping, Segment, SourceMapV3 };

package/build/compiler/sourcemap.js

@@ -0,0 +1,247 @@
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const CLASS_OTHER = 2;
+const CLASS_SPACE = 1;
+const CLASS_WORD = 0;
+let inverse = buildInverse();
+function buildInverse() {
+    let table = new Int8Array(128).fill(-1);
+    for (let i = 0, n = BASE64.length; i < n; i++) {
+        table[BASE64.charCodeAt(i)] = i;
+    }
+    return table;
+}
+function charClass(code) {
+    if ((code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 36 || code === 95) {
+        return CLASS_WORD;
+    }
+    if (code === 9 || code === 10 || code === 13 || code === 32) {
+        return CLASS_SPACE;
+    }
+    return CLASS_OTHER;
+}
+function decodeVlqArray(segment) {
+    let out = [], i = 0, n = segment.length;
+    while (i < n) {
+        let digit = 0, result = 0, shift = 0;
+        do {
+            digit = inverse[segment.charCodeAt(i)];
+            i++;
+            result += (digit & 31) << shift;
+            shift += 5;
+        } while (digit & 32);
+        out.push((result & 1) ? -(result >>> 1) : (result >>> 1));
+    }
+    return out;
+}
+function encodeVlq(value) {
+    let out = '', vlq = value < 0 ? ((-value) << 1) | 1 : value << 1;
+    do {
+        let digit = vlq & 31;
+        vlq >>>= 5;
+        if (vlq > 0) {
+            digit |= 32;
+        }
+        out += BASE64[digit];
+    } while (vlq > 0);
+    return out;
+}
+function lineStarts(text) {
+    let starts = [0];
+    for (let i = 0, n = text.length; i < n; i++) {
+        if (text.charCodeAt(i) === 10) {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+}
+function offsetToLineCol(starts, offset) {
+    let hi = starts.length - 1, line = 0, lo = 0;
+    while (lo <= hi) {
+        let mid = (lo + hi) >> 1;
+        if (starts[mid] <= offset) {
+            line = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return { column: offset - starts[line], line };
+}
+function rawToSegments(raw) {
+    let name = 0, origColumn = 0, origLine = 0, source = 0;
+    return raw.map((line) => {
+        let genColumn = 0;
+        return line.map((values) => {
+            genColumn += values[0];
+            let segment = { genColumn };
+            if (values.length >= 4) {
+                source += values[1];
+                origLine += values[2];
+                origColumn += values[3];
+                segment.originalColumn = origColumn;
+                segment.originalLine = origLine;
+                segment.source = source;
+                if (values.length >= 5) {
+                    name += values[4];
+                    segment.name = name;
+                }
+            }
+            return segment;
+        });
+    });
+}
+function resolveGeneration(anchors, offset) {
+    let found = anchors[0], hi = anchors.length - 1, lo = 0;
+    while (lo <= hi) {
+        let mid = (lo + hi) >> 1, anchor = anchors[mid];
+        if (offset < anchor.afterStart) {
+            hi = mid - 1;
+        }
+        else {
+            found = anchor;
+            lo = mid + 1;
+        }
+    }
+    if (found.identity) {
+        return found.beforeStart + (offset - found.afterStart);
+    }
+    return found.beforeStart;
+}
+function resolveOffset(mapping, offset) {
+    let generations = mapping.generations, result = offset;
+    for (let i = generations.length - 1; i >= 0; i--) {
+        result = resolveGeneration(generations[i], result);
+    }
+    return result;
+}
+function segmentAt(starts, offset, genColumn) {
+    let position = offsetToLineCol(starts, offset);
+    return { genColumn, originalColumn: position.column, originalLine: position.line, source: 0 };
+}
+function segmentsToRaw(segments) {
+    let name = 0, origColumn = 0, origLine = 0, source = 0;
+    return segments.map((line) => {
+        let genColumn = 0;
+        return line.map((segment) => {
+            let values = [segment.genColumn - genColumn];
+            genColumn = segment.genColumn;
+            if (segment.source !== undefined && segment.originalLine !== undefined && segment.originalColumn !== undefined) {
+                values.push(segment.source - source, segment.originalLine - origLine, segment.originalColumn - origColumn);
+                origColumn = segment.originalColumn;
+                origLine = segment.originalLine;
+                source = segment.source;
+                if (segment.name !== undefined) {
+                    values.push(segment.name - name);
+                    name = segment.name;
+                }
+            }
+            return values;
+        });
+    });
+}
+const buildGeneration = (beforeText, edits) => {
+    let afterCursor = 0, anchors = [], beforeCursor = 0, ordered = [...edits].sort((a, b) => a.start - b.start);
+    for (let i = 0, n = ordered.length; i < n; i++) {
+        let edit = ordered[i];
+        if (edit.start > beforeCursor) {
+            let length = edit.start - beforeCursor;
+            anchors.push({ afterEnd: afterCursor + length, afterStart: afterCursor, beforeStart: beforeCursor, identity: true });
+            afterCursor += length;
+        }
+        let inserted = edit.newText.length;
+        if (inserted > 0) {
+            anchors.push({ afterEnd: afterCursor + inserted, afterStart: afterCursor, beforeStart: edit.start, identity: false });
+            afterCursor += inserted;
+        }
+        beforeCursor = edit.end;
+    }
+    if (beforeCursor < beforeText.length) {
+        anchors.push({ afterEnd: afterCursor + (beforeText.length - beforeCursor), afterStart: afterCursor, beforeStart: beforeCursor, identity: true });
+    }
+    if (anchors.length === 0) {
+        anchors.push({ afterEnd: 0, afterStart: 0, beforeStart: 0, identity: true });
+    }
+    return anchors;
+};
+const composeEmittedMap = (map, mapping, transformedText, originalText) => {
+    let oStarts = lineStarts(originalText), segments = rawToSegments(decode(map.mappings)), tStarts = lineStarts(transformedText);
+    for (let i = 0, n = segments.length; i < n; i++) {
+        let line = segments[i];
+        for (let j = 0, m = line.length; j < m; j++) {
+            let segment = line[j];
+            if (segment.originalLine === undefined || segment.originalColumn === undefined) {
+                continue;
+            }
+            let base = segment.originalLine < tStarts.length ? tStarts[segment.originalLine] : transformedText.length, position = offsetToLineCol(oStarts, resolveOffset(mapping, base + segment.originalColumn));
+            segment.originalColumn = position.column;
+            segment.originalLine = position.line;
+        }
+    }
+    let composed = {
+        mappings: encode(segmentsToRaw(segments)),
+        names: map.names ?? [],
+        sources: map.sources,
+        version: 3
+    };
+    if (map.file !== undefined) {
+        composed.file = map.file;
+    }
+    if (map.sourceRoot !== undefined) {
+        composed.sourceRoot = map.sourceRoot;
+    }
+    return composed;
+};
+const decode = (mappings) => {
+    if (mappings === '') {
+        return [];
+    }
+    return mappings.split(';').map((line) => {
+        if (line === '') {
+            return [];
+        }
+        return line.split(',').map((segment) => decodeVlqArray(segment));
+    });
+};
+const encode = (decoded) => {
+    let lines = [];
+    for (let i = 0, n = decoded.length; i < n; i++) {
+        let parts = [], segments = decoded[i];
+        for (let j = 0, m = segments.length; j < m; j++) {
+            let encoded = '', values = segments[j];
+            for (let k = 0, o = values.length; k < o; k++) {
+                encoded += encodeVlq(values[k]);
+            }
+            parts.push(encoded);
+        }
+        lines.push(parts.join(','));
+    }
+    return lines.join(';');
+};
+const originalPositionFor = (mapping, transformedText, originalText, line, column) => {
+    let tStarts = lineStarts(transformedText), base = line < tStarts.length ? tStarts[line] : transformedText.length;
+    return offsetToLineCol(lineStarts(originalText), resolveOffset(mapping, base + column));
+};
+const toSourceMapV3 = (mapping, transformedText, originalText, source) => {
+    let oStarts = lineStarts(originalText), segments = [], tStarts = lineStarts(transformedText);
+    for (let line = 0, n = tStarts.length; line < n; line++) {
+        let end = line + 1 < n ? tStarts[line + 1] - 1 : transformedText.length, previous = resolveOffset(mapping, tStarts[line]), start = tStarts[line];
+        let row = [segmentAt(oStarts, previous, 0)];
+        for (let offset = start + 1; offset < end; offset++) {
+            let current = charClass(transformedText.charCodeAt(offset));
+            if (current !== CLASS_OTHER && current === charClass(transformedText.charCodeAt(offset - 1))) {
+                continue;
+            }
+            let resolved = resolveOffset(mapping, offset);
+            if (resolved === previous) {
+                continue;
+            }
+            previous = resolved;
+            row.push(segmentAt(oStarts, resolved, offset - start));
+        }
+        segments.push(row);
+    }
+    return { mappings: encode(segmentsToRaw(segments)), names: [], sources: [source], version: 3 };
+};
+export default { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, toSourceMapV3 };