@ts-ioc-container/bundler 0.0.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) 2024, Igor Babkin
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

package/README.md

@@ -3,7 +3,7 @@
 **Bundles your dependencies into a single container module.** `tic build` scans
 your folders — by path or tsconfig alias — and generates one typed bundle that
 registers every class in them, ready for
-[`ts-ioc-container`](../ts-ioc-container):
+[`ts-ioc-container`](https://www.npmjs.com/package/ts-ioc-container):
 
 ```ts
 const container = new Container().useModule(new AppBundle());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ts-ioc-container/bundler",
-  "version": "0.0.0",
-  "description": "Bundles your dependencies into a single container module for ts-ioc-container: the `tic` CLI scans folders (by path or tsconfig alias) and generates one typed bundle that registers every class \u2014 `container.useModule(new AppBundle())`.",
+  "version": "0.2.0",
+  "description": "Bundles your dependencies into a single container module for ts-ioc-container: the `tic` CLI scans folders (by path or tsconfig alias) and generates one typed bundle that registers every class — `container.useModule(new AppBundle())`.",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -38,9 +38,8 @@
   "files": [
     "cjm/**/*",
     "typings/**/*",
+    "!typings/**/*.d.ts.map",
     "tpl/**/*",
-    "lib/**/*",
-    "!lib/**/*.hbs",
     "tic.schema.json",
     "AGENTS.md"
   ],
@@ -49,20 +48,6 @@
     "url": "git+https://github.com/IgorBabkin/ts-ioc-container",
     "directory": "packages/bundler"
   },
-  "scripts": {
-    "hbs:compile": "mkdir -p tpl && handlebars lib/protocols/*.hbs -f tpl/index.cjs -c handlebars",
-    "build:cjm": "node ../scripts/build.mjs cjm",
-    "build:types": "node ../scripts/build.mjs types",
-    "build": "pnpm run hbs:compile && pnpm run build:cjm && pnpm run build:types",
-    "prepack": "pnpm run hbs:compile",
-    "test": "pnpm run hbs:compile && pnpm run build:cjm && vitest run",
-    "test:coverage": "pnpm run hbs:compile && pnpm run build:cjm && vitest run --coverage --coverage.reporter=lcov",
-    "type-check": "pnpm run hbs:compile && tsc --noEmit",
-    "lint": "eslint lib/**/*.ts __tests__/**/*.ts",
-    "lint:fix": "pnpm run lint --fix",
-    "format": "prettier --write \"lib/**/*.ts\" \"__tests__/**/*.ts\"",
-    "format:check": "prettier --check \"lib/**/*.ts\" \"__tests__/**/*.ts\""
-  },
   "dependencies": {
     "handlebars": "^4.7.9"
   },
@@ -73,12 +58,25 @@
     "@types/node": "^25.5.2",
     "@vitest/coverage-v8": "^4.1.2",
     "reflect-metadata": "^0.2.2",
-    "ts-ioc-container": "workspace:*",
     "typescript": "5.8.3",
     "unplugin-swc": "^1.6.0",
-    "vitest": "^4.1.11"
+    "vitest": "^4.1.11",
+    "ts-ioc-container": "72.3.2"
   },
   "engines": {
     "node": ">= 18"
+  },
+  "scripts": {
+    "hbs:compile": "mkdir -p tpl && handlebars lib/protocols/*.hbs -f tpl/index.cjs -c handlebars",
+    "build:cjm": "node ../scripts/build.mjs cjm",
+    "build:types": "node ../scripts/build.mjs types",
+    "build": "pnpm run hbs:compile && pnpm run build:cjm && pnpm run build:types",
+    "test": "pnpm run hbs:compile && pnpm run build:cjm && vitest run",
+    "test:coverage": "pnpm run hbs:compile && pnpm run build:cjm && vitest run --coverage --coverage.reporter=lcov",
+    "type-check": "pnpm run hbs:compile && tsc --noEmit",
+    "lint": "eslint lib/**/*.ts __tests__/**/*.ts",
+    "lint:fix": "pnpm run lint --fix",
+    "format": "prettier --write \"lib/**/*.ts\" \"__tests__/**/*.ts\"",
+    "format:check": "prettier --check \"lib/**/*.ts\" \"__tests__/**/*.ts\""
   }
-}
+}

package/lib/ImportPaths.ts

@@ -1,127 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import path from 'node:path';
-import * as ts from 'typescript';
-import { NamespaceNotFoundError, TicConfigError } from './errors';
-import { toPosix } from './glob';
-
-interface Alias {
-  pattern: string;
-  /** Absolute, `/`-separated. */
-  targets: string[];
-}
-
-const SOURCE_EXTENSION = /\.(tsx?|mts|cts)$/;
-/** tsconfig "No inputs were found": irrelevant here, the bundler scans its own folders. */
-const NO_INPUTS = 18003;
-
-const isDirectory = (dir: string) => existsSync(dir) && statSync(dir).isDirectory();
-const isRelative = (spec: string) => spec.startsWith('.') || path.isAbsolute(spec);
-
-/** Splits a `paths` pattern at its `*`, if it has one. */
-function splitWildcard(pattern: string): [string, string] | undefined {
-  const star = pattern.indexOf('*');
-  return star === -1 ? undefined : [pattern.slice(0, star), pattern.slice(star + 1)];
-}
-
-/**
- * Import paths as a project's `tsconfig.json` sees them: resolves namespaces
- * written as `paths` aliases to folders, and writes imports back in alias form.
- */
-export class ImportPaths {
-  /**
-   * Reads `paths` (following `extends`) and the extension imports need under the
-   * tsconfig's `moduleResolution`; `importExtension` overrides the latter.
-   *
-   * @throws {TicConfigError} when a required tsconfig is missing or cannot be parsed.
-   */
-  static load(tsconfig: { file: string; required: boolean }, importExtension?: string): ImportPaths {
-    if (!existsSync(tsconfig.file)) {
-      if (tsconfig.required) throw new TicConfigError(`tsconfig not found: ${tsconfig.file}`);
-      return new ImportPaths([], importExtension ?? '');
-    }
-
-    const { config, error } = ts.readConfigFile(tsconfig.file, ts.sys.readFile);
-    const parsed = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(tsconfig.file), undefined, tsconfig.file);
-    const [fatal] = [error, ...parsed.errors].filter((d): d is ts.Diagnostic => !!d && d.code !== NO_INPUTS);
-    if (fatal) {
-      throw new TicConfigError(`${tsconfig.file}: ${ts.flattenDiagnosticMessageText(fatal.messageText, '\n')}`);
-    }
-
-    const { paths = {}, baseUrl, pathsBasePath, moduleResolution } = parsed.options;
-    // Without baseUrl, paths resolve against the tsconfig that declared them (which `extends` may make another file).
-    const base = baseUrl ?? (typeof pathsBasePath === 'string' ? pathsBasePath : path.dirname(tsconfig.file));
-    const aliases = Object.entries(paths).map(([pattern, targets]) => ({
-      pattern,
-      targets: targets.map((target) => toPosix(path.resolve(base, target))),
-    }));
-    const nodeEsm =
-      moduleResolution === ts.ModuleResolutionKind.Node16 || moduleResolution === ts.ModuleResolutionKind.NodeNext;
-    return new ImportPaths(aliases, importExtension ?? (nodeEsm ? '.js' : ''));
-  }
-
-  constructor(
-    private readonly aliases: Alias[],
-    readonly extension: string,
-  ) {}
-
-  /**
-   * The folder a namespace names: a path relative to `baseDir`, or a `paths` alias.
-   *
-   * @throws {NamespaceNotFoundError} when the namespace is neither an existing folder nor an alias of one.
-   */
-  resolveNamespace(namespace: string, baseDir: string): string {
-    const folder = path.resolve(baseDir, namespace);
-    if (isDirectory(folder)) return folder;
-    if (!isRelative(namespace)) {
-      // `@app` also matches an `@app/*` pattern, naming the alias root itself.
-      const found = [namespace, `${namespace}/`].flatMap((spec) => this.aliasTargets(spec)).find(isDirectory);
-      if (found) return path.normalize(found);
-    }
-    throw new NamespaceNotFoundError(
-      `namespace "${namespace}" is neither a folder relative to ${baseDir} nor a tsconfig paths alias of one`,
-    );
-  }
-
-  /** The specifier `fromFile` imports `toFile` by: its most specific alias, else a relative path. */
-  specifier(fromFile: string, toFile: string): string {
-    const target = toPosix(toFile);
-    const bare = target.replace(SOURCE_EXTENSION, '');
-    let best: { spec: string; score: number } | undefined;
-    for (const { pattern, targets } of this.aliases) {
-      for (const aliasTarget of targets) {
-        const match = this.matchAlias(pattern, aliasTarget, target, bare);
-        if (match && (!best || match.score > best.score)) best = match;
-      }
-    }
-    if (best) return best.spec;
-
-    const relative = toPosix(path.relative(path.dirname(fromFile), bare));
-    return `${relative.startsWith('.') ? relative : `./${relative}`}${this.extension}`;
-  }
-
-  private aliasTargets(spec: string): string[] {
-    return this.aliases.flatMap(({ pattern, targets }) => {
-      const wildcard = splitWildcard(pattern);
-      if (!wildcard) return pattern === spec ? targets : [];
-      const [prefix, suffix] = wildcard;
-      if (!spec.startsWith(prefix) || !spec.endsWith(suffix) || spec.length < prefix.length + suffix.length) return [];
-      const captured = spec.slice(prefix.length, spec.length - suffix.length);
-      return targets.map((target) => target.replace('*', captured));
-    });
-  }
-
-  /** A longer matched target prefix is a more specific alias; an exact file alias beats every wildcard. */
-  private matchAlias(pattern: string, aliasTarget: string, file: string, bare: string) {
-    const wildcard = splitWildcard(aliasTarget);
-    if (!wildcard) {
-      const exact = aliasTarget === file || aliasTarget.replace(SOURCE_EXTENSION, '') === bare;
-      return exact && !splitWildcard(pattern) ? { spec: pattern, score: Infinity } : undefined;
-    }
-    const [prefix, suffix] = wildcard;
-    if (!bare.startsWith(prefix) || !bare.endsWith(suffix) || bare.length < prefix.length + suffix.length) {
-      return undefined;
-    }
-    const captured = bare.slice(prefix.length, bare.length - suffix.length);
-    return { spec: `${pattern.replace('*', captured)}${this.extension}`, score: prefix.length };
-  }
-}

