@liautaud/typezod 1.0.0 → 2.0.0

package/README.md

@@ -27,7 +27,7 @@ const Rectangle = t.object({
   height: t.number(),
 });
 
-const ElectronWindow = t.fromModule("/electron/", "BaseWindow");
+const ElectronWindow = t.fromModule("electron", "BaseWindow");
 
 // Inside a typescript-eslint rule's `create()` function, build a context
 // from the parser services and use `isAssignableTo` to check types.
@@ -51,36 +51,55 @@ by the schema.
 ### `SchemaContext`
 
 The context object passed to `isAssignableTo`. Contains a `checker`
-(required) and an optional `program` (only needed for `t.fromModule()`).
+(always required), a `program` (required when using `t.fromModule()`),
+and a `sourceFile` (required when using `t.fromModule()` with a relative
+module specifier such as `"./foo"` or `"../foo"`).
+
+Example for relative module specifiers inside an ESLint rule:
+
+```typescript
+const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+const ctx: SchemaContext = {
+  checker: parserServices.program.getTypeChecker(),
+  program: parserServices.program,
+  sourceFile: tsNode.getSourceFile(),
+};
+```
 
 ### Primitives
 
-| Builder          | Description                    |
-| ---------------- | ------------------------------ |
-| `t.string()`     | Represents the `string` type   |
-| `t.number()`     | Represents the `number` type   |
-| `t.boolean()`    | Represents the `boolean` type  |
-| `t.void()`       | Represents the `void` type     |
-| `t.undefined()`  | Represents the `undefined` type|
-| `t.null()`       | Represents the `null` type     |
-| `t.any()`        | Accepts any type               |
-| `t.unknown()`    | Accepts any type               |
+| Builder         | Description                     |
+| --------------- | ------------------------------- |
+| `t.string()`    | Represents the `string` type    |
+| `t.number()`    | Represents the `number` type    |
+| `t.boolean()`   | Represents the `boolean` type   |
+| `t.void()`      | Represents the `void` type      |
+| `t.undefined()` | Represents the `undefined` type |
+| `t.null()`      | Represents the `null` type      |
+| `t.any()`       | Accepts any type                |
+| `t.unknown()`   | Accepts any type                |
 
 ### Combinators
 
-| Builder                    | Description                                                      |
-| -------------------------- | ---------------------------------------------------------------- |
-| `t.object(shape)`          | Represents an object with the given shape (structural subtyping) |
-| `t.array(element)`         | Represents an array whose element satisfies the given schema     |
-| `t.union(...schemas)`      | Represents a union of the given schemas                          |
-| `t.intersection(...schemas)` | Represents an intersection of the given schemas                |
+| Builder                      | Description                                                      |
+| ---------------------------- | ---------------------------------------------------------------- |
+| `t.object(shape)`            | Represents an object with the given shape (structural subtyping) |
+| `t.array(element)`           | Represents an array whose element satisfies the given schema     |
+| `t.union(...schemas)`        | Represents a union of the given schemas                          |
+| `t.intersection(...schemas)` | Represents an intersection of the given schemas                  |
 
 ### Advanced
 
-| Builder                                 | Description                                             |
-| --------------------------------------- | ------------------------------------------------------- |
-| `t.fromModule(pathPattern, exportName)` | Represents a type exported from a module in the program |
-| `t.custom(fn)`                          | Escape hatch for arbitrary predicates                   |
+| Builder                                | Description                                             |
+| -------------------------------------- | ------------------------------------------------------- |
+| `t.fromModule(moduleName, exportName)` | Represents a type exported from a module in the program |
+| `t.custom(fn)`                         | Escape hatch for arbitrary predicates                   |
+
+`t.fromModule()` accepts the same module specifier you'd write in an `import` statement.
+Installed packages (`"typescript"`, `"electron"`), relative paths (`"./types"`,
+`"../shared/types"`), and ambient module declarations (`declare module '...'`) are
+all supported. Relative specifiers require `sourceFile` in the context. Throws if the
+module or export cannot be found.
 
 ### Modifiers
 

package/dist/{index.d.ts → index.d.mts}

