@augment-vir/assert 31.0.0 → 31.0.1

package/dist/augments/guards/assert-wrap.d.ts

@@ -1,6 +1,9 @@
-import { assertWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { AssertWrapGroup } from '../../guard-types/assert-wrap-function.js';
-declare const assertWrapGroup: AssertWrapGroup<typeof extendableAssertions, typeof assertWrapOverrides>;
+import { ArrayElement } from '@augment-vir/core';
+import { UnionToIntersection } from 'type-fest';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+declare const assertWrapMethods: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
+    assertWrap: any;
+}>['assertWrap']>;
 /**
  * A group of guard methods that do the following:
  *
@@ -34,5 +37,5 @@ declare const assertWrapGroup: AssertWrapGroup<typeof extendableAssertions, type
  * @throws {@link AssertionError} When the assertion fails.
  * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export declare const assertWrap: (<T>(input: T, failureMessage?: string | undefined) => T) & typeof assertWrapGroup;
+export declare const assertWrap: (<T>(input: T, failureMessage?: string | undefined) => T) & typeof assertWrapMethods;
 export {};

package/dist/augments/guards/assert-wrap.js

@@ -1,7 +1,8 @@
-import { assertWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { createAssertWrapGroup } from '../../guard-types/assert-wrap-function.js';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
 import { AssertionError } from '../assertion.error.js';
-const assertWrapGroup = createAssertWrapGroup(extendableAssertions, assertWrapOverrides);
+const assertWrapMethods = Object.assign({}, ...guardOverrides.map((entry) => {
+    return entry.assertWrap;
+}));
 /**
  * A group of guard methods that do the following:
  *
@@ -40,4 +41,4 @@ export const assertWrap = Object.assign(function assertWrap(input, failureMessag
         throw new AssertionError('Assertion failed.', failureMessage);
     }
     return input;
-}, assertWrapGroup);
+}, assertWrapMethods);

package/dist/augments/guards/check-wrap.d.ts

@@ -1,7 +1,9 @@
-import { type AnyFunction } from '@augment-vir/core';
-import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { CheckWrapGroup } from '../../guard-types/check-wrap-wrapper-function.js';
-declare const checkWrapGroup: CheckWrapGroup<typeof extendableAssertions, typeof checkWrapOverrides>;
+import { AnyFunction, ArrayElement } from '@augment-vir/core';
+import { UnionToIntersection } from 'type-fest';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+declare const checkWrapMethods: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
+    checkWrap: any;
+}>['checkWrap']>;
 /**
  * A group of guard methods that do the following:
  *
@@ -35,5 +37,5 @@ declare const checkWrapGroup: CheckWrapGroup<typeof extendableAssertions, typeof
  *   `undefined`.
  * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export declare const checkWrap: (<T>(input: T) => undefined | T) & typeof checkWrapGroup & Record<keyof AnyFunction, never>;
+export declare const checkWrap: (<T>(input: T) => undefined | T) & typeof checkWrapMethods & Record<keyof AnyFunction, never>;
 export {};

package/dist/augments/guards/check-wrap.js

@@ -1,6 +1,7 @@
-import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { createCheckWrapGroup, } from '../../guard-types/check-wrap-wrapper-function.js';
-const checkWrapGroup = createCheckWrapGroup(extendableAssertions, checkWrapOverrides);
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+const checkWrapMethods = Object.assign({}, ...guardOverrides.map((entry) => {
+    return entry.checkWrap;
+}));
 /**
  * A group of guard methods that do the following:
  *
@@ -39,4 +40,4 @@ export const checkWrap = Object.assign(function checkWrap(input) {
         return undefined;
     }
     return input;
-}, checkWrapGroup);
+}, checkWrapMethods);

package/dist/augments/guards/check.d.ts

@@ -1,7 +1,7 @@
-import type { AnyFunction } from '@augment-vir/core';
-import { checkOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { CheckGroup } from '../../guard-types/check-function.js';
-declare const checkGroup: CheckGroup<typeof extendableAssertions, typeof checkOverrides>;
+import { AnyFunction, ArrayElement } from '@augment-vir/core';
+import { UnionToIntersection } from 'type-fest';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+declare const checkMethods: UnionToIntersection<ArrayElement<typeof guardOverrides>['check']>;
 /**
  * A group of guard methods that return a boolean type guard rather than an assertion type guard.
  *
@@ -24,5 +24,5 @@ declare const checkGroup: CheckGroup<typeof extendableAssertions, typeof checkOv
  * @returns A boolean (as a type guard when possible).
  * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export declare const check: ((input: unknown) => boolean) & typeof checkGroup & Record<keyof AnyFunction, never>;
+export declare const check: ((input: unknown) => boolean) & typeof checkMethods & Record<keyof AnyFunction, never>;
 export {};

package/dist/augments/guards/check.js

@@ -1,6 +1,7 @@
-import { checkOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { createCheckGroup } from '../../guard-types/check-function.js';
-const checkGroup = createCheckGroup(extendableAssertions, checkOverrides);
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+const checkMethods = Object.assign({}, ...guardOverrides.map((entry) => {
+    return entry.check;
+}));
 /**
  * A group of guard methods that return a boolean type guard rather than an assertion type guard.
  *
@@ -25,4 +26,4 @@ const checkGroup = createCheckGroup(extendableAssertions, checkOverrides);
  */
 export const check = Object.assign(function check(input) {
     return !!input;
-}, checkGroup);
+}, checkMethods);