package/lib/bin.ts

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { run } from './cli';
-
-process.exitCode = run(process.argv.slice(2));

package/lib/build.ts

@@ -1,157 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { DEFAULT_CONFIG_FILE, loadConfig, type ResolvedConfig, type ResolvedBundle } from './config';
-import { emitBundle } from './emit';
-import { globToRegExp, toPosix } from './glob';
-import { ImportPaths } from './ImportPaths';
-import { type ExportPredicate, findConventionalExportPredicate, loadExportPredicate } from './exportPredicate';
-import { fileTags, findConventionalPredicate, type InclusionPredicate, loadInclusionPredicate } from './inclusion';
-import { findClasses, listSourceFiles } from './scan';
-
-export interface BuildOptions {
-  /** Path of `tic.config.json`, relative to `cwd`. Default `tic.config.json`. */
-  config?: string;
-  /** Default `process.cwd()`. */
-  cwd?: string;
-  /** Compare instead of writing: outputs that would change are reported `stale`. */
-  check?: boolean;
-  /** Decides which scanned files take part; overrides every inclusion predicate file. */
-  include?: InclusionPredicate;
-  /** Decides which parsed classes become registrations; overrides every export predicate file. */
-  filterExports?: ExportPredicate;
-}
-
-/** `written` / `unchanged` after a build; `stale` / `unchanged` after a check. */
-export type OutputStatus = 'written' | 'unchanged' | 'stale';
-
-export interface OutputResult {
-  /** Absolute path of the generated file. */
-  file: string;
-  /** Name of the generated class. */
-  bundle: string;
-  status: OutputStatus;
-  registrations: number;
-  content: string;
-}
-
-export interface BuildResult {
-  /** Absolute path of the config that was built. */
-  config: string;
-  outputs: OutputResult[];
-}
-
-/**
- * Generates one bundle per config entry. Every bundle is generated before any
- * file is written, so a failing namespace leaves the previous outputs intact.
- *
- * @throws {TicConfigError} when the config, the tsconfig or a predicate file it names is missing or invalid.
- * @throws {NamespaceNotFoundError} when a namespace is neither a folder nor a tsconfig paths alias of one.
- */
-export function build({
-  config = DEFAULT_CONFIG_FILE,
-  cwd = process.cwd(),
-  check = false,
-  include,
-  filterExports,
-}: BuildOptions = {}): BuildResult {
-  const resolved = loadConfig(path.resolve(cwd, config));
-  const paths = ImportPaths.load(resolved.tsconfig, resolved.importExtension);
-  const includeFor = predicateResolver({
-    override: include,
-    conventional: findConventionalPredicate(resolved.dir),
-    fileOf: (bundle) => bundle.include,
-    load: loadInclusionPredicate,
-  });
-  const filterExportsFor = predicateResolver({
-    override: filterExports,
-    conventional: findConventionalExportPredicate(resolved.dir),
-    fileOf: (bundle) => bundle.filterExports,
-    load: loadExportPredicate,
-  });
-  const generated = resolved.bundles.map((bundle) =>
-    generate(resolved, bundle, paths, { include: includeFor(bundle), filterExports: filterExportsFor(bundle) }),
-  );
-
-  const outputs = generated.map(({ bundle, content, registrations }): OutputResult => {
-    const current = existsSync(bundle.output) ? readFileSync(bundle.output, 'utf8') : undefined;
-    const status: OutputStatus = current === content ? 'unchanged' : check ? 'stale' : 'written';
-    if (status === 'written') {
-      mkdirSync(path.dirname(bundle.output), { recursive: true });
-      writeFileSync(bundle.output, content);
-    }
-    return { file: bundle.output, bundle: bundle.name, status, registrations, content };
-  });
-  return { config: resolved.file, outputs };
-}
-
-/**
- * Which predicate of one kind a bundle uses: the one passed to `build`, else the bundle's own file,
- * else the conventional file next to the config, else none. Each file is loaded once, and only when
- * a bundle needs it.
- *
- * @throws {TicConfigError} when a predicate file a bundle needs is missing or does not export a function.
- */
-function predicateResolver<P>({
-  override,
-  conventional,
-  fileOf,
-  load,
-}: {
-  override?: P;
-  conventional?: string;
-  fileOf: (bundle: ResolvedBundle) => string | undefined;
-  load: (file: string) => P;
-}) {
-  const loaded = new Map<string, P>();
-  return (bundle: ResolvedBundle): P | undefined => {
-    if (override) return override;
-    const file = fileOf(bundle) ?? conventional;
-    if (file === undefined) return undefined;
-    if (!loaded.has(file)) loaded.set(file, load(file));
-    return loaded.get(file);
-  };
-}
-
-/**
- * @throws {NamespaceNotFoundError} when a namespace is neither a folder nor a tsconfig paths alias of one.
- */
-function generate(
-  config: ResolvedConfig,
-  bundle: ResolvedBundle,
-  paths: ImportPaths,
-  { include, filterExports }: { include?: InclusionPredicate; filterExports?: ExportPredicate },
-) {
-  const relative = (file: string) => toPosix(path.relative(config.dir, file));
-  const outputs = new Set(config.bundles.map((m) => m.output));
-  const excludes = bundle.exclude.map(globToRegExp);
-  const isExcluded = (file: string) => {
-    if (outputs.has(file)) return true;
-    const filename = relative(file);
-    return excludes.some((glob) => glob.test(filename)) || (include !== undefined && !include({ filename }));
-  };
-
-  const files = new Set<string>();
-  for (const namespace of bundle.namespaces) {
-    const dir = paths.resolveNamespace(namespace.path, config.dir);
-    for (const file of listSourceFiles(dir, namespace.recursive, isExcluded)) files.add(file);
-  }
-
-  const classes = [...files]
-    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
-    .flatMap((file) => findClasses(file, bundle.select))
-    .filter((cls) => {
-      if (!filterExports) return true;
-      const filename = relative(cls.file);
-      const { exportName, className, isDefault, decorators } = cls;
-      return filterExports({ filename, exportName, className, isDefault, decorators, tags: fileTags(filename) });
-    })
-    .map((cls) => ({ ...cls, specifier: paths.specifier(bundle.output, cls.file) }));
-
-  const content = emitBundle({
-    name: bundle.name,
-    configPath: toPosix(path.relative(path.dirname(bundle.output), config.file)),
-    namespaces: bundle.namespaces.map((ns) => ns.path),
-    classes,
-  });
-  return { bundle, content, registrations: classes.length };
-}