@@ -1,14 +1,21 @@
-import { Program, Type, TypeChecker } from "typescript";
+import { Program, SourceFile, Type, TypeChecker } from "typescript";
 
 //#region src/index.d.ts
 
 /**
- * Context required by all schema checks. The `program` field is only needed
- * for schemas that resolve types from external modules ({@link t.fromModule}).
+ * Context required by all schema checks.
+ *
+ * `program` is required by schemas that resolve module exports
+ * ({@link t.fromModule}).
+ *
+ * `sourceFile` is only required when resolving relative module specifiers
+ * (`"./x"`, `"../x"`) with {@link t.fromModule}. It should be the source file
+ * currently being analyzed.
  */
 type SchemaContext = {
   checker: TypeChecker;
   program?: Program;
+  sourceFile?: SourceFile;
 };
 type AcceptsFn = (type: Type, ctx: SchemaContext) => boolean;
 /**
@@ -56,6 +63,12 @@ declare class TypeSchema {
    */
   nullish(): TypeSchema;
 }
+/**
+ * Returns `true` if the given TypeScript type is assignable to the schema–in
+ * other words, if `type extends T` with `T` the TypeScript type represented
+ * by the schema.
+ */
+declare function isAssignableTo(ctx: SchemaContext, type: Type, schema: TypeSchema): boolean;
 /**
  * Schema builder namespace.
  */
@@ -134,25 +147,27 @@ declare const t: {
    */
   intersection: (...members: TypeSchema[]) => TypeSchema;
   /**
-   * Represents a type exported from a module in the program. Resolves a genuine
-   * `ts.Type` and delegates to `checker.isTypeAssignableTo()`, so it handles
-   * nominal class hierarchies correctly.
+   * Represents a type exported from a module. Resolves the module using
+   * TypeScript's module resolution algorithm, with a fallback to ambient
+   * module declarations. Resolved types are cached per `TypeChecker` instance.
    *
-   * Resolved types are cached per `TypeChecker` instance (via a `WeakMap`) so
-   * repeated calls across files do not re-scan source files.
+   * Requires `program` in the {@link SchemaContext}. Relative specifiers
+   * (`"./x"`, `"../x"`) also require `sourceFile`.
    *
-   * Requires `program` in the {@link SchemaContext}.
-   *
-   * @param modulePathPattern Substring matched against source-file paths.
+   * @param moduleName The module specifier, as in an `import` statement.
    * @param exportName The exported type, class or interface name.
    *
    * @example
    * ```typescript
-   * const BaseWindow = t.fromModule("/electron/", "BaseWindow");
-   * const Buffer = t.fromModule("@types/node", "Buffer");
+   * const BaseWindow = t.fromModule("electron", "BaseWindow");
+   * const Buffer = t.fromModule("node:buffer", "Buffer");
    * ```
+   *
+   * @throws When `program` is missing from the context.
+   * @throws When `moduleName` is relative and `sourceFile` is missing.
+   * @throws When no export named `exportName` can be resolved from `moduleName`.
    */
-  fromModule: (modulePathPattern: string, exportName: string) => TypeSchema;
+  fromModule: (moduleName: string, exportName: string) => TypeSchema;
   /**
    * Escape hatch for arbitrary predicates that the DSL cannot express directly.
    *
@@ -165,12 +180,5 @@ declare const t: {
    */
   custom: (predicate: AcceptsFn) => TypeSchema;
 };
-/**
- * Returns `true` if the given TypeScript type is assignable to the schema–in
- * other words, if `type extends T` with `T` the TypeScript type represented
- * by the schema.
- */
-declare function isAssignableTo(ctx: SchemaContext, type: Type, schema: TypeSchema): boolean;
 //#endregion
-export { SchemaContext, TypeSchema, isAssignableTo, t };
-//# sourceMappingURL=index.d.ts.map
+export { SchemaContext, TypeSchema, isAssignableTo, t };

package/dist/{index.js → index.mjs}

@@ -1,3 +1,5 @@
+import ts from "typescript";
+
 //#region src/index.ts
 const TS_SYMBOL_FLAGS_OPTIONAL = 16777216;
 /**
@@ -55,7 +57,14 @@ var TypeSchema = class TypeSchema {
 	}
 };
 const schema = (check) => new TypeSchema(check);
-const moduleTypeCache = new WeakMap();
+/**
+* Returns `true` if the given TypeScript type is assignable to the schema–in
+* other words, if `type extends T` with `T` the TypeScript type represented
+* by the schema.
+*/
+function isAssignableTo(ctx, type, schema$1) {
+	return schema$1._accepts(type, ctx);
+}
 /**
 * Schema builder namespace.
 */
