iobroker.javascript 10.0.0 → 10.1.0

package/build/lib/typescriptSettings.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsDeclarationCompilerOptions = exports.tsCompilerOptions = exports.targetTsLib = void 0;
+exports.jsDeclarationCompilerOptions = exports.tsCompilerOptions = exports.TS_TARGETS = exports.targetTsLib = void 0;
+exports.getTargetTsLib = getTargetTsLib;
+exports.getTsCompilerOptions = getTsCompilerOptions;
 const typescript_1 = require("typescript");
 // Node.js 18+ supports the features of ES2022
 // consider changing this, so we get to support the newest features too
 exports.targetTsLib = 'es2022';
+/** All targets that may be selected in the instance configuration */
+exports.TS_TARGETS = {
+    es2018: typescript_1.ScriptTarget.ES2018,
+    es2019: typescript_1.ScriptTarget.ES2019,
+    es2020: typescript_1.ScriptTarget.ES2020,
+    es2021: typescript_1.ScriptTarget.ES2021,
+    es2022: typescript_1.ScriptTarget.ES2022,
+    es2023: typescript_1.ScriptTarget.ES2023,
+    es2024: typescript_1.ScriptTarget.ES2024,
+    es2025: typescript_1.ScriptTarget.ES2025,
+    esnext: typescript_1.ScriptTarget.ESNext,
+};
 exports.tsCompilerOptions = {
+    // TypeScript 6 enables `strict` by default. That would break virtually every existing user
+    // script (implicit any parameters, strict null checks), so keep the pre-TS6 behavior.
+    // Can be re-enabled per instance in the "TypeScript" tab of the adapter settings.
+    strict: false,
     // don't compile faulty scripts
     noEmitOnError: true,
     // emit declarations for global scripts
@@ -22,7 +40,7 @@ exports.tsCompilerOptions = {
     // Node.js 18+ runs ES2022 natively, so nothing has to be downleveled. This also makes
     // `downlevelIteration` obsolete - QueryResults stays iterable without it
     // (https://github.com/ioBroker/ioBroker.javascript/pull/663#issuecomment-721645705).
-    target: typescript_1.ScriptTarget.ES2022,
+    target: exports.TS_TARGETS[exports.targetTsLib],
     // From ES2022 on, TypeScript would emit class fields as native declarations ([[Define]]
     // semantics). Keep the previous assignment semantics (`this.x = ...` in the constructor),
     // so existing user scripts behave unchanged.
@@ -42,4 +60,96 @@ exports.jsDeclarationCompilerOptions = {
     noImplicitAny: false,
     strict: false,
 };
+/**
+ * Applies a checkbox option from the instance configuration.
+ * An option that is missing (configuration of an older version) keeps the value the adapter ships with.
+ *
+ * @param options The compiler options to modify
+ * @param name Name of the compiler option
+ * @param value Value from the instance configuration
+ */
+function applyBoolean(options, name, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    options[name] = !!value;
+}
+/**
+ * Applies a tri-state option from the instance configuration.
+ * An empty selection removes the option, so it follows `strict` (resp. the TypeScript default).
+ * An option that is missing (configuration of an older version) keeps the value the adapter ships with.
+ *
+ * @param options The compiler options to modify
+ * @param name Name of the compiler option
+ * @param value Value from the instance configuration
+ */
+function applyTriState(options, name, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (value === '') {
+        delete options[name];
+        return;
+    }
+    options[name] = value === 'true';
+}
+/**
+ * Determines the ECMAScript version the user scripts are compiled for
+ *
+ * @param config The instance configuration
+ */
+function getTargetTsLib(config) {
+    const target = config?.tsTarget?.toLowerCase();
+    return target && exports.TS_TARGETS[target] !== undefined ? target : exports.targetTsLib;
+}
+/**
+ * Builds the compiler options for the user scripts out of the instance configuration.
+ * Everything that is not configured stays at the value the adapter ships with.
+ *
+ * @param config The instance configuration
+ */
+function getTsCompilerOptions(config) {
+    const tsLib = getTargetTsLib(config);
+    const options = {
+        ...exports.tsCompilerOptions,
+        target: exports.TS_TARGETS[tsLib],
+        lib: [`lib.${tsLib}.d.ts`],
+    };
+    if (!config) {
+        return options;
+    }
+    // Strict type checking
+    applyBoolean(options, 'strict', config.tsStrict);
+    applyTriState(options, 'noImplicitAny', config.tsNoImplicitAny);
+    applyTriState(options, 'strictNullChecks', config.tsStrictNullChecks);
+    applyTriState(options, 'strictFunctionTypes', config.tsStrictFunctionTypes);
+    applyTriState(options, 'strictBindCallApply', config.tsStrictBindCallApply);
+    applyTriState(options, 'strictPropertyInitialization', config.tsStrictPropertyInitialization);
+    applyTriState(options, 'strictBuiltinIteratorReturn', config.tsStrictBuiltinIteratorReturn);
+    applyTriState(options, 'noImplicitThis', config.tsNoImplicitThis);
+    applyTriState(options, 'alwaysStrict', config.tsAlwaysStrict);
+    applyTriState(options, 'useUnknownInCatchVariables', config.tsUseUnknownInCatchVariables);
+    // Additional checks
+    applyBoolean(options, 'noUnusedLocals', config.tsNoUnusedLocals);
+    applyBoolean(options, 'noUnusedParameters', config.tsNoUnusedParameters);
+    applyBoolean(options, 'noImplicitReturns', config.tsNoImplicitReturns);
+    applyBoolean(options, 'noFallthroughCasesInSwitch', config.tsNoFallthroughCasesInSwitch);
+    applyBoolean(options, 'noImplicitOverride', config.tsNoImplicitOverride);
+    applyBoolean(options, 'noUncheckedIndexedAccess', config.tsNoUncheckedIndexedAccess);
+    applyBoolean(options, 'noPropertyAccessFromIndexSignature', config.tsNoPropertyAccessFromIndexSignature);
+    applyBoolean(options, 'exactOptionalPropertyTypes', config.tsExactOptionalPropertyTypes);
+    applyTriState(options, 'allowUnreachableCode', config.tsAllowUnreachableCode);
+    applyTriState(options, 'allowUnusedLabels', config.tsAllowUnusedLabels);
+    // Language and emit
+    applyBoolean(options, 'noEmitOnError', config.tsNoEmitOnError);
+    applyBoolean(options, 'esModuleInterop', config.tsEsModuleInterop);
+    applyBoolean(options, 'allowSyntheticDefaultImports', config.tsAllowSyntheticDefaultImports);
+    applyBoolean(options, 'useDefineForClassFields', config.tsUseDefineForClassFields);
+    applyBoolean(options, 'downlevelIteration', config.tsDownlevelIteration);
+    applyBoolean(options, 'experimentalDecorators', config.tsExperimentalDecorators);
+    applyBoolean(options, 'emitDecoratorMetadata', config.tsEmitDecoratorMetadata);
+    applyBoolean(options, 'removeComments', config.tsRemoveComments);
+    applyBoolean(options, 'skipLibCheck', config.tsSkipLibCheck);
+    return options;
+}
 //# sourceMappingURL=typescriptSettings.js.map

package/build/lib/typescriptSettings.js.map

@@ -1 +1 @@
-{"version":3,"file":"typescriptSettings.js","sourceRoot":"","sources":["../../src/lib/typescriptSettings.ts"],"names":[],"mappings":";;;AAAA,2CAA4E;AAE5E,8CAA8C;AAC9C,uEAAuE;AAC1D,QAAA,WAAW,GAAG,QAAQ,CAAC;AAEvB,QAAA,iBAAiB,GAAoB;IAC9C,+BAA+B;IAC/B,aAAa,EAAE,IAAI;IACnB,uCAAuC;IACvC,WAAW,EAAE,IAAI;IACjB,wEAAwE;IACxE,eAAe,EAAE,IAAI;IACrB,2EAA2E;IAC3E,4BAA4B;IAC5B,0BAA0B,EAAE,KAAK;IACjC,8FAA8F;IAC9F,gGAAgG;IAChG,+FAA+F;IAC/F,MAAM,EAAE,uBAAU,CAAC,QAAQ;IAC3B,sFAAsF;IACtF,yEAAyE;IACzE,qFAAqF;IACrF,MAAM,EAAE,yBAAY,CAAC,MAAM;IAC3B,wFAAwF;IACxF,0FAA0F;IAC1F,6CAA6C;IAC7C,uBAAuB,EAAE,KAAK;IAC9B,6FAA6F;IAC7F,6FAA6F;IAC7F,gCAAgC;IAChC,kBAAkB,EAAE,KAAK;IACzB,GAAG,EAAE,CAAC,OAAO,mBAAW,OAAO,CAAC;CACnC,CAAC;AAEW,QAAA,4BAA4B,GAAoB;IACzD,GAAG,yBAAiB;IACpB,sCAAsC;IACtC,mBAAmB,EAAE,IAAI;IACzB,eAAe;IACf,aAAa,EAAE,KAAK;IACpB,aAAa,EAAE,KAAK;IACpB,MAAM,EAAE,KAAK;CAChB,CAAC","sourcesContent":["import { type CompilerOptions, ModuleKind, ScriptTarget } from 'typescript';\n\n// Node.js 18+ supports the features of ES2022\n// consider changing this, so we get to support the newest features too\nexport const targetTsLib = 'es2022';\n\nexport const tsCompilerOptions: CompilerOptions = {\n    // don't compile faulty scripts\n    noEmitOnError: true,\n    // emit declarations for global scripts\n    declaration: true,\n    // This enables TS users to `import * as ... from` and `import ... from`\n    esModuleInterop: true,\n    // This flag was introduced in TS 4.4 and may break a lot of legacy scripts\n    // Better keep it turned off\n    useUnknownInCatchVariables: false,\n    // Scripts are executed as a Node.js `vm.Script`, which does not support the `import` keyword,\n    // so the emitted code must be CommonJS. This has to be set explicitly: TypeScript only defaults\n    // `module` to CommonJS for the ES5/ES3 targets and would emit ES modules for the target below.\n    module: ModuleKind.CommonJS,\n    // Node.js 18+ runs ES2022 natively, so nothing has to be downleveled. This also makes\n    // `downlevelIteration` obsolete - QueryResults stays iterable without it\n    // (https://github.com/ioBroker/ioBroker.javascript/pull/663#issuecomment-721645705).\n    target: ScriptTarget.ES2022,\n    // From ES2022 on, TypeScript would emit class fields as native declarations ([[Define]]\n    // semantics). Keep the previous assignment semantics (`this.x = ...` in the constructor),\n    // so existing user scripts behave unchanged.\n    useDefineForClassFields: false,\n    // `virtual-tsc` overwrites `moduleResolution` with \"node10\", which TypeScript 6 reports as a\n    // deprecation error. It cannot be configured from here, so deprecations have to be tolerated\n    // until that is fixed upstream.\n    ignoreDeprecations: '6.0',\n    lib: [`lib.${targetTsLib}.d.ts`],\n};\n\nexport const jsDeclarationCompilerOptions: CompilerOptions = {\n    ...tsCompilerOptions,\n    // we only care about the declarations\n    emitDeclarationOnly: true,\n    // allow errors\n    noEmitOnError: false,\n    noImplicitAny: false,\n    strict: false,\n};\n"]}
+{"version":3,"file":"typescriptSettings.js","sourceRoot":"","sources":["../../src/lib/typescriptSettings.ts"],"names":[],"mappings":"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","sourcesContent":["import { type CompilerOptions, ModuleKind, ScriptTarget } from 'typescript';\nimport type { JavaScriptAdapterConfig, TsTarget, TsTriState } from '../types';\n\n// Node.js 18+ supports the features of ES2022\n// consider changing this, so we get to support the newest features too\nexport const targetTsLib: TsTarget = 'es2022';\n\n/** All targets that may be selected in the instance configuration */\nexport const TS_TARGETS: Record<TsTarget, ScriptTarget> = {\n    es2018: ScriptTarget.ES2018,\n    es2019: ScriptTarget.ES2019,\n    es2020: ScriptTarget.ES2020,\n    es2021: ScriptTarget.ES2021,\n    es2022: ScriptTarget.ES2022,\n    es2023: ScriptTarget.ES2023,\n    es2024: ScriptTarget.ES2024,\n    es2025: ScriptTarget.ES2025,\n    esnext: ScriptTarget.ESNext,\n};\n\nexport const tsCompilerOptions: CompilerOptions = {\n    // TypeScript 6 enables `strict` by default. That would break virtually every existing user\n    // script (implicit any parameters, strict null checks), so keep the pre-TS6 behavior.\n    // Can be re-enabled per instance in the \"TypeScript\" tab of the adapter settings.\n    strict: false,\n    // don't compile faulty scripts\n    noEmitOnError: true,\n    // emit declarations for global scripts\n    declaration: true,\n    // This enables TS users to `import * as ... from` and `import ... from`\n    esModuleInterop: true,\n    // This flag was introduced in TS 4.4 and may break a lot of legacy scripts\n    // Better keep it turned off\n    useUnknownInCatchVariables: false,\n    // Scripts are executed as a Node.js `vm.Script`, which does not support the `import` keyword,\n    // so the emitted code must be CommonJS. This has to be set explicitly: TypeScript only defaults\n    // `module` to CommonJS for the ES5/ES3 targets and would emit ES modules for the target below.\n    module: ModuleKind.CommonJS,\n    // Node.js 18+ runs ES2022 natively, so nothing has to be downleveled. This also makes\n    // `downlevelIteration` obsolete - QueryResults stays iterable without it\n    // (https://github.com/ioBroker/ioBroker.javascript/pull/663#issuecomment-721645705).\n    target: TS_TARGETS[targetTsLib],\n    // From ES2022 on, TypeScript would emit class fields as native declarations ([[Define]]\n    // semantics). Keep the previous assignment semantics (`this.x = ...` in the constructor),\n    // so existing user scripts behave unchanged.\n    useDefineForClassFields: false,\n    // `virtual-tsc` overwrites `moduleResolution` with \"node10\", which TypeScript 6 reports as a\n    // deprecation error. It cannot be configured from here, so deprecations have to be tolerated\n    // until that is fixed upstream.\n    ignoreDeprecations: '6.0',\n    lib: [`lib.${targetTsLib}.d.ts`],\n};\n\nexport const jsDeclarationCompilerOptions: CompilerOptions = {\n    ...tsCompilerOptions,\n    // we only care about the declarations\n    emitDeclarationOnly: true,\n    // allow errors\n    noEmitOnError: false,\n    noImplicitAny: false,\n    strict: false,\n};\n\n/**\n * Applies a checkbox option from the instance configuration.\n * An option that is missing (configuration of an older version) keeps the value the adapter ships with.\n *\n * @param options The compiler options to modify\n * @param name Name of the compiler option\n * @param value Value from the instance configuration\n */\nfunction applyBoolean(options: CompilerOptions, name: keyof CompilerOptions, value: boolean | undefined): void {\n    if (value === undefined || value === null) {\n        return;\n    }\n    (options as Record<string, unknown>)[name] = !!value;\n}\n\n/**\n * Applies a tri-state option from the instance configuration.\n * An empty selection removes the option, so it follows `strict` (resp. the TypeScript default).\n * An option that is missing (configuration of an older version) keeps the value the adapter ships with.\n *\n * @param options The compiler options to modify\n * @param name Name of the compiler option\n * @param value Value from the instance configuration\n */\nfunction applyTriState(options: CompilerOptions, name: keyof CompilerOptions, value: TsTriState | undefined): void {\n    if (value === undefined || value === null) {\n        return;\n    }\n    if (value === '') {\n        delete (options as Record<string, unknown>)[name];\n        return;\n    }\n    (options as Record<string, unknown>)[name] = value === 'true';\n}\n\n/**\n * Determines the ECMAScript version the user scripts are compiled for\n *\n * @param config The instance configuration\n */\nexport function getTargetTsLib(config?: Partial<JavaScriptAdapterConfig>): TsTarget {\n    const target = config?.tsTarget?.toLowerCase() as TsTarget;\n\n    return target && TS_TARGETS[target] !== undefined ? target : targetTsLib;\n}\n\n/**\n * Builds the compiler options for the user scripts out of the instance configuration.\n * Everything that is not configured stays at the value the adapter ships with.\n *\n * @param config The instance configuration\n */\nexport function getTsCompilerOptions(config?: Partial<JavaScriptAdapterConfig>): CompilerOptions {\n    const tsLib = getTargetTsLib(config);\n    const options: CompilerOptions = {\n        ...tsCompilerOptions,\n        target: TS_TARGETS[tsLib],\n        lib: [`lib.${tsLib}.d.ts`],\n    };\n\n    if (!config) {\n        return options;\n    }\n\n    // Strict type checking\n    applyBoolean(options, 'strict', config.tsStrict);\n    applyTriState(options, 'noImplicitAny', config.tsNoImplicitAny);\n    applyTriState(options, 'strictNullChecks', config.tsStrictNullChecks);\n    applyTriState(options, 'strictFunctionTypes', config.tsStrictFunctionTypes);\n    applyTriState(options, 'strictBindCallApply', config.tsStrictBindCallApply);\n    applyTriState(options, 'strictPropertyInitialization', config.tsStrictPropertyInitialization);\n    applyTriState(options, 'strictBuiltinIteratorReturn', config.tsStrictBuiltinIteratorReturn);\n    applyTriState(options, 'noImplicitThis', config.tsNoImplicitThis);\n    applyTriState(options, 'alwaysStrict', config.tsAlwaysStrict);\n    applyTriState(options, 'useUnknownInCatchVariables', config.tsUseUnknownInCatchVariables);\n\n    // Additional checks\n    applyBoolean(options, 'noUnusedLocals', config.tsNoUnusedLocals);\n    applyBoolean(options, 'noUnusedParameters', config.tsNoUnusedParameters);\n    applyBoolean(options, 'noImplicitReturns', config.tsNoImplicitReturns);\n    applyBoolean(options, 'noFallthroughCasesInSwitch', config.tsNoFallthroughCasesInSwitch);\n    applyBoolean(options, 'noImplicitOverride', config.tsNoImplicitOverride);\n    applyBoolean(options, 'noUncheckedIndexedAccess', config.tsNoUncheckedIndexedAccess);\n    applyBoolean(options, 'noPropertyAccessFromIndexSignature', config.tsNoPropertyAccessFromIndexSignature);\n    applyBoolean(options, 'exactOptionalPropertyTypes', config.tsExactOptionalPropertyTypes);\n    applyTriState(options, 'allowUnreachableCode', config.tsAllowUnreachableCode);\n    applyTriState(options, 'allowUnusedLabels', config.tsAllowUnusedLabels);\n\n    // Language and emit\n    applyBoolean(options, 'noEmitOnError', config.tsNoEmitOnError);\n    applyBoolean(options, 'esModuleInterop', config.tsEsModuleInterop);\n    applyBoolean(options, 'allowSyntheticDefaultImports', config.tsAllowSyntheticDefaultImports);\n    applyBoolean(options, 'useDefineForClassFields', config.tsUseDefineForClassFields);\n    applyBoolean(options, 'downlevelIteration', config.tsDownlevelIteration);\n    applyBoolean(options, 'experimentalDecorators', config.tsExperimentalDecorators);\n    applyBoolean(options, 'emitDecoratorMetadata', config.tsEmitDecoratorMetadata);\n    applyBoolean(options, 'removeComments', config.tsRemoveComments);\n    applyBoolean(options, 'skipLibCheck', config.tsSkipLibCheck);\n\n    return options;\n}\n"]}

package/build/lib/typescriptTools.js

@@ -9,6 +9,12 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const typescript_1 = require("typescript");
 const tools_1 = require("./tools");
+/**
+ * The transformed sources are stored in the ioBroker database and mirrored to disk, so they must
+ * not depend on the platform or on a TypeScript default. TypeScript 5 printed CRLF here and
+ * TypeScript 6 prints LF - pinning it keeps a compiler update from silently rewriting every script.
+ */
+const PRINTER_OPTIONS = { newLine: typescript_1.NewLineKind.LineFeed };
 /**
  * Resolves all TypeScript lib files for the editor
  *
@@ -49,41 +55,117 @@ function normalizeDTSImport(filename) {
     return (0, node_path_1.join)(filename, 'index.d.ts');
 }
 /**
- * Resolves the type declarations of a 3rd party package for the editor
+ * Wraps a package's root declarations in `declare module "<pkg>"` if - and only if - they are not a
+ * module themselves.
+ *
+ * This used to be applied to every package. That broke all of them that ship real typings: inside an
+ * ambient module declaration TypeScript does not resolve the relative paths a barrel file re-exports
+ * from, so every name the package exported became `any` - which is why type inference never worked
+ * for e.g. rxjs (https://github.com/ioBroker/ioBroker.javascript/issues/2341). Such a file is now
+ * left alone and found through ordinary module resolution.
+ *
+ * A declaration file without any top-level `import`/`export` is a script, not a module, and
+ * `import ... from "<pkg>"` would not accept it. Those still need the wrapper - and having no
+ * imports, they cannot suffer from the problem above.
+ *
+ * A file that only points at other files (`@types/node` is nothing but `/// <reference path>` lines)
+ * is left alone as well: the wrapper would cut those references off from the global scope they are
+ * meant to populate.
+ *
+ * @param pkg The package the declarations belong to
+ * @param content The content of the root declaration file
+ */
+function wrapRootTypingsIfNeeded(pkg, content) {
+    const isModule = /^\s*(?:import|export)\b/m.test(content);
+    const isAmbientDeclaration = /^\s*declare module/m.test(content);
+    const referencesOtherFiles = /\/\/\/\s*<reference path=/.test(content);
+    return isModule || isAmbientDeclaration || referencesOtherFiles
+        ? content
+        : `declare module "${pkg}" { ${content} }`;
+}
+/**
+ * Finds the package.json of a package on disk.
+ *
+ * `require.resolve("<pkg>/package.json")` goes through Node's module resolution, and a package with
+ * an `exports` map that does not list `./package.json` makes that throw - which is common enough
+ * among modern packages to matter. The directories Node would have searched are then looked at
+ * directly, which no `exports` map can hide.
+ *
+ * @param pkg The package to look for
+ */
+function findPackageJson(pkg) {
+    try {
+        return require.resolve(`${pkg}/package.json`);
+    }
+    catch {
+        // the package may be there but refuse to hand out its manifest
+    }
+    return (require.resolve.paths(pkg) || [])
+        .map(dir => (0, node_path_1.join)(dir, pkg, 'package.json'))
+        .find(candidate => (0, node_fs_1.existsSync)(candidate));
+}
+/**
+ * Finds the declaration entry point of a package.
+ *
+ * A package that ships an `exports` map often keeps the legacy `types` field only as a stub - rxjs 7
+ * declares `"types": "index.d.ts"` although no such file exists and the real declarations sit in
+ * `./dist/types/`. A candidate therefore only counts if the file is really there
+ * (https://github.com/ioBroker/ioBroker.javascript/issues/928).
+ *
+ * @param packageJson The parsed package.json
+ * @param packageRoot The directory that package.json lives in
+ */
+function findRootTypings(packageJson, packageRoot) {
+    const mainExport = packageJson.exports?.['.'];
+    const fromExports = mainExport && typeof mainExport === 'object'
+        ? (mainExport.types ??
+            mainExport.require?.types ??
+            mainExport.import?.types ??
+            mainExport.default?.types)
+        : undefined;
+    // the legacy fields come first: they are what a package without an `exports` map has, and where
+    // both exist they agree
+    return [packageJson.types, packageJson.typings, fromExports].find(candidate => typeof candidate === 'string' && (0, node_fs_1.existsSync)(normalizeDTSImport((0, node_path_1.join)(packageRoot, candidate))));
+}
+/**
+ * Resolves the type declarations of a 3rd party package for the editor and the compiler
+ *
+ * The declarations are handed to TypeScript as a virtual file system. They are placed under the name
+ * the *scripts* import - `node_modules/rxjs/...` - not under the name the package has on disk: the
+ * js-controller installs script libraries under an adapter-scoped alias, and TypeScript has to
+ * resolve `import ... from "rxjs"` against these files.
  *
  * @param pkg The package whose typings we're interested in
  * @param adapterScopedPackageName the package name on the system
- * @param wrapInDeclareModule Whether the root file should be wrapped in `declare module "<pkg>" { ... }`
  * @returns The found declarations or undefined if none were found
  */
-function resolveTypings(pkg, adapterScopedPackageName, wrapInDeclareModule) {
+function resolveTypings(pkg, adapterScopedPackageName) {
     let packageJsonPath;
     let packageJson;
     let rootTypings;
     let pkgIncludesTypings = true;
-    function tryToLoadPackage(path) {
+    function tryToLoadPackage(name) {
+        const found = findPackageJson(name);
+        if (!found) {
+            return;
+        }
         try {
-            packageJsonPath = require.resolve(path);
-            packageJson = require(packageJsonPath);
-            rootTypings =
-                typeof packageJson.types === 'string'
-                    ? packageJson.types
-                    : typeof packageJson.typings === 'string'
-                        ? packageJson.typings
-                        : undefined;
+            packageJsonPath = found;
+            packageJson = require(found);
+            rootTypings = findRootTypings(packageJson, (0, node_path_1.dirname)(found));
         }
         catch {
             /* ignore */
         }
     }
     // First, try to resolve the package itself in case it brings its own typings
-    tryToLoadPackage(`${adapterScopedPackageName}/package.json`);
+    tryToLoadPackage(adapterScopedPackageName);
     if (!rootTypings) {
-        tryToLoadPackage(`${pkg}/package.json`);
+        tryToLoadPackage(pkg);
     }
     // If that didn't work, try again with the @types version of the package
     if (!rootTypings) {
-        tryToLoadPackage(`@types/${pkg}/package.json`);
+        tryToLoadPackage(`@types/${pkg}`);
         pkgIncludesTypings = false;
     }
     // TODO: If that didn't work, download @types/<packagename> and retry the previous step
@@ -95,56 +177,99 @@ function resolveTypings(pkg, adapterScopedPackageName, wrapInDeclareModule) {
         return undefined;
     }
     const packageRoot = (0, node_path_1.dirname)(packageJsonPath);
-    const normalizeImportPath = (filename) => (0, node_path_1.normalize)(`node_modules/${pkgIncludesTypings ? adapterScopedPackageName : `@types/${pkg}`}/${(0, node_path_1.relative)(packageRoot, filename)}`).replace(/\\/g, '/');
-    const ret = {};
-    // We need to look at `import/export ... from 'modulename'` and `/// <reference path='...' />`
-    const importDtsRegex = /^\s*(?:import|export) .+ from ["'](\.+\/[^"']+)["']/g;
+    /**
+     * The directory the declarations get in the virtual file system. It has to be the one the
+     * `package.json` below is written to, otherwise TypeScript reads that file, follows its `types`
+     * entry and finds nothing - which used to leave every import from the package typed as `any`.
+     */
+    const virtualPackageDir = `node_modules/${pkgIncludesTypings ? '' : '@types/'}${pkg}`;
+    // We need to look at everything that names another file of the package: `import ... from "./x"`,
+    // `export ... from "./x"`, the side effect import `import "./x"`, `import x = require("./x")`,
+    // and `/// <reference path='...' />`.
+    //
+    // The `m` flag is what makes `^` match every line instead of only the start of the file. Without
+    // it, exactly one import per file was followed - and only if it happened to be the first thing in
+    // it. For rxjs 6 that collected 6 of its ~800 declaration files.
+    //
+    // Everything between the keyword and the path is skipped, so the shape of the import does not
+    // matter and it may span several lines. `[^;]` stops that at the statement's semicolon, so a
+    // match can never run into the next statement.
+    const importDtsRegex = /^\s*(?:import|export)\s[^;]*?["'](\.+\/[^"']+)["']/gm;
     const pathReferenceRegex = /\/\/\/ <reference path=["']([^"']+)["'] \/>/g;
     const matchAllImports = (str) => [...(0, tools_1.matchAll)(importDtsRegex, str), ...(0, tools_1.matchAll)(pathReferenceRegex, str)].map(groups => groups[0]);
     // the paths are relative to the package.json - we need an absolute path to read the files
     rootTypings = (0, node_path_1.join)(packageRoot, rootTypings);
     // some @types packages specify `index` as their typings file instead of `index.d.ts`
     rootTypings = normalizeDTSImport(rootTypings);
-    // include package.json in typings, so TypeScript can look up the correct entry point
-    const relativePath = `node_modules/${pkgIncludesTypings ? '' : '@types/'}${pkg}/package.json`.replace(/\\/g, '/');
-    ret[relativePath] = JSON.stringify(packageJson);
-    // Used to test whether a .d.ts file already uses "declare module" or not
-    const declareModuleRegex = /^\s*declare module/gm;
-    // recursively load all typings
+    // recursively load all typings, keyed by their location on disk
+    const collected = new Map();
     const definitionQueue = [rootTypings];
     while (definitionQueue.length > 0) {
         const filename = definitionQueue.shift();
-        const dirName = (0, node_path_1.dirname)(filename);
-        // Read the file and remember it in the return dictionary
+        if (collected.has(filename)) {
+            continue;
+        }
         let fileContent;
         try {
             fileContent = (0, node_fs_1.readFileSync)(filename, 'utf8');
         }
         catch (e) {
-            // The typings are malformed
-            console.error(`Failed to load definitions for ${pkg}: ${e.toString()}`);
-            // Since we cannot use them, return undefined
-            return undefined;
+            // Without the entry point there is nothing to hand to TypeScript
+            if (filename === rootTypings) {
+                console.error(`Failed to load definitions for ${pkg}: ${e.toString()}`);
+                return undefined;
+            }
+            // A referenced file was there a moment ago but cannot be read now. Dropping every
+            // declaration of the package over one unreadable file would be out of proportion.
+            console.warn(`Skipped a definition file of ${pkg}: ${e.toString()}`);
+            continue;
         }
-        // We need to store the filename relative to the base dir
-        const relativePath = normalizeImportPath(filename);
-        // If necessary, wrap the root typings (only those!)
-        ret[relativePath] =
-            wrapInDeclareModule && filename === rootTypings && !declareModuleRegex.test(fileContent)
-                ? `declare module "${pkg}" { ${fileContent} }`
-                : fileContent;
+        collected.set(filename, fileContent);
         // If this file references another .d.ts file, we need to load that too
         matchAllImports(fileContent)
             // resolve the file relative to the current directory
-            .map(file => (0, node_path_1.join)(dirName, file))
+            .map(file => (0, node_path_1.join)((0, node_path_1.dirname)(filename), file))
             // find out the correct path of the file we want to import
             .map(normalizeDTSImport)
+            // A package may import something it does not ship declarations for, and the matcher
+            // above may pick up a string that only looks like a path
+            .filter(file => (0, node_fs_1.existsSync)(file))
             // Find all libs we have not loaded yet
-            .filter(file => !(normalizeImportPath(file) in ret))
+            .filter(file => !collected.has(file))
             .forEach(file => definitionQueue.push(file));
     }
+    /**
+     * The directory that becomes `node_modules/<pkg>` in the virtual file system.
+     *
+     * `virtual-tsc` resolves with `moduleResolution: node10`, which looks the entry point up next to
+     * the package - so laying the files out around the entry point rather than around the
+     * package.json is what makes a package work whose declarations sit in a subdirectory. For a
+     * package whose entry point is at its root - the usual case - this is the package root and
+     * nothing changes.
+     */
+    let virtualRoot = (0, node_path_1.dirname)(rootTypings);
+    if ([...collected.keys()].some(file => (0, node_path_1.relative)(virtualRoot, file).startsWith('..'))) {
+        // Declarations reach above the entry point. Moving them would break the relative imports
+        // between them, so the layout of the package is kept as it is.
+        virtualRoot = packageRoot;
+    }
+    const toVirtualPath = (filename) => (0, node_path_1.normalize)(`${virtualPackageDir}/${(0, node_path_1.relative)(virtualRoot, filename)}`).replace(/\\/g, '/');
+    const ret = {};
+    for (const [filename, fileContent] of collected) {
+        ret[toVirtualPath(filename)] =
+            filename === rootTypings ? wrapRootTypingsIfNeeded(pkg, fileContent) : fileContent;
+    }
+    // Include a package.json, so TypeScript can look up the entry point. It describes the layout
+    // above, not the one the package has on disk - and it is deliberately minimal: the original
+    // `exports` map refers to paths that do not exist here, and TypeScript refuses to resolve the
+    // package at all when it finds one it cannot follow under `moduleResolution: node10`.
+    ret[`${virtualPackageDir}/package.json`] = JSON.stringify({
+        name: pkg,
+        version: packageJson?.version,
+        types: `./${(0, node_path_1.relative)(virtualRoot, rootTypings).replace(/\\/g, '/')}`,
+    });
     // Avoid returning empty declarations
-    if (Object.keys(ret).length === 0) {
+    if (!collected.size) {
         return undefined;
     }
     return ret;
@@ -386,7 +511,7 @@ function transformScriptBeforeCompilation(source, isGlobal) {
     };
     const sourceFile = (0, typescript_1.createSourceFile)('index.ts', source, typescript_1.ScriptTarget.ESNext, /* setParentNodes */ true);
     const result = (0, typescript_1.transform)(sourceFile, [transformer]);
-    return (0, typescript_1.createPrinter)().printNode(typescript_1.EmitHint.Unspecified, result.transformed[0], sourceFile);
+    return (0, typescript_1.createPrinter)(PRINTER_OPTIONS).printNode(typescript_1.EmitHint.Unspecified, result.transformed[0], sourceFile);
 }
 /**
  * Takes the global declarations for a TypeScript and wraps export statements in `declare global`
@@ -422,7 +547,7 @@ function transformGlobalDeclarations(decl) {
     };
     const sourceFile = (0, typescript_1.createSourceFile)('index.d.ts', decl, typescript_1.ScriptTarget.ESNext, /* setParentNodes */ true);
     const result = (0, typescript_1.transform)(sourceFile, [transformer]);
-    return (0, typescript_1.createPrinter)().printNode(typescript_1.EmitHint.Unspecified, result.transformed[0], sourceFile);
+    return (0, typescript_1.createPrinter)(PRINTER_OPTIONS).printNode(typescript_1.EmitHint.Unspecified, result.transformed[0], sourceFile);
 }
 /**
  * Translates a script ID to a filename for the compiler