package/lib/cli.ts

@@ -1,88 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { build, type OutputStatus } from './build';
-import { TicError } from './errors';
-
-export interface CliIo {
-  cwd: string;
-  stdout: (line: string) => void;
-  stderr: (line: string) => void;
-}
-
-const USAGE = [
-  'Usage: ts-ioc-container <command> [options]',
-  '       tic is a shortcut for ts-ioc-container',
-  '',
-  'Commands:',
-  '  ts-ioc-container build [--config <path>] [--check]   generate the bundles described by tic.config.json',
-  '',
-  'Options:',
-  '  -c, --config <path>   config file (default: tic.config.json)',
-  '  --check               write nothing; exit 1 when a generated bundle is out of date',
-  '  -h, --help            show this help',
-  '  -v, --version         show the version',
-].join('\n');
-
-const VERB: Record<OutputStatus, string> = { written: 'wrote', unchanged: 'unchanged', stale: 'stale' };
-
-const plural = (n: number) => `${n} registration${n === 1 ? '' : 's'}`;
-
-function version(): string {
-  return JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
-}
-
-class UsageError extends TicError {}
-
-/**
- * @throws {UsageError} when an option is unknown or `--config` has no value.
- */
-function parseBuildArgs(args: string[]) {
-  const options: { config?: string; check: boolean } = { check: false };
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--check') options.check = true;
-    else if (arg === '--config' || arg === '-c') {
-      options.config = args[++i];
-      if (!options.config) throw new UsageError(`${arg} needs a path`);
-    } else if (arg.startsWith('--config=')) options.config = arg.slice('--config='.length);
-    else throw new UsageError(`unknown option "${arg}"`);
-  }
-  return options;
-}
-
-/** Runs the `tic` CLI and returns its exit code; output goes through `io`. */
-export function run(
-  argv: string[],
-  io: CliIo = { cwd: process.cwd(), stdout: console.log, stderr: console.error },
-): number {
-  const [command, ...rest] = argv;
-  if (command === '--help' || command === '-h' || command === 'help') {
-    io.stdout(USAGE);
-    return 0;
-  }
-  if (command === '--version' || command === '-v') {
-    io.stdout(version());
-    return 0;
-  }
-  try {
-    if (command !== 'build') {
-      io.stderr(command ? `tic: unknown command "${command}"` : USAGE);
-      return 1;
-    }
-    const { config, check } = parseBuildArgs(rest);
-    const { outputs } = build({ config, check, cwd: io.cwd });
-    for (const { status, file, registrations } of outputs) {
-      io.stdout(`${VERB[status].padEnd(10)}${path.relative(io.cwd, file)} (${plural(registrations)})`);
-    }
-    const stale = outputs.filter((o) => o.status === 'stale').length;
-    if (stale > 0) {
-      io.stderr(`tic: ${stale} generated bundle${stale === 1 ? ' is' : 's are'} out of date — run \`tic build\``);
-      return 1;
-    }
-    return 0;
-  } catch (e) {
-    if (!(e instanceof TicError)) throw e;
-    io.stderr(`tic: ${e.message}`);
-    return 1;
-  }
-}