@@ -85,43 +94,56 @@ const t = {
 		return members.some((m) => m._accepts(type, ctx));
 	}),
 	intersection: (...members) => schema((type, ctx) => members.every((m) => m._accepts(type, ctx))),
-	fromModule: (modulePathPattern, exportName) => schema((type, { checker, program }) => {
+	fromModule: (moduleName, exportName) => schema((type, { checker, program, sourceFile }) => {
 		if (!program) throw new Error("t.fromModule() requires `program` in the SchemaContext.");
+		const isRelative = moduleName.startsWith("./") || moduleName.startsWith("../");
+		if (isRelative && !sourceFile) throw new Error("t.fromModule() requires `sourceFile` in the SchemaContext for relative module specifiers.");
 		let cache = moduleTypeCache.get(checker);
 		if (!cache) {
-			cache = new Map();
+			cache = /* @__PURE__ */ new Map();
 			moduleTypeCache.set(checker, cache);
 		}
-		const cacheKey = JSON.stringify([modulePathPattern, exportName]);
-		if (!cache.has(cacheKey)) {
-			let resolved = null;
-			for (const sourceFile of program.getSourceFiles()) {
-				if (!sourceFile.fileName.includes(modulePathPattern)) continue;
-				const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-				if (!moduleSymbol) continue;
-				const exportSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === exportName);
-				if (exportSymbol) {
-					resolved = checker.getDeclaredTypeOfSymbol(exportSymbol);
-					break;
-				}
-			}
-			cache.set(cacheKey, resolved);
-		}
+		const cacheKey = JSON.stringify([
+			moduleName,
+			exportName,
+			isRelative ? sourceFile.fileName : null
+		]);
+		if (!cache.has(cacheKey)) cache.set(cacheKey, resolveModuleType(checker, program, moduleName, exportName, sourceFile));
 		const targetType = cache.get(cacheKey);
-		if (targetType == null) throw new Error(`t.fromModule(): could not resolve export "${exportName}" from any module matching "${modulePathPattern}".`);
+		if (targetType == null) throw new Error(`t.fromModule(): could not resolve export "${exportName}" from module "${moduleName}".`);
 		return checker.isTypeAssignableTo(type, targetType);
 	}),
 	custom: (predicate) => schema(predicate)
 };
+/** Per-checker cache for `t.fromModule()` resolved types. */
+const moduleTypeCache = /* @__PURE__ */ new WeakMap();
 /**
-* Returns `true` if the given TypeScript type is assignable to the schema–in
-* other words, if `type extends T` with `T` the TypeScript type represented
-* by the schema.
+* Resolves a module's exported type using TypeScript's module resolution
+* algorithm, with a fallback to ambient module declarations.
+*
+* Returns the resolved `ts.Type`, or `null` if the export cannot be found.
+*
+* @throws When multiple ambient/resolved symbols yield different types for the
+* same export name (ambiguity).
 */
-function isAssignableTo(ctx, type, schema$1) {
-	return schema$1._accepts(type, ctx);
-}
+const resolveModuleType = (checker, program, moduleName, exportName, sourceFile) => {
+	const compilerOptions = program.getCompilerOptions();
+	const containingFile = sourceFile ? sourceFile.fileName : program.getCurrentDirectory() + "/__typezod__.ts";
+	let moduleSymbol;
+	const resolved = ts.resolveModuleName(moduleName, containingFile, compilerOptions, ts.sys);
+	if (resolved.resolvedModule) {
+		const resolvedSf = program.getSourceFile(resolved.resolvedModule.resolvedFileName);
+		if (resolvedSf) moduleSymbol = checker.getSymbolAtLocation(resolvedSf);
+	}
+	if (!moduleSymbol) {
+		const quotedName = `"${moduleName}"`;
+		moduleSymbol = checker.getAmbientModules().find((s) => s.getName() === quotedName);
+	}
+	if (!moduleSymbol) return null;
+	const exportSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === exportName);
+	if (!exportSymbol) return null;
+	return checker.getDeclaredTypeOfSymbol(exportSymbol);
+};
 
 //#endregion
