@cardstack/boxel-cli 0.9.0 → 0.10.0-unstable.0

package/bundled-test-harness/assets/dist-CLbqnmnm.js

@@ -1,389 +0,0 @@
-import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
-import { h as assert } from "./debug-Dg0TiPYl.js";
-import { wn as associateDestroyableChild } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { d as createCache, v as getValue } from "./validator-T25d_ucg.js";
-import { i as setOwner } from "./application-VoCE-EjL.js";
-import "./destroyable-mdLYRn_o.js";
-import { t as dist_exports$1 } from "./dist-qkBOmIQy.js";
-import { c as invokeHelper, l as setHelperManager, n as capabilities } from "./helper-BHX0HLF2.js";
-import { t as esCompat } from "./es-compat2-CZCbH4TS.js";
-//#region ../../node_modules/.pnpm/ember-modify-based-class-resource@1.1.2_@babel+core@7.29.7_supports-color@8.1.1__@glimm_d7c900291e205ac92ae71eb3fb8b1b28/node_modules/ember-modify-based-class-resource/dist/core/utils.js
-var DEFAULT_THUNK = () => [];
-function normalizeThunk(thunk) {
-	if (!thunk) return {
-		named: {},
-		positional: []
-	};
-	let args = thunk();
-	if (Array.isArray(args)) return {
-		named: {},
-		positional: args
-	};
-	if (!args) return {
-		named: {},
-		positional: []
-	};
-	/**
-	* Hopefully people aren't using args named "named"
-	*/
-	if ("positional" in args || "named" in args) return args;
-	return {
-		named: args,
-		positional: []
-	};
-}
-//#endregion
-//#region ../../node_modules/.pnpm/ember-modify-based-class-resource@1.1.2_@babel+core@7.29.7_supports-color@8.1.1__@glimm_d7c900291e205ac92ae71eb3fb8b1b28/node_modules/ember-modify-based-class-resource/dist/core/class-based/resource.js
-var TYPE = "class-based";
-{
-	const { registerUsable } = esCompat(dist_exports$1);
-	registerUsable(TYPE, (context, config) => {
-		let { definition, thunk } = config;
-		return invokeHelper(context, definition, () => normalizeThunk(thunk));
-	});
-}
-/**
-* @private utility type
-*
-* Returns the Thunk-cased args for a given Class/InstanceType of Resource
-*/
-/**
-* https://gist.github.com/dfreeman/e4728f2f48737b44efb99fa45e2d22ef#typing-the-return-value-implicitly
-*
-* This is a Glint helper to help HelperLike determine what the ReturnType is.
-*/
-/**
-* The 'Resource' base class has only one lifecycle hook, `modify`, which is called during
-* instantiation of the resource as well as on every update of any of any consumed args.
-*
-* Typically, a `Resource` will be used to build higher-level APIs that you'd then use in your apps.
-* For example, maybe you want to build a reactive-wrapper around a non-reactive wrapper, XState
-* which requires that the "State machine interpreter"
-* is stopped when you are discarding the parent context (such as a component).
-*
-* _When would you reach for the class-based `Resource` instead of the function-based `resource`?_
-*
-*  - the capabilities of the function-based resource and class-based resource are almost identical.
-*    the main difference is that function-based resources may represent a single a value
-*    (which could, itself, be a class instance, or object with properties),
-*    class-based-resources expose the whole class instance to the consumer.
-*
-*  - function-based resources, however, are much easier to work with and understand, and have
-*    better intellisense capabilities.
-*
-*
-* An example
-* ```js
-* import { Resource } from 'ember-modify-based-class-resource';
-* import { createMachine, interpret } from 'xstate';
-*
-* const machine = createMachine(); // ... see XState docs for this function this ...
-*
-* class MyResource extends Resource {
-*   @tracked customState;
-*
-*   constructor(owner) {
-*     super(owner);
-*
-*     registerDestructor(this, () => this.interpreter.stop());
-*   }
-*
-*   modify(positional, named) {
-*     if (!this.interpreter) {
-*       // Initial Setup
-*       this.interpreter = interpret(machine).onTransition(state => this.customState = state);
-*     } else {
-*       // Subsequent Updates
-*       this.interpreter.send('SOME_EVENT', { positional, named });
-*     }
-*   }
-* }
-* ```
-*
-* Once defined, there are two ways to use `MyResource`
-*  - in a template
-*  - in JavaScript
-*
-* In the template, the Resource can be imported (or re-exported from the helpers directory)
-*
-* When imported (using [RFC 779](https://github.com/emberjs/rfcs/pull/779)),
-* ```jsx gjs
-* import { MyResource } from './somewhere';
-*
-* <template>
-*   {{#let (MyResource) as |myResource|}}
-*     {{log myResource.customState}}
-*   {{/let}}
-* </template>
-*
-* ```
-*
-* When using in javascript, you'll need the `from` utility
-* ```ts
-* import { MyResource } from './somewhere';
-*
-* class ContainingClass {
-*   state = MyResource.from(this, () => [...])
-* }
-* ```
-* However, when authoring a Resource, it's useful to co-locate an export of a helper function:
-* ```js
-* export function myResource(destroyable, options) {
-*   return MyResource.from(destroyable, () => ({
-*     foo: () => options.foo,
-*     bar: () => options.bar,
-*   }))
-* }
-* ```
-*
-* This way, consumers only need one import.
-*
-* If your resource may be used with other resources in the same file,
-* class-based resources also work with use, which gives the benefit of
-* omitting the `this` parameter to `from`.
-*
-* ```js
-* import { use } from 'ember-resources';
-* import { MyResource } from './somewhere';
-* import { SomeRequest } from './somewhere-else';
-* import { WebSocket } from './connection';
-*
-* class ContainingClass {
-*   @use state = MyResource.from(() => [...])
-*   @use request = SomeRequest.from(() => [...])
-*   @use socket = WebSocket.from(() => [...])
-* }
-* ```
-*
-*/
-var Resource = class {
-	/**
-	* @private (secret)
-	*
-	* Because classes are kind of like interfaces,
-	* we need "something" to help TS know what a Resource is.
-	*
-	* This isn't a real API, but does help with type inference
-	* with the ArgsFrom utility above
-	*/
-	/**
-	* @private (secret)
-	*
-	* This is a lie, but a useful one for Glint, because
-	* Glint's "HelperLike" matches on this "Invoke" property.
-	*
-	* Faking the interface of `HelperLike` is the only way we can get Glint to treat
-	*  class-based resources as helpers in templates.
-	*
-	* If subclassing was not needed, we could just "merge the interface" with Resource
-	* and HelperLike, but merged interfaces are not retained in subclasses.
-	*
-	* Without this, the static method, from, would have a type error.
-	*/
-	/**
-	* For use in the body of a class.
-	*
-	* `from` is what allows resources to be used in JS, they hide the reactivity APIs
-	* from the consumer so that the surface API is smaller.
-	*
-	* ```js
-	* import { use } from 'ember-resources';
-	* import { Resource } from 'ember-modify-based-class-resource';
-	*
-	* class SomeResource extends Resource {}
-	*
-	* class MyClass {
-	*   @use data = SomeResource.from(() => [ ... ]);
-	* }
-	* ```
-	*/
-	/**
-	* For use in the body of a class.
-	*
-	* `from` is what allows resources to be used in JS, they hide the reactivity APIs
-	* from the consumer so that the surface API is smaller.
-	* Though it _may_ be more convenient to not wrap your resource abstraction in a helper function.
-	*
-	* ```js
-	* import { Resource } from 'ember-modify-based-class-resource';
-	*
-	* class SomeResource extends Resource {}
-	*
-	* class MyClass {
-	*   data = SomeResource.from(this, () => [ ... ]);
-	* }
-	* ```
-	*
-	* However, if you have argument defaults or need to change the shape of arguments
-	* depending on what ergonomics you want your users to have, a wrapper function
-	* may be better.
-	*
-	* ```js
-	* export function someResource(context, { foo, bar }) {
-	*   return SomeResource.from(context, () =>  ... );
-	* }
-	* ```
-	*  usage:
-	* ```js
-	* import { someResource } from 'your-library';
-	*
-	* class SomeResource extends Resource {}
-	*
-	* class MyClass {
-	*   @tracked foo;
-	*   @tracked bar;
-	*
-	*   data = someResource(this, {
-	*     foo: () => this.foo,
-	*     bar: () => this.bar
-	*   });
-	* }
-	* ```
-	*/
-	static from(contextOrThunk, thunkOrUndefined) {
-		/**
-		* This first branch is for
-		*
-		* ```js
-		* class Foo {
-		*   @use foo = SomeResource.from(() => [ ... ])
-		* }
-		* ```
-		*
-		* and in order to support this, we need to defer the passed
-		* thunk until when the decorator is accessed.
-		*
-		* The decorator mostly does what `resourceOf` is doing below, but
-		* a little more simply, because we don't have to deal with a Proxy.
-		*
-		*/
-		if (typeof contextOrThunk === "function")
- /**
-		* We have to lie here because TypeScript doesn't allow decorators
-		* to alter the type of a property.
-		*
-		* This is private API that the `@use` decorator understands,
-		* but is not supported for use by any other conusmer.
-		*/
-		return {
-			thunk: contextOrThunk,
-			definition: this,
-			type: TYPE,
-			__INTERNAL__: true
-		};
-		/**
-		* This usage is for decorator-less usage
-		*
-		* ```js
-		* class Foo {
-		*   foo = SomeResource.from(this, () => [ ... ])
-		* }
-		* ```
-		*
-		* The only tradeoff is that a `this` needs to be passed.
-		*
-		*/
-		return resourceOf(contextOrThunk, this, thunkOrUndefined);
-	}
-	constructor(owner) {
-		setOwner(this, owner);
-	}
-};
-function resourceOf(context, klass, thunk) {
-	!(klass.prototype instanceof Resource) && assert(`Expected second argument, klass, to be a Resource. Instead, received some ${typeof klass}, ${klass.name}`, klass.prototype instanceof Resource);
-	let cache;
-	/**
-	* This proxy takes everything called on or accessed on "target"
-	* and forwards it along to target.value (where the actual resource instance is)
-	*
-	* It's important to only access .value within these proxy-handler methods so that
-	* consumers "reactively entangle with" the Resource.
-	*/
-	return new Proxy({ get value() {
-		if (!cache) cache = invokeHelper(context, klass, () => normalizeThunk(thunk || DEFAULT_THUNK));
-		return getValue(cache);
-	} }, {
-		get(target, key) {
-			const instance = target.value;
-			const value = Reflect.get(instance, key, instance);
-			return typeof value === "function" ? value.bind(instance) : value;
-		},
-		ownKeys(target) {
-			const instance = target.value;
-			return Reflect.ownKeys(instance);
-		},
-		getOwnPropertyDescriptor(target, key) {
-			const instance = target.value;
-			return Reflect.getOwnPropertyDescriptor(instance, key);
-		}
-	});
-}
-//#endregion
-//#region ../../node_modules/.pnpm/ember-modify-based-class-resource@1.1.2_@babel+core@7.29.7_supports-color@8.1.1__@glimm_d7c900291e205ac92ae71eb3fb8b1b28/node_modules/ember-modify-based-class-resource/dist/core/class-based/manager.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-		return typeof o;
-	} : function(o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof(o);
-}
-function _toPrimitive(input, hint) {
-	if (_typeof(input) !== "object" || input === null) return input;
-	var prim = input[Symbol.toPrimitive];
-	if (prim !== void 0) {
-		var res = prim.call(input, hint || "default");
-		if (_typeof(res) !== "object") return res;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return (hint === "string" ? String : Number)(input);
-}
-function _toPropertyKey(arg) {
-	var key = _toPrimitive(arg, "string");
-	return _typeof(key) === "symbol" ? key : String(key);
-}
-function _defineProperty(obj, key, value) {
-	key = _toPropertyKey(key);
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-	else obj[key] = value;
-	return obj;
-}
-var ResourceManager = class {
-	constructor(owner) {
-		_defineProperty(this, "capabilities", capabilities("3.23", {
-			hasValue: true,
-			hasDestroyable: true
-		}));
-		this.owner = owner;
-	}
-	createHelper(Class, args) {
-		let owner = this.owner;
-		let instance;
-		let cache = createCache(() => {
-			if (instance === void 0) {
-				instance = new Class(owner);
-				associateDestroyableChild(cache, instance);
-			}
-			if (instance.modify) instance.modify(args.positional, args.named);
-			return instance;
-		});
-		return cache;
-	}
-	getValue(cache) {
-		return getValue(cache);
-	}
-	getDestroyable(cache) {
-		return cache;
-	}
-};
-setHelperManager((owner) => new ResourceManager(owner), Resource);
-//#endregion
-//#region ../../node_modules/.pnpm/ember-modify-based-class-resource@1.1.2_@babel+core@7.29.7_supports-color@8.1.1__@glimm_d7c900291e205ac92ae71eb3fb8b1b28/node_modules/ember-modify-based-class-resource/dist/index.js
-var dist_exports = /* @__PURE__ */ __exportAll({ Resource: () => Resource });
-//#endregion
-export { Resource as n, dist_exports as t };

package/bundled-test-harness/assets/dist-qkBOmIQy.js

@@ -1,323 +0,0 @@
-import { r as __exportAll } from "./chunk-Rp0pCe6z.js";
-import { h as assert } from "./debug-Dg0TiPYl.js";
-import { Tn as destroy, et as tracked, wn as associateDestroyableChild } from "./cache-DtDz7X5V-Wn8jRDfL.js";
-import { d as createCache, v as getValue } from "./validator-T25d_ucg.js";
-import { n as application_exports } from "./application-VoCE-EjL.js";
-import { n as registerDestructor } from "./destroyable-mdLYRn_o.js";
-import "./tracking-CNiq91Pk.js";
-import { c as invokeHelper, l as setHelperManager, n as capabilities } from "./helper-BHX0HLF2.js";
-import { t as esCompat } from "./es-compat2-CZCbH4TS.js";
-//#region ../../node_modules/.pnpm/ember-resources@7.0.8_@glimmer+component@2.1.1_supports-color@8.1.1__@glint+template@1.7.7_supports-color@8.1.1/node_modules/ember-resources/dist/index.js
-var dist_exports = /* @__PURE__ */ __exportAll({
-	cell: () => cell,
-	registerUsable: () => registerUsable,
-	resource: () => resource,
-	resourceFactory: () => resourceFactory,
-	use: () => use
-});
-var INTERMEDIATE_VALUE = "__Intermediate_Value__";
-var INTERNAL = "__INTERNAL__";
-var CURRENT = Symbol("ember-resources::CURRENT");
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-	var result = void 0;
-	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = decorator(target, key, result) || result;
-	if (result) __defProp(target, key, result);
-	return result;
-};
-var ReadonlyCell = class {
-	#getter;
-	constructor(getter) {
-		this.#getter = getter;
-	}
-	toHTML() {
-		assert("Not a valid API. Please access either .current or .read() if the value of this Cell is needed");
-	}
-	get [CURRENT]() {
-		return this.current;
-	}
-	get current() {
-		return this.#getter();
-	}
-};
-var Cell = class {
-	get [CURRENT]() {
-		return this.current;
-	}
-	toHTML() {
-		assert("Not a valid API. Please access either .current or .read() if the value of this Cell is needed");
-	}
-	constructor(initialValue) {
-		if (initialValue !== void 0) this.current = initialValue;
-	}
-	/**
-	* Toggles the value of `current` only if
-	* `current` is a boolean -- errors otherwise
-	*/
-	toggle = () => {
-		!(typeof this.current === "boolean" || this.current === void 0) && assert(`toggle can only be used when 'current' is a boolean type`, typeof this.current === "boolean" || this.current === void 0);
-		this.current = !this.current;
-	};
-	/**
-	* Updates the value of `current`
-	* by calling a function that receives the previous value.
-	*/
-	update = (updater) => {
-		this.current = updater(this.current);
-	};
-	/**
-	* Updates the value of `current`
-	*/
-	set = (nextValue) => {
-		this.current = nextValue;
-	};
-	/**
-	* Returns the current value.
-	*/
-	read = () => this.current;
-};
-__decorateClass([tracked], Cell.prototype, "current");
-function cell(initialValue) {
-	if (initialValue !== void 0) return new Cell(initialValue);
-	return new Cell();
-}
-var CellManager = class {
-	capabilities = capabilities("3.23", { hasValue: true });
-	createHelper(cell2) {
-		return cell2;
-	}
-	getValue(cell2) {
-		return cell2.current;
-	}
-};
-var cellEvaluator = new CellManager();
-setHelperManager(() => cellEvaluator, Cell.prototype);
-setHelperManager(() => cellEvaluator, ReadonlyCell.prototype);
-var compatOwner = {};
-compatOwner.getOwner = esCompat(application_exports).getOwner;
-compatOwner.setOwner = esCompat(application_exports).setOwner;
-var setOwner$1 = compatOwner.setOwner;
-var ResourceInvokerManager = class {
-	constructor(owner) {
-		this.owner = owner;
-	}
-	capabilities = capabilities("3.23", {
-		hasValue: true,
-		hasDestroyable: true
-	});
-	createHelper(fn, args) {
-		let previous;
-		const cache = createCache(() => {
-			let resource2 = fn(...[...args.positional, args.named]);
-			setOwner$1(resource2, this.owner);
-			let result = invokeHelper(cache, resource2);
-			if (previous) destroy(previous);
-			previous = result;
-			return result;
-		});
-		setOwner$1(cache, this.owner);
-		return { cache };
-	}
-	/**
-	* getValue is re-called when args change
-	*/
-	getValue({ cache }) {
-		let resource2 = getValue(cache);
-		associateDestroyableChild(cache, resource2);
-		return getValue(resource2);
-	}
-	getDestroyable({ cache }) {
-		return cache;
-	}
-};
-function resourceFactory(wrapperFn) {
-	setHelperManager(ResourceInvokerFactory, wrapperFn);
-	return wrapperFn;
-}
-var ResourceInvokerFactory = (owner) => {
-	!owner && assert(`Cannot create resource without an owner`, owner);
-	return new ResourceInvokerManager(owner);
-};
-var setOwner = compatOwner.setOwner;
-var FunctionResourceManager = class {
-	constructor(owner) {
-		this.owner = owner;
-	}
-	capabilities = capabilities("3.23", {
-		hasValue: true,
-		hasDestroyable: true
-	});
-	/**
-	* Resources do not take args.
-	* However, they can access tracked data
-	*/
-	createHelper(config) {
-		let { definition: fn } = config;
-		let thisFn = fn.bind(null);
-		let previousFn;
-		let usableCache = /* @__PURE__ */ new WeakMap();
-		let owner = this.owner;
-		let cache = createCache(() => {
-			if (previousFn) destroy(previousFn);
-			let currentFn = thisFn.bind(null);
-			associateDestroyableChild(thisFn, currentFn);
-			previousFn = currentFn;
-			return currentFn({
-				on: { cleanup: (destroyer) => {
-					registerDestructor(currentFn, destroyer);
-				} },
-				use: (usable) => {
-					!(typeof usable === "object") && assert(`Expected the resource's \`use(...)\` utility to have been passed an object, but a \`${typeof usable}\` was passed.`, typeof usable === "object");
-					!usable && assert(`Expected the resource's \`use(...)\` utility to have been passed a truthy value, instead was passed: ${usable}.`, usable);
-					!(INTERNAL in usable) && assert(`Expected the resource's \`use(...)\` utility to have been passed another resource, but something else was passed.`, INTERNAL in usable);
-					let previousCache = usableCache.get(usable);
-					if (previousCache) destroy(previousCache);
-					let nestedCache = invokeHelper(cache, usable);
-					associateDestroyableChild(currentFn, nestedCache);
-					usableCache.set(usable, nestedCache);
-					return new ReadonlyCell(() => {
-						let cache2 = usableCache.get(usable);
-						!cache2 && assert(`Cache went missing while evaluating the result of a resource.`, cache2);
-						return getValue(cache2);
-					});
-				},
-				owner: this.owner
-			});
-		});
-		setOwner(cache, owner);
-		return {
-			fn: thisFn,
-			cache
-		};
-	}
-	getValue({ cache }) {
-		let maybeValue = getValue(cache);
-		if (typeof maybeValue === "function") return maybeValue();
-		if (isReactive(maybeValue)) return maybeValue[CURRENT];
-		return maybeValue;
-	}
-	getDestroyable({ fn }) {
-		return fn;
-	}
-};
-function isReactive(maybe) {
-	return typeof maybe === "object" && maybe !== null && CURRENT in maybe;
-}
-var ResourceManagerFactory = (owner) => {
-	!owner && assert(`Cannot create resource without an owner`, owner);
-	return new FunctionResourceManager(owner);
-};
-function use(...args) {
-	if (args.length === 3) return initializerDecorator(...args);
-	if (args.length === 2) {
-		if (typeof args[1] !== "string" && typeof args[1] !== "symbol") return classContextLink(args[0], args[1]);
-	}
-	if (args.length === 1) return argumentToDecorator(args[0]);
-	assert(`Unknown arity for \`use\`. Received ${args.length} arguments`, false);
-}
-function getCurrentValue(value) {
-	if (typeof value === "object" && value !== null && "current" in value) return value.current;
-	return value;
-}
-function classContextLink(context, definition) {
-	let cache;
-	return new ReadonlyCell(() => {
-		if (!cache) {
-			cache = invokeHelper(context, definition);
-			associateDestroyableChild(context, cache);
-		}
-		return getCurrentValue(getValue(cache));
-	});
-}
-function argumentToDecorator(definition) {
-	return (_prototype, key, descriptor) => {
-		if (!descriptor) return;
-		!(typeof key === "string") && assert(`@use can only be used with string-keys`, typeof key === "string");
-		descriptor.initializer && assert(`When @use(...) is passed a resource, an initialized value is not allowed. \`@use(Clock) time;`, !descriptor.initializer);
-		return descriptorGetter(definition);
-	};
-}
-var USABLES = /* @__PURE__ */ new Map();
-function registerUsable(type, useFn) {
-	USABLES.has(type) && assert(`type may not overlap with an existing usable`, !USABLES.has(type));
-	USABLES.set(type, useFn);
-}
-function descriptorGetter(initializer) {
-	let caches = /* @__PURE__ */ new WeakMap();
-	return { get() {
-		let cache = caches.get(this);
-		if (!cache) {
-			let config = typeof initializer === "function" ? initializer.call(this) : initializer;
-			let usable = USABLES.get(config.type);
-			!usable && assert(`Expected the initialized value with @use to have been a registerd "usable". Available usables are: ${[...USABLES.keys()]}`, usable);
-			cache = usable(this, config);
-			!cache && assert(`Failed to create cache for usable: ${config.type}`, cache);
-			caches.set(this, cache);
-			associateDestroyableChild(this, cache);
-		}
-		return getCurrentValue(getValue(cache));
-	} };
-}
-function initializerDecorator(_prototype, key, descriptor) {
-	if (!descriptor) return;
-	!(typeof key === "string") && assert(`@use can only be used with string-keys`, typeof key === "string");
-	let { initializer } = descriptor;
-	!initializer && assert(`@use may only be used on initialized properties. For example, \`@use foo = resource(() => { ... })\` or \`@use foo = SomeResource.from(() => { ... });\``, initializer);
-	return descriptorGetter(initializer);
-}
-function wrapForPlainUsage(context, setup) {
-	let cache;
-	return new Proxy({ get [INTERMEDIATE_VALUE]() {
-		if (!cache) cache = invokeHelper(context, setup);
-		return getValue(cache);
-	} }, {
-		get(target2, key) {
-			const state = target2[INTERMEDIATE_VALUE];
-			!state && assert("[BUG]: it should not have been possible for this to be undefined", state);
-			return Reflect.get(state, key, state);
-		},
-		ownKeys(target2) {
-			const value = target2[INTERMEDIATE_VALUE];
-			!value && assert("[BUG]: it should not have been possible for this to be undefined", value);
-			return Reflect.ownKeys(value);
-		},
-		getOwnPropertyDescriptor(target2, key) {
-			const value = target2[INTERMEDIATE_VALUE];
-			!value && assert("[BUG]: it should not have been possible for this to be undefined", value);
-			return Reflect.getOwnPropertyDescriptor(value, key);
-		}
-	});
-}
-var TYPE = "function-based";
-registerUsable(TYPE, (context, config) => {
-	return invokeHelper(context, config);
-});
-function resource(context, setup) {
-	if (!setup) {
-		!(typeof context === "function") && assert(`When using \`resource\` with @use, the first argument to \`resource\` must be a function. Instead, a ${typeof context} was received.`, typeof context === "function");
-		let internalConfig2 = {
-			definition: context,
-			type: "function-based",
-			name: "Resource",
-			[INTERNAL]: true
-		};
-		setHelperManager(ResourceManagerFactory, internalConfig2);
-		return internalConfig2;
-	}
-	!(typeof context === "object") && assert(`Mismatched argument types passed to \`resource\`. Expected the first arg, the context, to be a type of object. This is usually the \`this\`. Received ${typeof context} instead.`, typeof context === "object");
-	!(typeof setup === "function") && assert(`Mismatched argument type passed to \`resource\`. Expected the second arg to be a function but instead received ${typeof setup}.`, typeof setup === "function");
-	let internalConfig = {
-		definition: setup,
-		type: TYPE,
-		name: getDebugName(setup),
-		[INTERNAL]: true
-	};
-	setHelperManager(ResourceManagerFactory, internalConfig);
-	return wrapForPlainUsage(context, internalConfig);
-}
-function getDebugName(obj) {
-	if ("name" in obj) return `Resource Function: ${obj.name}`;
-	return `Resource Function`;
-}
-//#endregion
-export { resource as n, use as r, dist_exports as t };