package/lib/config.ts

@@ -1,206 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { TicConfigError } from './errors';
-import { globToRegExp } from './glob';
-
-/** Which exports of a file count: both kinds, only named exports, or only the default export. */
-export type ExportKind = 'any' | 'named' | 'default';
-
-/**
- * How the bundler picks target classes out of a file. A class is selected when
- * it is exported, not abstract, and meets every criterion set here; an empty
- * rule selects every exported class.
- */
-export interface ClassSelector {
-  /** Default `any`. */
-  export?: ExportKind;
-  /** The class must carry one of these decorators, recognised by name (`register`, or a composed one). */
-  decorators?: string[];
-  /** A glob the class name must match, e.g. `*Service`. An anonymous default export is named after its file. */
-  nameGlob?: string;
-}
-
-/** A {@link ClassSelector} with its defaults filled in and its `nameGlob` compiled. */
-export interface ResolvedSelector {
-  export: ExportKind;
-  decorators?: string[];
-  nameGlob?: RegExp;
-}
-
-export interface NamespaceConfig {
-  /** A folder relative to the config file (`./src/services`) or a tsconfig `paths` alias (`@app/services`). */
-  path: string;
-  /** Scan sub-folders too. Default `true`. */
-  recursive?: boolean;
-}
-
-export interface BundleConfig {
-  /** The generated file, relative to the config file. */
-  output: string;
-  /** Name of the generated class, an `IContainerModule`. Default `Bundle`. */
-  name?: string;
-  namespaces: (string | NamespaceConfig)[];
-  /** Which classes of a scanned file are registered. Default: every exported class. */
-  select?: ClassSelector;
-  /** Globs, relative to the config file, of files never scanned. Replaces {@link DEFAULT_EXCLUDE} when given. */
-  exclude?: string[];
-  /**
-   * A file exporting an `InclusionPredicate`, relative to the config file. Overrides the
-   * conventional `tic.include.*` next to the config.
-   */
-  include?: string;
-  /**
-   * A file exporting an `ExportPredicate`, relative to the config file. Overrides the
-   * conventional `tic.exports.*` next to the config.
-   */
-  filterExports?: string;
-}
-
-/** The shape of `tic.config.json`. */
-export interface TicConfig {
-  $schema?: string;
-  /** Relative to the config file. Default `tsconfig.json`, which may be absent. */
-  tsconfig?: string;
-  /** Extension of generated imports. Inferred from the tsconfig's `moduleResolution` when omitted. */
-  importExtension?: string;
-  bundles: BundleConfig[];
-}
-
-export const DEFAULT_CONFIG_FILE = 'tic.config.json';
-export const DEFAULT_BUNDLE_NAME = 'Bundle';
-export const DEFAULT_EXCLUDE = [
-  '**/*.spec.ts',
-  '**/*.test.ts',
-  '**/*.spec.tsx',
-  '**/*.test.tsx',
-  '**/__tests__/**',
-  '**/node_modules/**',
-];
-
-/** A config whose defaults are filled in and whose paths are absolute. */
-export interface ResolvedConfig {
-  file: string;
-  dir: string;
-  tsconfig: { file: string; required: boolean };
-  importExtension?: string;
-  bundles: ResolvedBundle[];
-}
-
-export interface ResolvedBundle {
-  output: string;
-  name: string;
-  namespaces: Required<NamespaceConfig>[];
-  select: ResolvedSelector;
-  exclude: string[];
-  /** Absolute path of the bundle's own predicate file, when it names one. */
-  include?: string;
-  /** Absolute path of the bundle's own export predicate file, when it names one. */
-  filterExports?: string;
-}
-
-type Json = Record<string, unknown>;
-
-const isObject = (value: unknown): value is Json =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-const isNonEmptyString = (value: unknown): value is string => typeof value === 'string' && value.length > 0;
-const isStringArray = (value: unknown): value is string[] => Array.isArray(value) && value.every(isNonEmptyString);
-const isIdentifier = (value: unknown): value is string => typeof value === 'string' && /^[A-Za-z_$][\w$]*$/.test(value);
-
-const fail = (field: string, expected: string): never => {
-  throw new TicConfigError(`${field}: expected ${expected}`);
-};
-
-/**
- * @throws {TicConfigError} when a namespace entry is neither a non-empty string nor an object with a `path`.
- */
-function toNamespace(value: unknown, field: string): Required<NamespaceConfig> {
-  if (isNonEmptyString(value)) return { path: value, recursive: true };
-  if (!isObject(value)) return fail(field, 'a string or an object with "path"');
-  if (!isNonEmptyString(value.path)) return fail(`${field}.path`, 'a non-empty string');
-  if (value.recursive !== undefined && typeof value.recursive !== 'boolean')
-    return fail(`${field}.recursive`, 'a boolean');
-  return { path: value.path, recursive: value.recursive ?? true };
-}
-
-const SELECTOR_FIELDS = new Set(['export', 'decorators', 'nameGlob']);
-
-/**
- * @throws {TicConfigError} when the rule is not an object, has an unknown field, or a field has the wrong type.
- */
-function toSelector(value: unknown, field: string): ResolvedSelector {
-  if (value === undefined) return { export: 'any' };
-  if (!isObject(value)) return fail(field, 'an object');
-  const unknown = Object.keys(value).find((key) => !SELECTOR_FIELDS.has(key));
-  if (unknown) throw new TicConfigError(`${field}.${unknown}: unknown field`);
-  const { export: kind, decorators, nameGlob } = value;
-  if (kind !== undefined && kind !== 'any' && kind !== 'named' && kind !== 'default') {
-    return fail(`${field}.export`, '"any", "named" or "default"');
-  }
-  if (decorators !== undefined && !(isStringArray(decorators) && decorators.length > 0)) {
-    return fail(`${field}.decorators`, 'a non-empty array of strings');
-  }
-  if (nameGlob !== undefined && !isNonEmptyString(nameGlob)) return fail(`${field}.nameGlob`, 'a non-empty string');
-  return { export: kind ?? 'any', decorators, nameGlob: nameGlob === undefined ? undefined : globToRegExp(nameGlob) };
-}
-
-/**
- * @throws {TicConfigError} when a bundle field is missing or has the wrong type.
- */
-function toBundle(value: unknown, field: string, dir: string): ResolvedBundle {
-  if (!isObject(value)) return fail(field, 'an object');
-  const { output, name, namespaces, select, exclude, include, filterExports } = value;
-  if (!isNonEmptyString(output)) return fail(`${field}.output`, 'a non-empty string');
-  if (name !== undefined && !isIdentifier(name)) return fail(`${field}.name`, 'a valid identifier');
-  if (!Array.isArray(namespaces) || namespaces.length === 0) return fail(`${field}.namespaces`, 'a non-empty array');
-  if (exclude !== undefined && !isStringArray(exclude)) return fail(`${field}.exclude`, 'an array of strings');
-  if (include !== undefined && !isNonEmptyString(include)) return fail(`${field}.include`, 'a non-empty string');
-  if (filterExports !== undefined && !isNonEmptyString(filterExports)) {
-    return fail(`${field}.filterExports`, 'a non-empty string');
-  }
-  return {
-    output: path.resolve(dir, output),
-    name: name ?? DEFAULT_BUNDLE_NAME,
-    namespaces: namespaces.map((ns, i) => toNamespace(ns, `${field}.namespaces[${i}]`)),
-    select: toSelector(select, `${field}.select`),
-    exclude: exclude ?? DEFAULT_EXCLUDE,
-    include: include === undefined ? undefined : path.resolve(dir, include),
-    filterExports: filterExports === undefined ? undefined : path.resolve(dir, filterExports),
-  };
-}
-
-/**
- * Validates parsed `tic.config.json` content and resolves its paths against `file`'s directory.
- *
- * @throws {TicConfigError} when the content does not match the config shape; the message names the field.
- */
-export function resolveConfig(content: unknown, file: string): ResolvedConfig {
-  const dir = path.dirname(file);
-  if (!isObject(content)) return fail('config', 'a JSON object');
-  const { tsconfig, importExtension, bundles } = content;
-  if (tsconfig !== undefined && !isNonEmptyString(tsconfig)) return fail('tsconfig', 'a non-empty string');
-  if (importExtension !== undefined && typeof importExtension !== 'string') return fail('importExtension', 'a string');
-  if (!Array.isArray(bundles) || bundles.length === 0) return fail('bundles', 'a non-empty array');
-  return {
-    file,
-    dir,
-    tsconfig: { file: path.resolve(dir, tsconfig ?? 'tsconfig.json'), required: tsconfig !== undefined },
-    importExtension,
-    bundles: bundles.map((m, i) => toBundle(m, `bundles[${i}]`, dir)),
-  };
-}
-
-/**
- * Reads and validates a `tic.config.json`.
- *
- * @throws {TicConfigError} when the file is missing, is not valid JSON, or does not match the config shape.
- */
-export function loadConfig(file: string): ResolvedConfig {
-  if (!existsSync(file)) throw new TicConfigError(`config file not found: ${file}`);
-  let content: unknown;
-  try {
-    content = JSON.parse(readFileSync(file, 'utf8'));
-  } catch (e) {
-    throw new TicConfigError(`${file} is not valid JSON: ${(e as Error).message}`);
-  }
-  return resolveConfig(content, file);
-}