-export { TypeSchema, isAssignableTo, t };
-//# sourceMappingURL=index.js.map
+export { TypeSchema, isAssignableTo, t };

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "@liautaud/typezod",
-  "version": "1.0.0",
-  "description": "Zod-like DSL for comparing TypeScript compiler types against user-defined schemas",
   "type": "module",
-  "license": "MIT",
+  "version": "2.0.0",
+  "description": "Zod-like DSL for comparing TypeScript compiler types against user-defined schemas",
   "author": "Romain Liautaud",
+  "license": "MIT",
+  "homepage": "https://github.com/liautaud/typezod#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/liautaud/typezod.git"
   },
+  "bugs": {
+    "url": "https://github.com/liautaud/typezod/issues"
+  },
   "keywords": [
     "typescript",
     "type-checking",
@@ -32,16 +36,19 @@
   },
   "scripts": {
     "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
     "prepublishOnly": "npm test && npm run build"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
   },
   "devDependencies": {
-    "tsdown": "^0.11.9",
+    "@types/node": "^25.0.3",
+    "prettier": "^3.8.1",
+    "tsdown": "^0.18.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   }
 }

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;;AACW,KADC,aAAA,GACD;EAAW,OACV,EADD,WACC;EAAO,OAAA,CAAA,EAAP,OAAO;AACjB,CAAA;KAEG,SAAA,GAAS,CAAA,IAAA,EAAU,IAAV,EAAA,GAAA,EAAqB,aAArB,EAAA,GAAA,OAAA;;;AAAkC;AAQhD;;;AAQuB,cARV,UAAA,CAQU;EAAS;EAiBR,SAYV,QAAA,EAnCO,SAmCP;EAAU;EAYD,SAAA,WAAA,EAAA,OAAA;EAaV;EA+MZ,WAAA,CAAA,OAAA,EArQsB,SAqQtB,EAAA,UAAA,CAAA,EAAA,OAAA;EAAA;;;;;;;;;;;;EAjH4B,QAAG,CAAA,CAAA,EAnIlB,UAmIkB;EAAU;;;;;;;AAgHE;EAQ5B,QAAA,CAAA,CAAA,EA/OF,UA+OgB;EAAA;;;;AAGV;;;;aAtOP;;;;;cAaA;;gBAEC;;gBAMA;;iBAMC;;cAMH;;mBAMK;;cAML;;;;;aASD;;;;;iBAMI;;;;;;;;;;;;;;;;;kBAkBG,eAAe,gBAAc;;;;;;;;;;;mBA6B5B,eAAa;;;;;;;;;;sBAgBV,iBAAe;;;;;;;;;;;;;6BAsBR,iBAAe;;;;;;;;;;;;;;;;;;;;iEAsBmB;;;;;;;;;;;sBAoDzC,cAAY;;;;;;;iBAQlB,cAAA,MACT,qBACC,cACE"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["accepts: AcceptsFn","check: AcceptsFn","shape: Record<string, TypeSchema>","element: TypeSchema","modulePathPattern: string","exportName: string","resolved: Type | null","predicate: AcceptsFn","ctx: SchemaContext","type: Type","schema: TypeSchema"],"sources":["../src/index.ts"],"sourcesContent":["import type { TypeChecker, Type, Program, SymbolFlags } from \"typescript\";\n\nconst TS_SYMBOL_FLAGS_OPTIONAL = 16777216 satisfies SymbolFlags.Optional;\n\n/**\n * Context required by all schema checks. The `program` field is only needed\n * for schemas that resolve types from external modules ({@link t.fromModule}).\n */\nexport type SchemaContext = {\n  checker: TypeChecker;\n  program?: Program;\n};\n\ntype AcceptsFn = (type: Type, ctx: SchemaContext) => boolean;\n\n/**\n * A type schema that checks whether a TypeScript compiler type is assignable\n * to the type represented by the schema.\n *\n * Obtain instances through the {@link t} builder, never instantiate directly.\n */\nexport class TypeSchema {\n  /** @internal */\n  readonly _accepts: AcceptsFn;\n\n  /** @internal */\n  readonly _isOptional: boolean;\n\n  /** @internal */\n  constructor(accepts: AcceptsFn, isOptional = false) {\n    this._accepts = accepts;\n    this._isOptional = isOptional;\n  }\n\n  /**\n   * Marks this schema as optional when used as a property in {@link t.object}.\n   * An optional property may be absent from the type or carry the TypeScript\n   * `Optional` symbol flag.\n   *\n   * @example\n   * ```typescript\n   * const Shape = t.object({\n   *   label: t.string().optional(),\n   * });\n   * ```\n   */\n  optional(): TypeSchema {\n    return new TypeSchema(t.union(this, t.undefined())._accepts, true);\n  }\n\n  /**\n   * Wraps this schema to also accept `null`.\n   *\n   * @example\n   * ```typescript\n   * const MaybeNumber = t.number().nullable(); // number | null\n   * ```\n   */\n  nullable(): TypeSchema {\n    return t.union(this, t.null());\n  }\n\n  /**\n   * Wraps this schema to also accept `null` and `undefined`.\n   *\n   * @example\n   * ```typescript\n   * const MaybeNumber = t.number().nullish(); // number | null | undefined\n   * ```\n   */\n  nullish(): TypeSchema {\n    return this.nullable().optional();\n  }\n}\n\nconst schema = (check: AcceptsFn): TypeSchema => new TypeSchema(check);\n\n// Per-checker cache for `t.fromModule()` resolved types.\nconst moduleTypeCache = new WeakMap<TypeChecker, Map<string, Type | null>>();\n\n/**\n * Schema builder namespace.\n */\nexport const t = {\n  /** Represents the `number` type. */\n  number: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getNumberType())\n    ),\n\n  /** Represents the `string` type. */\n  string: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getStringType())\n    ),\n\n  /** Represents the `boolean` type. */\n  boolean: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getBooleanType())\n    ),\n\n  /** Represents the `void` type. */\n  void: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getVoidType())\n    ),\n\n  /** Represents the `undefined` type. */\n  undefined: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getUndefinedType())\n    ),\n\n  /** Represents the `null` type. */\n  null: (): TypeSchema =>\n    schema((type, { checker }) =>\n      checker.isTypeAssignableTo(type, checker.getNullType())\n    ),\n\n  /**\n   * Represents the `any` type. Useful as a placeholder in object schemas when\n   * you care about a property's existence but not its type.\n   */\n  any: (): TypeSchema => schema(() => true),\n\n  /**\n   * Represents the `unknown` type. Semantically identical to `t.any()` as a\n   * predicate, but communicates intent differently in your schema.\n   */\n  unknown: (): TypeSchema => schema(() => true),\n\n  /**\n   * Represents an object type with the specified shape. Each property must be\n   * present and non-optional unless its schema was marked `.optional()`.\n   *\n   * Extra properties are allowed (structural subtyping), consistent with\n   * TypeScript's own assignability rules.\n   *\n   * @example\n   * ```typescript\n   * const Point = t.object({\n   *   x: t.number(),\n   *   y: t.number(),\n   *   label: t.string().optional(),\n   * });\n   * ```\n   */\n  object: (shape: Record<string, TypeSchema>): TypeSchema =>\n    schema((type, ctx) =>\n      Object.entries(shape).every(([key, propSchema]) => {\n        const propSymbol = type.getProperty(key);\n\n        if (!propSymbol) return propSchema._isOptional;\n\n        if (\n          !propSchema._isOptional &&\n          (propSymbol.flags & TS_SYMBOL_FLAGS_OPTIONAL) !== 0\n        ) {\n          return false;\n        }\n\n        const propType = ctx.checker.getTypeOfSymbol(propSymbol);\n        return propSchema._accepts(propType, ctx);\n      })\n    ),\n\n  /**\n   * Represents an array type whose element type satisfies the given schema.\n   * Checks for a numeric index signature, so it also covers tuples and other\n   * numerically-indexed types.\n   *\n   * @example\n   * ```typescript\n   * const NumberArray = t.array(t.number());\n   * ```\n   */\n  array: (element: TypeSchema): TypeSchema =>\n    schema((type, ctx) => {\n      const indexType = type.getNumberIndexType();\n      if (!indexType) return false;\n      return element._accepts(indexType, ctx);\n    }),\n\n  /**\n   * Represents a union of the given schemas. For union source types, every\n   * constituent must individually satisfy at least one member schema.\n   *\n   * @example\n   * ```typescript\n   * const StringOrNumber = t.union(t.string(), t.number());\n   * ```\n   */\n  union: (...members: TypeSchema[]): TypeSchema =>\n    schema((type, ctx) => {\n      if (type.isUnion()) {\n        return type.types.every((member) =>\n          members.some((m) => m._accepts(member, ctx))\n        );\n      }\n      return members.some((m) => m._accepts(type, ctx));\n    }),\n\n  /**\n   * Represents an intersection of the given schemas. The type must satisfy\n   * every member schema simultaneously.\n   *\n   * @example\n   * ```typescript\n   * const NamedAndAged = t.intersection(\n   *   t.object({ name: t.string() }),\n   *   t.object({ age: t.number() }),\n   * );\n   * ```\n   */\n  intersection: (...members: TypeSchema[]): TypeSchema =>\n    schema((type, ctx) => members.every((m) => m._accepts(type, ctx))),\n\n  /**\n   * Represents a type exported from a module in the program. Resolves a genuine\n   * `ts.Type` and delegates to `checker.isTypeAssignableTo()`, so it handles\n   * nominal class hierarchies correctly.\n   *\n   * Resolved types are cached per `TypeChecker` instance (via a `WeakMap`) so\n   * repeated calls across files do not re-scan source files.\n   *\n   * Requires `program` in the {@link SchemaContext}.\n   *\n   * @param modulePathPattern Substring matched against source-file paths.\n   * @param exportName The exported type, class or interface name.\n   *\n   * @example\n   * ```typescript\n   * const BaseWindow = t.fromModule(\"/electron/\", \"BaseWindow\");\n   * const Buffer = t.fromModule(\"@types/node\", \"Buffer\");\n   * ```\n   */\n  fromModule: (modulePathPattern: string, exportName: string): TypeSchema =>\n    schema((type, { checker, program }) => {\n      if (!program) {\n        throw new Error(\n          \"t.fromModule() requires `program` in the SchemaContext.\"\n        );\n      }\n\n      let cache = moduleTypeCache.get(checker);\n      if (!cache) {\n        cache = new Map();\n        moduleTypeCache.set(checker, cache);\n      }\n\n      const cacheKey = JSON.stringify([modulePathPattern, exportName]);\n\n      if (!cache.has(cacheKey)) {\n        let resolved: Type | null = null;\n        for (const sourceFile of program.getSourceFiles()) {\n          if (!sourceFile.fileName.includes(modulePathPattern)) continue;\n          const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n          if (!moduleSymbol) continue;\n          const exportSymbol = checker\n            .getExportsOfModule(moduleSymbol)\n            .find((s) => s.getName() === exportName);\n          if (exportSymbol) {\n            resolved = checker.getDeclaredTypeOfSymbol(exportSymbol);\n            break;\n          }\n        }\n        cache.set(cacheKey, resolved);\n      }\n\n      const targetType = cache.get(cacheKey);\n      if (targetType == null) {\n        throw new Error(\n          `t.fromModule(): could not resolve export \"${exportName}\" from any module matching \"${modulePathPattern}\".`\n        );\n      }\n      return checker.isTypeAssignableTo(type, targetType);\n    }),\n\n  /**\n   * Escape hatch for arbitrary predicates that the DSL cannot express directly.\n   *\n   * @example\n   * ```typescript\n   * const HasLengthProp = t.custom((type) =>\n   *   type.getProperty(\"length\") != null,\n   * );\n   * ```\n   */\n  custom: (predicate: AcceptsFn): TypeSchema => schema(predicate),\n};\n\n/**\n * Returns `true` if the given TypeScript type is assignable to the schema–in\n * other words, if `type extends T` with `T` the TypeScript type represented\n * by the schema.\n */\nexport function isAssignableTo(\n  ctx: SchemaContext,\n  type: Type,\n  schema: TypeSchema\n): boolean {\n  return schema._accepts(type, ctx);\n}\n"],"mappings":"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"}