package/dist/augments/guards/wait-until.d.ts

@@ -1,6 +1,10 @@
-import { extendableAssertions, waitUntilOverrides } from '../../assertions/extendable-assertions.js';
-import { type WaitUntilGroup, type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
-declare const waitUntilGroup: WaitUntilGroup<typeof extendableAssertions, typeof waitUntilOverrides>;
+import { ArrayElement } from '@augment-vir/core';
+import { UnionToIntersection } from 'type-fest';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+import { type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+declare const waitUntilMethods: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
+    waitUntil: any;
+}>['waitUntil']>;
 /**
  * A group of guard methods that run the given callback multiple times until its return value
  * matches expectations. Callback interval and timeout can be customized with
@@ -36,5 +40,5 @@ declare const waitUntilGroup: WaitUntilGroup<typeof extendableAssertions, typeof
  * @throws {@link AssertionError} When the assertion fails.
  * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export declare const waitUntil: (<T>(callback: () => T, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<T>) & typeof waitUntilGroup;
+export declare const waitUntil: (<T>(callback: () => T, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<T>) & typeof waitUntilMethods;
 export {};

package/dist/augments/guards/wait-until.js

@@ -1,7 +1,9 @@
-import { extendableAssertions, waitUntilOverrides } from '../../assertions/extendable-assertions.js';
-import { createWaitUntilGroup, executeWaitUntil, } from '../../guard-types/wait-until-function.js';
+import { guardOverrides } from '../../assertions/extendable-assertions.js';
+import { executeWaitUntil } from '../../guard-types/wait-until-function.js';
 import { AssertionError } from '../assertion.error.js';
-const waitUntilGroup = createWaitUntilGroup(extendableAssertions, waitUntilOverrides);
+const waitUntilMethods = Object.assign({}, ...guardOverrides.map((entry) => {
+    return entry.waitUntil;
+}));
 /**
  * A group of guard methods that run the given callback multiple times until its return value
  * matches expectations. Callback interval and timeout can be customized with
@@ -42,8 +44,5 @@ export const waitUntil = Object.assign(function waitUntil(input, failureMessage)
         if (!input) {
             throw new AssertionError('Assertion failed.', failureMessage);
         }
-    }, [
-        input,
-        failureMessage,
-    ], false);
-}, waitUntilGroup);
+    }, [input, failureMessage], false);
+}, waitUntilMethods);

package/dist/guard-types/guard-group.d.ts

@@ -1,8 +1,11 @@
 /** C8 fails in type-only files. */
+import { AnyFunction, MaybePromise } from '@augment-vir/core';
 import type { AssertFunction } from './assert-function.js';
-import type { AssertWrapOverridesBase } from './assert-wrap-function.js';
-import type { CheckOverridesBase } from './check-function.js';
 import type { WaitUntilOverridesBase } from './wait-until-function.js';
+export type AssertWrapOverridesBase<Keys extends PropertyKey = string> = Partial<Readonly<Record<Keys, AnyFunction | undefined>>>;
+export type CheckFunction<Output> = (input: any, ...extraInputs: any[]) => input is Output;
+export type GenericCheckFunction = (input: any, ...extraInputs: any[]) => MaybePromise<boolean> | never;
+export type CheckOverridesBase<Keys extends PropertyKey = string> = Partial<Readonly<Record<Keys, CheckFunction<any> | GenericCheckFunction | undefined>>>;
 export type GuardGroup<Assertions extends Record<string, AssertFunction<any>>> = {
     assert: Assertions;
     check: CheckOverridesBase<keyof Assertions>;

package/dist/guard-types/wait-until-function.d.ts

@@ -1,8 +1,6 @@
 import type { AnyFunction, MaybePromise, NarrowToExpected, PartialWithUndefined, RemoveFirstTupleEntry, RemoveLastTupleEntry, RequiredAndNotNull } from '@augment-vir/core';
-import { type ExtractKeysWithMatchingValues, type Overwrite } from '@augment-vir/core';
 import { type AnyDuration } from '@date-vir/duration';
 import type { AssertFunction } from './assert-function.js';
-import { autoGuardSymbol } from './guard-override.js';
 /**
  * Options for configuring the timing of `waitUntil`.
  *
@@ -27,22 +25,16 @@ export type WaitUntilOptions = PartialWithUndefined<{
 }>;
 export declare const defaultWaitUntilOptions: RequiredAndNotNull<WaitUntilOptions>;
 export declare function executeWaitUntil<const Assert extends AssertFunction<any>>(this: void, assert: AssertFunction<any>, rawArgs: unknown[], requireSynchronousResult: boolean): Promise<ReturnType<WaitUntilFunction<Assert>>>;
-export type WaitUntilOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, AnyFunction | typeof autoGuardSymbol | undefined>>;
+export type WaitUntilOverridesBase<Keys extends PropertyKey = string> = Readonly<Partial<Record<Keys, AnyFunction | undefined>>>;
 export type WaitUntilFunctionParameters<Assert extends AssertFunction<any>, Input> = [
     ...RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>,
     () => MaybePromise<Input>
 ];
-export type WaitUntilFunction<Assert extends AssertFunction<any>> = Assert extends AssertFunction<infer Guard> ? <Input extends Parameters<Assert>[0]>(...params: [
+export type WaitUntilFunction<Assert extends AssertFunction<any>> = Assert extends AssertFunction<infer Guard> ? <Input extends Parameters<Assert>[0]>(this: void, ...params: [
     ...WaitUntilFunctionParameters<Assert, Input>,
     options?: WaitUntilOptions | undefined,
     failureMessage?: string | undefined
 ]) => Promise<NarrowToExpected<Input, Guard>> : never;
-export type WaitUntilGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, WaitUntilOverrides extends WaitUntilOverridesBase> = Omit<Overwrite<{
-    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: WaitUntilFunction<Asserts[Name]>;
-}, {
-    [Name in keyof WaitUntilOverrides]: WaitUntilOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<any> ? WaitUntilFunction<Asserts[Name]> : never : never : WaitUntilOverrides[Name];
-}>, ExtractKeysWithMatchingValues<WaitUntilOverrides, undefined>>;
-export declare function createWaitUntilGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const WaitUntilOverrides extends WaitUntilOverridesBase>(asserts: Asserts, waitUntilOverrides: WaitUntilOverrides): WaitUntilGroup<Asserts, WaitUntilOverrides>;
 export declare function createWaitUntil<const Assert extends AssertFunction<any>>(assert: Assert, requireSynchronousResult?: boolean): WaitUntilFunction<Assert>;
 export declare function parseWaitUntilArgs(rawArgs: unknown[]): {
     callback: AnyFunction;

package/dist/guard-types/wait-until-function.js

@@ -1,6 +1,5 @@
-import { ensureError, ensureErrorAndPrependMessage, wait, } from '@augment-vir/core';
+import { ensureError, ensureErrorAndPrependMessage, wait } from '@augment-vir/core';
 import { convertDuration } from '@date-vir/duration';
-import { pickOverride } from './guard-override.js';
 export const defaultWaitUntilOptions = {
     interval: {
         milliseconds: 100,
@@ -38,13 +37,6 @@ export async function executeWaitUntil(assert, rawArgs, requireSynchronousResult
     }
     return lastCallbackOutput;
 }
-export function createWaitUntilGroup(asserts, waitUntilOverrides) {
-    const waitUntilGroup = Object.entries(asserts).reduce((accum, [name, assert,]) => {
-        accum[name] = pickOverride(waitUntilOverrides, name, () => createWaitUntil(assert));
-        return accum;
-    }, {});
-    return waitUntilGroup;
-}
 export function createWaitUntil(assert, requireSynchronousResult = false) {
     return ((...rawArgs) => {
         return executeWaitUntil(assert, rawArgs, requireSynchronousResult);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { type Primitive } from 'type-fest';
 export * from './augments/assertion-exports.js';
 export * from './augments/assertion.error.js';
 export * from './augments/custom-equality.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/assert",
-    "version": "31.0.0",
+    "version": "31.0.1",
     "description": "A collection of assertions for test and production code alike.",
     "keywords": [
         "augment",
@@ -41,7 +41,7 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^31.0.0",
+        "@augment-vir/core": "^31.0.1",
         "@date-vir/duration": "^7.0.1",
         "deep-eql": "^5.0.2",
         "expect-type": "^1.1.0",

package/dist/guard-types/assert-wrap-function.d.ts

@@ -1,12 +0,0 @@
-import { type AnyFunction, type ExtractKeysWithMatchingValues, type NarrowToExpected, type Overwrite } from '@augment-vir/core';
-import { type AssertFunction } from './assert-function.js';
-import { autoGuardSymbol } from './guard-override.js';
-export type AssertWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToExpected<Input, Output>;
-export type AssertWrapOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, AnyFunction | undefined | typeof autoGuardSymbol>>;
-export type AssertWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, AssertWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{
-    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? AssertWrapFunction<Output> : never;
-}, {
-    [Name in keyof AssertWrapOverrides]: AssertWrapOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? AssertWrapFunction<Output> : never : never : AssertWrapOverrides[Name];
-}>, ExtractKeysWithMatchingValues<AssertWrapOverrides, undefined>>;
-export declare function createAssertWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const AssertWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, assertWrapOverrides: AssertWrapOverrides): AssertWrapGroup<Asserts, AssertWrapOverrides>;
-export declare function createAssertWrap<const Output>(assert: AssertFunction<Output>): AssertWrapFunction<Output>;

package/dist/guard-types/assert-wrap-function.js

@@ -1,14 +0,0 @@
-import { pickOverride } from './guard-override.js';
-export function createAssertWrapGroup(asserts, assertWrapOverrides) {
-    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
-        accum[name] = pickOverride(assertWrapOverrides, name, () => createAssertWrap(assert));
-        return accum;
-    }, {});
-    return checks;
-}
-export function createAssertWrap(assert) {
-    return ((...inputs) => {
-        assert(...inputs);
-        return inputs[0];
-    });
-}

package/dist/guard-types/check-function.d.ts

@@ -1,14 +0,0 @@
-import type { ExtractKeysWithMatchingValues, MaybePromise, Overwrite, RemoveFirstTupleEntry, RemoveLastTupleEntry } from '@augment-vir/core';
-import { type AssertFunction } from './assert-function.js';
-import { type autoGuardSymbol } from './guard-override.js';
-export type CheckFunction<Output> = (input: any, ...extraInputs: any[]) => input is Output;
-export type GenericCheckFunction = (input: any, ...extraInputs: any[]) => MaybePromise<boolean> | never;
-export type CheckOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, CheckFunction<any> | GenericCheckFunction | undefined | typeof autoGuardSymbol>>;
-export type CheckGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckOverrides extends CheckOverridesBase> = Omit<Overwrite<{
-    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? (input: Parameters<Asserts[Name]>[0], ...params: RemoveLastTupleEntry<RemoveFirstTupleEntry<Parameters<Asserts[Name]>>>) => input is Output : never;
-}, {
-    [Name in keyof CheckOverrides]: CheckOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? (input: Parameters<Asserts[Name]>[0], ...params: RemoveLastTupleEntry<RemoveFirstTupleEntry<Parameters<Asserts[Name]>>>) => input is Output : never : never : CheckOverrides[Name];
-}>, ExtractKeysWithMatchingValues<CheckOverrides, undefined>>;
-export declare function createCheckGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckOverrides extends CheckOverridesBase>(asserts: Asserts, checkOverrides: CheckOverrides): CheckGroup<Asserts, CheckOverrides>;
-export declare function createCheck<const Output>(assert: AssertFunction<Output>): CheckFunction<Output>;
-export declare function runAssertCheck<const Output, const Assert extends AssertFunction<Output>>(assert: Assert, input: Parameters<Assert>[0], ...inputs: RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>): input is Output;

package/dist/guard-types/check-function.js

@@ -1,22 +0,0 @@
-import { pickOverride } from './guard-override.js';
-export function createCheckGroup(asserts, checkOverrides) {
-    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
-        accum[name] = pickOverride(checkOverrides, name, () => createCheck(assert));
-        return accum;
-    }, {});
-    return checks;
-}
-export function createCheck(assert) {
-    return ((...inputs) => {
-        return runAssertCheck(assert, ...inputs);
-    });
-}
-export function runAssertCheck(assert, input, ...inputs) {
-    try {
-        assert(input, ...inputs);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/guard-types/check-wrap-wrapper-function.d.ts

@@ -1,12 +0,0 @@
-import type { ExtractKeysWithMatchingValues, NarrowToActual, Overwrite } from '@augment-vir/core';
-import { type AssertFunction } from './assert-function.js';
-import { type AssertWrapOverridesBase } from './assert-wrap-function.js';
-import { autoGuardSymbol } from './guard-override.js';
-export type CheckWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToActual<Input, Output> | undefined;
-export type CheckWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{
-    [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? CheckWrapFunction<Output> : never;
-}, {
-    [Name in keyof CheckWrapOverrides]: CheckWrapOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? CheckWrapFunction<Output> : never : never : CheckWrapOverrides[Name];
-}>, ExtractKeysWithMatchingValues<CheckWrapOverrides, undefined>>;
-export declare function createCheckWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, checkWrapOverrides: CheckWrapOverrides): CheckWrapGroup<Asserts, CheckWrapOverrides>;
-export declare function createCheckWrap<const Output>(assert: AssertFunction<Output>): CheckWrapFunction<Output>;

package/dist/guard-types/check-wrap-wrapper-function.js

@@ -1,19 +0,0 @@
-import { pickOverride } from './guard-override.js';
-export function createCheckWrapGroup(asserts, checkWrapOverrides) {
-    const checks = Object.entries(asserts).reduce((accum, [name, assert,]) => {
-        accum[name] = pickOverride(checkWrapOverrides, name, () => createCheckWrap(assert));
-        return accum;
-    }, {});
-    return checks;
-}
-export function createCheckWrap(assert) {
-    return ((...inputs) => {
-        try {
-            assert(...inputs);
-            return inputs[0];
-        }
-        catch {
-            return undefined;
-        }
-    });
-}

package/dist/guard-types/guard-override.d.ts

@@ -1,4 +0,0 @@
-import type { AnyObject, Values } from '@augment-vir/core';
-export declare const autoGuardSymbol: unique symbol;
-export declare function autoGuard<T>(): T;
-export declare function pickOverride<Overrides extends AnyObject, Created>(overrides: Overrides, name: string, create: () => Created): Values<Overrides> | Created;

package/dist/guard-types/guard-override.js

@@ -1,10 +0,0 @@
-export const autoGuardSymbol = Symbol('auto guard');
-export function autoGuard() {
-    return autoGuardSymbol;
-}
-export function pickOverride(overrides, name, create) {
-    if (name in overrides && overrides[name] !== autoGuardSymbol) {
-        return overrides[name];
-    }
-    return create();
-}