package/lib/emit.ts

@@ -1,47 +0,0 @@
-import { renderProtocol } from './render';
-import type { DiscoveredClass } from './scan';
-
-export interface EmitInput {
-  /** Name of the generated class. */
-  name: string;
-  /** Shown in the header: where the output came from. */
-  configPath: string;
-  namespaces: string[];
-  classes: (DiscoveredClass & { specifier: string })[];
-}
-
-const RUNTIME_IMPORTS = ['IContainer', 'IContainerModule', 'IRegistration', 'Registration'];
-
-/**
- * Renders the generated bundle — static imports, `registrations`, and the bundle applying them —
- * from its protocol, `protocols/Bundle.ts.hbs`. This function only prepares the data: unique local
- * names, and one import per file in file order.
- */
-export function emitBundle({ name, configPath, namespaces, classes }: EmitInput): string {
-  const taken = new Set([...RUNTIME_IMPORTS, 'registrations', name]);
-  const uniqueName = (wanted: string) => {
-    let candidate = wanted;
-    for (let n = 2; taken.has(candidate); n++) candidate = `${wanted}_${n}`;
-    taken.add(candidate);
-    return candidate;
-  };
-
-  // One import statement per file, in file order.
-  const byFile = new Map<string, { specifier: string; defaultName?: string; named: string[] }>();
-  const bindings = classes.map((cls) => {
-    const binding = uniqueName(cls.localName);
-    const entry = byFile.get(cls.file) ?? { specifier: cls.specifier, named: [] };
-    byFile.set(cls.file, entry);
-    if (cls.exportName === 'default') entry.defaultName = binding;
-    else entry.named.push(binding === cls.exportName ? binding : `${cls.exportName} as ${binding}`);
-    return binding;
-  });
-
-  return renderProtocol('Bundle.ts.hbs', {
-    configPath,
-    namespaces,
-    name,
-    imports: [...byFile.values()],
-    registrations: bindings,
-  });
-}

package/lib/errors.ts

@@ -1,14 +0,0 @@
-/** Base class of every error the bundler raises on purpose; the CLI prints its message without a stack. */
-export class TicError extends Error {
-  name = 'TicError';
-}
-
-/** The config file is missing, is not JSON, or does not match the `tic.config.json` shape. */
-export class TicConfigError extends TicError {
-  name = 'TicConfigError';
-}
-
-/** A namespace is neither an existing folder nor a `tsconfig.json` `paths` alias of one. */
-export class NamespaceNotFoundError extends TicError {
-  name = 'NamespaceNotFoundError';
-}

package/lib/exportPredicate.ts

@@ -1,45 +0,0 @@
-import { conventionalNames, findConventionalFile, loadPredicateFile } from './predicateFile';
-import type { FilterPredicate } from './utils';
-
-/** What an {@link ExportPredicate} decides on: one exported class of a parsed file. */
-export interface ExportContext {
-  /** The file's path relative to the config file, `/`-separated: `src/services/Logger.ts`. */
-  filename: string;
-  /** The name the class is exported under; `'default'` for a default export. */
-  exportName: string;
-  /** The declared class name; an anonymous default export is named after its file. */
-  className: string;
-  isDefault: boolean;
-  /** Names of the class's decorators, renamed imports resolved (`register as reg` -> `'register'`). */
-  decorators: string[];
-  /** The file-name tags `byTags` reads: `Report.production.eu.ts` -> `['production', 'eu']`. */
-  tags: string[];
-}
-
-/**
- * Decides, right after a file is parsed, whether one of its exported classes becomes a
- * registration. It runs on every exported, non-abstract class that passes `select`.
- *
- * @example
- * // tic.exports.ts, next to tic.config.json - picked up by convention
- * const filterExports: ExportPredicate = ({ exportName }) => !/(Stub|Mock|Fake)$/.test(exportName);
- * export default filterExports;
- */
-export type ExportPredicate = FilterPredicate<ExportContext>;
-
-/** Export predicate files looked up next to the config, in this order, when no bundle names one. */
-export const EXPORTS_CONVENTION = conventionalNames('tic.exports');
-
-/** The conventional export predicate file in `dir`, if there is one. */
-export function findConventionalExportPredicate(dir: string): string | undefined {
-  return findConventionalFile(dir, 'tic.exports');
-}
-
-/**
- * Loads an {@link ExportPredicate} file (see `loadPredicateFile` for formats and caching).
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export function loadExportPredicate(file: string): ExportPredicate {
-  return loadPredicateFile<ExportPredicate>(file, 'ExportPredicate');
-}

package/lib/glob.ts

@@ -1,24 +0,0 @@
-/**
- * Converts a glob to an anchored RegExp over `/`-separated paths: `**` spans
- * folders (`**\/` also matches none), `*` and `?` stay within one segment.
- */
-export function globToRegExp(glob: string): RegExp {
-  let source = '';
-  for (let i = 0; i < glob.length; i++) {
-    const char = glob[i];
-    if (char === '*' && glob[i + 1] === '*') {
-      const slash = glob[i + 2] === '/';
-      source += slash ? '(?:.*/)?' : '.*';
-      i += slash ? 2 : 1;
-    } else if (char === '*') {
-      source += '[^/]*';
-    } else if (char === '?') {
-      source += '[^/]';
-    } else {
-      source += char.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-    }
-  }
-  return new RegExp(`^${source}$`);
-}
-
-export const toPosix = (file: string): string => file.split('\\').join('/');

package/lib/inclusion.ts

@@ -1,61 +0,0 @@
-import { conventionalNames, findConventionalFile, loadPredicateFile } from './predicateFile';
-import type { FilterPredicate } from './utils';
-
-/** What an {@link InclusionPredicate} decides on. */
-export interface InclusionContext {
-  /** The file's path relative to the config file, `/`-separated: `src/services/Logger.ts`. */
-  filename: string;
-}
-
-/**
- * Decides whether a scanned file takes part in code generation. A file takes
- * part only when it matches no `exclude` glob and the predicate returns `true`.
- *
- * @example
- * // tic.include.ts, next to tic.config.json - picked up by convention
- * const include: InclusionPredicate = ({ filename }) => !filename.includes('/legacy/');
- * export default include;
- */
-export type InclusionPredicate = FilterPredicate<InclusionContext>;
-
-/**
- * An {@link InclusionPredicate} over a file's tags, the dot-separated parts of its name between
- * the base name and the extension. Wrap it with {@link byTags} to use it anywhere an
- * `InclusionPredicate` goes.
- *
- * @example
- * // StripeGateway.production.ts joins production only; Shared.ts joins every environment
- * const ENVS = ['development', 'production', 'test'];
- * export default byTags((tags) => tags.filter((t) => ENVS.includes(t)).every((t) => t === process.env.TIC_ENV));
- */
-export type TagInclusionPredicate = (tags: string[], context: InclusionContext) => boolean;
-
-/** `src/Report.production.eu.ts` -> `['production', 'eu']`; `src/Shared.ts` -> `[]`. */
-export function fileTags(filename: string): string[] {
-  return filename
-    .slice(filename.lastIndexOf('/') + 1)
-    .split('.')
-    .slice(1, -1);
-}
-
-/** Wraps a {@link TagInclusionPredicate} into the {@link InclusionPredicate} the bundler calls. */
-export function byTags(predicate: TagInclusionPredicate): InclusionPredicate {
-  return (context) => predicate(fileTags(context.filename), context);
-}
-
-/** Predicate files looked up next to the config, in this order, when no bundle names one. */
-export const INCLUSION_CONVENTION = conventionalNames('tic.include');
-
-/** The conventional inclusion predicate file in `dir`, if there is one. */
-export function findConventionalPredicate(dir: string): string | undefined {
-  return findConventionalFile(dir, 'tic.include');
-}
-
-/**
- * Loads an {@link InclusionPredicate} file (see `loadPredicateFile` for formats and caching).
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export function loadInclusionPredicate(file: string): InclusionPredicate {
-  return loadPredicateFile<InclusionPredicate>(file, 'InclusionPredicate');
-}

package/lib/index.ts

@@ -1,40 +0,0 @@
-export { build, type BuildOptions, type BuildResult, type OutputResult, type OutputStatus } from './build';
-export { run, type CliIo } from './cli';
-export {
-  loadConfig,
-  resolveConfig,
-  DEFAULT_CONFIG_FILE,
-  DEFAULT_EXCLUDE,
-  DEFAULT_BUNDLE_NAME,
-  type TicConfig,
-  type BundleConfig,
-  type NamespaceConfig,
-  type ClassSelector,
-  type ExportKind,
-  type ResolvedSelector,
-  type ResolvedConfig,
-  type ResolvedBundle,
-} from './config';
-export { ImportPaths } from './ImportPaths';
-export { type FilterPredicate } from './utils';
-export {
-  type ExportPredicate,
-  type ExportContext,
-  EXPORTS_CONVENTION,
-  findConventionalExportPredicate,
-  loadExportPredicate,
-} from './exportPredicate';
-export {
-  type InclusionPredicate,
-  type InclusionContext,
-  type TagInclusionPredicate,
-  byTags,
-  fileTags,
-  INCLUSION_CONVENTION,
-  findConventionalPredicate,
-  loadInclusionPredicate,
-} from './inclusion';
-export { findClasses, listSourceFiles, type DiscoveredClass } from './scan';
-export { emitBundle, type EmitInput } from './emit';
-export { globToRegExp } from './glob';
-export { TicError, TicConfigError, NamespaceNotFoundError } from './errors';

package/lib/predicateFile.ts

@@ -1,36 +0,0 @@
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { TicConfigError } from './errors';
-import type { FilterPredicate } from './utils';
-
-const EXTENSIONS = ['cjs', 'js', 'mjs', 'ts', 'cts', 'mts'];
-
-/** `tic.include` -> `tic.include.cjs`, `tic.include.js`, ... in lookup order. */
-export const conventionalNames = (base: string): string[] => EXTENSIONS.map((ext) => `${base}.${ext}`);
-
-/** The first conventional file for `base` that exists in `dir`, if any. */
-export function findConventionalFile(dir: string, base: string): string | undefined {
-  return conventionalNames(base)
-    .map((name) => path.join(dir, name))
-    .find((file) => existsSync(file));
-}
-
-/**
- * Loads a predicate file synchronously with `require` - `.cjs` / `.js`, ES modules
- * (Node 22.12+) and `.ts` (Node with type stripping). Its default export, or
- * `module.exports` itself, is the predicate. Like any `require`d module it is loaded
- * once per process, so a predicate that depends on the environment should read it
- * when called, not when loaded.
- *
- * @throws {TicConfigError} when the file is missing or does not export a function.
- */
-export function loadPredicateFile<T extends FilterPredicate<never>>(file: string, typeName: string): T {
-  if (!existsSync(file)) throw new TicConfigError(`predicate file not found: ${file}`);
-  const loaded: unknown = createRequire(file)(file);
-  const predicate = typeof loaded === 'function' ? loaded : (loaded as { default?: unknown } | undefined)?.default;
-  if (typeof predicate !== 'function') {
-    throw new TicConfigError(`${file} must export an ${typeName} function (default export or module.exports)`);
-  }
-  return predicate as T;
-}

package/lib/render.ts

@@ -1,19 +0,0 @@
-import '../tpl/index.cjs';
-import Handlebars from 'handlebars';
-
-// A protocol is the declarative definition (schema) of a generated file, written as a Handlebars
-// template in lib/protocols/. `hbs:compile` precompiles them into tpl/index.cjs, which registers each
-// one in the process-global `Handlebars.templates` under its file basename. Output is TypeScript,
-// not HTML, so protocols interpolate with `{{{ }}}` and helpers return plain strings.
-Handlebars.registerHelper('join', (items: string[], separator: string) => items.join(separator));
-
-/**
- * Renders a precompiled protocol, looked up by its file basename (`Bundle.ts.hbs`).
- *
- * @throws {Error} when no protocol is registered under `name`.
- */
-export function renderProtocol(name: string, data: unknown): string {
-  const protocol = Handlebars.templates?.[name];
-  if (!protocol) throw new Error(`Protocol not found: ${name}`);
-  return protocol(data);
-}

package/lib/scan.ts

@@ -1,133 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import * as ts from 'typescript';
-import type { ResolvedSelector } from './config';
-
-/** An exported class the generated bundle registers. */
-export interface DiscoveredClass {
-  file: string;
-  /** The name it is exported under; `default` for a default export. */
-  exportName: string;
-  /** The local name the generated bundle would like to import it under. */
-  localName: string;
-  /** The declared class name; an anonymous default export is named after its file. */
-  className: string;
-  isDefault: boolean;
-  /** Names of the class's decorators, renamed imports resolved. */
-  decorators: string[];
-}
-
-const SOURCE_FILE = /\.(tsx?|mts|cts)$/;
-const DECLARATION_FILE = /\.d\.[mc]?tsx?$/;
-
-/** Source files of `dir`, sorted by path so the generated output is stable across machines. */
-export function listSourceFiles(dir: string, recursive: boolean, isExcluded: (file: string) => boolean): string[] {
-  const files: string[] = [];
-  const walk = (current: string) => {
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const full = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        if (recursive && entry.name !== 'node_modules') walk(full);
-      } else if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name) && !isExcluded(full)) {
-        files.push(full);
-      }
-    }
-  };
-  walk(dir);
-  return files.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
-}
-
-const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) =>
-  ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((m) => m.kind === kind);
-
-/** `@register`, `@register(...)`, `@ioc.register(...)` -> `register`; renamed imports map back to the imported name. */
-function decoratorName(decorator: ts.Decorator, imports: Map<string, string>): string | undefined {
-  const callee = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
-  if (ts.isIdentifier(callee)) return imports.get(callee.text) ?? callee.text;
-  if (ts.isPropertyAccessExpression(callee)) return callee.name.text;
-  return undefined;
-}
-
-/**
- * `user-service.ts` -> `UserService`: the import name of an anonymous default-exported class.
- * File-name tags are not part of it: `user-service.production.ts` -> `UserService`.
- */
-function nameFromFile(file: string): string {
-  const words = path
-    .basename(file)
-    .split('.')[0]
-    .split(/[^A-Za-z0-9_$]+/)
-    .filter(Boolean);
-  const name = words.map((w: string) => w[0].toUpperCase() + w.slice(1)).join('');
-  return /^[A-Za-z_$]/.test(name) ? name : `_${name}`;
-}
-
-/**
- * The exported, non-abstract classes of one file that `selector` selects, in
- * declaration order. Syntax only: decorators are recognised by name, not by type.
- */
-export function findClasses(
-  file: string,
-  selector: ResolvedSelector,
-  text = readFileSync(file, 'utf8'),
-): DiscoveredClass[] {
-  const kind = file.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
-  const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, kind);
-
-  const imports = new Map<string, string>(); // local name -> imported name
-  const classes = new Map<string, ts.ClassDeclaration>();
-  const exported: { node: ts.ClassDeclaration | undefined; local?: string; exportName: string }[] = [];
-
-  for (const statement of source.statements) {
-    if (ts.isImportDeclaration(statement)) {
-      const bindings = statement.importClause?.namedBindings;
-      if (bindings && ts.isNamedImports(bindings)) {
-        for (const el of bindings.elements) imports.set(el.name.text, (el.propertyName ?? el.name).text);
-      }
-    } else if (ts.isClassDeclaration(statement)) {
-      if (statement.name) classes.set(statement.name.text, statement);
-      if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
-        const isDefault = hasModifier(statement, ts.SyntaxKind.DefaultKeyword);
-        exported.push({ node: statement, exportName: isDefault ? 'default' : statement.name!.text });
-      }
-    } else if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && !statement.isTypeOnly) {
-      const clause = statement.exportClause;
-      if (clause && ts.isNamedExports(clause)) {
-        for (const el of clause.elements) {
-          if (!el.isTypeOnly)
-            exported.push({ node: undefined, local: (el.propertyName ?? el.name).text, exportName: el.name.text });
-        }
-      }
-    } else if (ts.isExportAssignment(statement) && !statement.isExportEquals && ts.isIdentifier(statement.expression)) {
-      exported.push({ node: undefined, local: statement.expression.text, exportName: 'default' });
-    }
-  }
-
-  const decoratorsOf = (node: ts.ClassDeclaration) =>
-    (ts.getDecorators(node) ?? []).map((d) => decoratorName(d, imports)).filter((n): n is string => !!n);
-
-  return exported
-    .map(({ node, local, exportName }) => ({ node: node ?? (local ? classes.get(local) : undefined), exportName }))
-    .filter((e): e is { node: ts.ClassDeclaration; exportName: string } => !!e.node)
-    .map(({ node, exportName }) => ({
-      node,
-      exportName,
-      className: node.name?.text ?? nameFromFile(file),
-      decorators: decoratorsOf(node),
-    }))
-    .filter(({ node, exportName, className, decorators }) => {
-      if (hasModifier(node, ts.SyntaxKind.AbstractKeyword)) return false;
-      if (selector.export !== 'any' && (exportName === 'default') !== (selector.export === 'default')) return false;
-      if (selector.decorators && !selector.decorators.some((name) => decorators.includes(name))) return false;
-      return !selector.nameGlob || selector.nameGlob.test(className);
-    })
-    .sort((a, b) => a.node.pos - b.node.pos)
-    .map(({ exportName, className, decorators }) => ({
-      file,
-      exportName,
-      localName: exportName === 'default' ? className : exportName,
-      className,
-      isDefault: exportName === 'default',
-      decorators,
-    }));
-}

package/lib/utils.ts

@@ -1,2 +0,0 @@
-/** Decides whether a value is kept. The base of every predicate the bundler takes. */
-export type FilterPredicate<Target> = (value: Target) => boolean;

package/typings/ImportPaths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ImportPaths.d.ts","sourceRoot":"","sources":["../lib/ImportPaths.ts"],"names":[],"mappings":"AAMA,UAAU,KAAK;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAeD;;;GAGG;AACH,qBAAa,WAAW;IAiCpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM;IAjC5B;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,WAAW;gBA0B9E,OAAO,EAAE,KAAK,EAAE,EACxB,SAAS,EAAE,MAAM;IAG5B;;;;OAIG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAa5D,mGAAmG;IACnG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAgBnD,OAAO,CAAC,YAAY;IAWpB,yGAAyG;IACzG,OAAO,CAAC,UAAU;CAanB"}

package/typings/bin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../lib/bin.ts"],"names":[],"mappings":""}

package/typings/build.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../lib/build.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,eAAe,EAAwD,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAuC,KAAK,kBAAkB,EAA0B,MAAM,aAAa,CAAC;AAGnH,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uFAAuF;IACvF,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,gGAAgG;IAChG,aAAa,CAAC,EAAE,eAAe,CAAC;CACjC;AAED,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,EACpB,MAA4B,EAC5B,GAAmB,EACnB,KAAa,EACb,OAAO,EACP,aAAa,GACd,GAAE,YAAiB,GAAG,WAAW,CA6BjC"}

package/typings/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../lib/cli.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AA2CD,8EAA8E;AAC9E,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,KAA0E,GAC7E,MAAM,CA+BR"}

package/typings/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../lib/config.ts"],"names":[],"mappings":"AAKA,iGAAiG;AACjG,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,qBAAqB;IACrB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,wGAAwG;IACxG,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,8GAA8G;IAC9G,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,6GAA6G;IAC7G,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,CAAC,MAAM,GAAG,eAAe,CAAC,EAAE,CAAC;IACzC,qFAAqF;IACrF,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,+GAA+G;IAC/G,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,sCAAsC;AACtC,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oGAAoG;IACpG,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AACrD,eAAO,MAAM,mBAAmB,WAAW,CAAC;AAC5C,eAAO,MAAM,eAAe,UAO3B,CAAC;AAEF,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;IACxC,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAwED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,CAc5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CASvD"}

package/typings/emit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../lib/emit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,MAAM,WAAW,SAAS;IACxB,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CACtD;AAID;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,SAAS,GAAG,MAAM,CA2BvF"}

package/typings/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../lib/errors.ts"],"names":[],"mappings":"AAAA,2GAA2G;AAC3G,qBAAa,QAAS,SAAQ,KAAK;IACjC,IAAI,SAAc;CACnB;AAED,8FAA8F;AAC9F,qBAAa,cAAe,SAAQ,QAAQ;IAC1C,IAAI,SAAoB;CACzB;AAED,4FAA4F;AAC5F,qBAAa,sBAAuB,SAAQ,QAAQ;IAClD,IAAI,SAA4B;CACjC"}

package/typings/exportPredicate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exportPredicate.d.ts","sourceRoot":"","sources":["../lib/exportPredicate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,uFAAuF;AACvF,MAAM,WAAW,aAAa;IAC5B,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,qGAAqG;IACrG,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,8FAA8F;IAC9F,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,CAAC,aAAa,CAAC,CAAC;AAE7D,oGAAoG;AACpG,eAAO,MAAM,kBAAkB,UAAmC,CAAC;AAEnE,wEAAwE;AACxE,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE/E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAEjE"}

package/typings/glob.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../lib/glob.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBjD;AAED,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,KAAG,MAAoC,CAAC"}

package/typings/inclusion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inclusion.d.ts","sourceRoot":"","sources":["../lib/inclusion.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAC;AAEnE;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;AAE3F,wFAAwF;AACxF,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAKnD;AAED,mGAAmG;AACnG,wBAAgB,MAAM,CAAC,SAAS,EAAE,qBAAqB,GAAG,kBAAkB,CAE3E;AAED,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,UAAmC,CAAC;AAErE,2EAA2E;AAC3E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAEvE"}

package/typings/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3G,OAAO,EAAE,GAAG,EAAE,KAAK,KAAK,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EACL,UAAU,EACV,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,kBAAkB,EAClB,+BAA+B,EAC/B,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,MAAM,EACN,QAAQ,EACR,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC"}

package/typings/predicateFile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicateFile.d.ts","sourceRoot":"","sources":["../lib/predicateFile.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,MAAM,EAA+C,CAAC;AAEvG,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIlF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,eAAe,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,CAQrG"}

package/typings/render.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../lib/render.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAS1B;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAIlE"}

package/typings/scan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../lib/scan.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,iEAAiE;IACjE,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAKD,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,EAAE,CAchH;AA2BD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,SAA6B,GAChC,eAAe,EAAE,CA4DnB"}

package/typings/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC"}