@kubb/core 5.0.0-alpha.3 → 5.0.0-alpha.31

package/src/utils/FunctionParams.ts

@@ -30,12 +30,12 @@ type FunctionParamsASTWithType = {
   default?: string
 }
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
 
 /**
- * @deprecated
+ * @deprecated use ast package instead
  */
 export class FunctionParams {
   #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []

package/src/utils/TreeNode.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { getMode } from '../PluginManager.ts'
+import type * as KubbFile from '../KubbFile.ts'
+import { getMode } from '../PluginDriver.ts'
 
 type BarrelData = {
   file?: KubbFile.File
@@ -12,6 +12,15 @@ type BarrelData = {
   name: string
 }
 
+/**
+ * Tree structure used to build per-directory barrel (`index.ts`) files from a
+ * flat list of generated {@link KubbFile.File} entries.
+ *
+ * Each node represents either a directory or a file within the output tree.
+ * Use {@link TreeNode.build} to construct a root node from a file list, then
+ * traverse with {@link TreeNode.forEach}, {@link TreeNode.leaves}, or the
+ * `*Deep` helpers.
+ */
 export class TreeNode {
   data: BarrelData
   parent?: TreeNode
@@ -32,6 +41,9 @@ export class TreeNode {
     return child
   }
 
+  /**
+   * Returns the root ancestor of this node, walking up via `parent` links.
+   */
   get root(): TreeNode {
     if (!this.parent) {
       return this
@@ -39,6 +51,11 @@ export class TreeNode {
     return this.parent.root
   }
 
+  /**
+   * Returns all leaf descendants (nodes with no children) of this node.
+   *
+   * Results are cached after the first traversal.
+   */
   get leaves(): Array<TreeNode> {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
@@ -59,6 +76,9 @@ export class TreeNode {
     return leaves
   }
 
+  /**
+   * Visits this node and every descendant in depth-first order.
+   */
   forEach(callback: (treeNode: TreeNode) => void): this {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -73,6 +93,9 @@ export class TreeNode {
     return this
   }
 
+  /**
+   * Finds the first leaf that satisfies `predicate`, or `undefined` when none match.
+   */
   findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
     if (typeof predicate !== 'function') {
       throw new TypeError('find() predicate must be a function')
@@ -81,6 +104,9 @@ export class TreeNode {
     return this.leaves.find(predicate)
   }
 
+  /**
+   * Calls `callback` for every leaf of this node.
+   */
   forEachDeep(callback: (treeNode: TreeNode) => void): void {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -89,6 +115,9 @@ export class TreeNode {
     this.leaves.forEach(callback)
   }
 
+  /**
+   * Returns all leaves that satisfy `callback`.
+   */
   filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
     if (typeof callback !== 'function') {
       throw new TypeError('filter() callback must be a function')
@@ -97,6 +126,9 @@ export class TreeNode {
     return this.leaves.filter(callback)
   }
 
+  /**
+   * Maps every leaf through `callback` and returns the resulting array.
+   */
   mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
     if (typeof callback !== 'function') {
       throw new TypeError('map() callback must be a function')
@@ -105,6 +137,12 @@ export class TreeNode {
     return this.leaves.map(callback)
   }
 
+  /**
+   * Builds a {@link TreeNode} tree from a flat list of files.
+   *
+   * - Filters to files under `root` (when provided) and skips `.json` files.
+   * - Returns `null` when no files match.
+   */
   public static build(files: KubbFile.File[], root?: string): TreeNode | null {
     try {
       const filteredTree = buildDirectoryTree(files, root)

package/src/utils/diagnostics.ts

@@ -2,7 +2,10 @@ import { version as nodeVersion } from 'node:process'
 import { version as KubbVersion } from '../../package.json'
 
 /**
- * Get diagnostic information for debugging
+ * Returns a snapshot of the current runtime environment.
+ *
+ * Useful for attaching context to debug logs and error reports so that
+ * issues can be reproduced without manual information gathering.
  */
 export function getDiagnosticInfo() {
   return {

package/src/utils/executeStrategies.ts

@@ -7,7 +7,12 @@ type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Arr
 type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>
 
 /**
- * Chains promises
+ * Runs promise functions in sequence, threading each result into the next call.
+ *
+ * - Each function receives the accumulated state from the previous call.
+ * - Skips functions that return a falsy value (acts as a no-op for that step).
+ * - Returns an array of all individual results.
+ *  @deprecated
  */
 export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TOutput = SeqOutput<TInput, TValue>>(promises: TInput): TOutput {
   return promises.filter(Boolean).reduce(
@@ -33,7 +38,11 @@ export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue,
 type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>
 
 /**
- * Chains promises, first non-null result stops and returns
+ * Runs promise functions in sequence and returns the first non-null result.
+ *
+ * - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
+ * - Subsequent functions are skipped once a match is found.
+ *  @deprecated
  */
 export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
   promises: TInput,
@@ -57,7 +66,11 @@ export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValu
 type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
 
 /**
- * Runs an array of promise functions with optional concurrency limit.
+ * Runs promise functions concurrently and returns all settled results.
+ *
+ * - Limits simultaneous executions to `concurrency` (default: unlimited).
+ * - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
+ *  @deprecated
  */
 export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
   promises: TInput,
@@ -70,12 +83,18 @@ export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TV
   return Promise.allSettled(tasks) as TOutput
 }
 
+/**
+ * Execution strategy used when dispatching plugin hook calls.
+ *  @deprecated
+ */
 export type Strategy = 'seq' | 'first' | 'parallel'
 
-export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = TStrategy extends 'first'
-  ? HookFirstOutput<TInput, TValue>
-  : TStrategy extends 'seq'
-    ? SeqOutput<TInput, TValue>
-    : TStrategy extends 'parallel'
-      ? HookParallelOutput<TInput, TValue>
-      : never
+type StrategyOutputMap<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = {
+  first: HookFirstOutput<TInput, TValue>
+  seq: SeqOutput<TInput, TValue>
+  parallel: HookParallelOutput<TInput, TValue>
+}
+/**
+ *  @deprecated
+ */
+export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = StrategyOutputMap<TInput, TValue>[TStrategy]

package/src/utils/formatters.ts

@@ -4,18 +4,13 @@ import type { formatters } from '../constants.ts'
 type Formatter = keyof typeof formatters
 
 /**
- * Check if a formatter command is available in the system.
+ * Returns `true` when the given formatter is installed and callable.
  *
- * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
- * @returns Promise that resolves to true if the formatter is available, false otherwise
- *
- * @remarks
- * This function checks availability by running `<formatter> --version` command.
- * All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+ * Availability is detected by running `<formatter> --version` and checking
+ * that the process exits without error.
  */
 async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
   try {
-    // Try to get the version of the formatter to check if it's installed
     await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
     return true
   } catch {
@@ -24,27 +19,21 @@ async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
 }
 
 /**
- * Detect which formatter is available in the system.
- *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
+ * Detects the first available code formatter on the current system.
  *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
+ * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
+ * - Returns `null` when none are found.
  *
  * @example
- * ```typescript
+ * ```ts
  * const formatter = await detectFormatter()
  * if (formatter) {
  *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
  * }
  * ```
  */
-export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatterNames: Formatter[] = ['biome', 'oxfmt', 'prettier']
+export async function detectFormatter(): Promise<Formatter | null> {
+  const formatterNames = new Set(['biome', 'oxfmt', 'prettier'] as const)
 
   for (const formatter of formatterNames) {
     if (await isFormatterAvailable(formatter)) {
@@ -52,5 +41,5 @@ export async function detectFormatter(): Promise<Formatter | undefined> {
     }
   }
 
-  return undefined
+  return null
 }

package/src/utils/getBarrelFiles.ts

@@ -1,7 +1,9 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { BarrelManager } from '../BarrelManager.ts'
+import { getRelativePath } from '@internals/utils'
+import type * as KubbFile from '../KubbFile.ts'
 import type { BarrelType } from '../types.ts'
+import { TreeNode } from './TreeNode.ts'
 
 export type FileMetaBase = {
   pluginName?: string
@@ -27,6 +29,72 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
+function getBarrelFilesByRoot(root: string | undefined, files: Array<KubbFile.ResolvedFile>): Array<KubbFile.File> {
+  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+
+  TreeNode.build(files, root)?.forEach((treeNode) => {
+    if (!treeNode?.children || !treeNode.parent?.data.path) {
+      return
+    }
+
+    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path
+    const barrelFile: KubbFile.File = {
+      path: barrelFilePath,
+      baseName: 'index.ts',
+      exports: [],
+      imports: [],
+      sources: [],
+    }
+    const previousBarrelFile = cachedFiles.get(barrelFile.path)
+    const leaves = treeNode.leaves
+
+    leaves.forEach((item) => {
+      if (!item.data.name) {
+        return
+      }
+
+      const sources = item.data.file?.sources || []
+
+      sources.forEach((source) => {
+        if (!item.data.file?.path || !source.isIndexable || !source.name) {
+          return
+        }
+        const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
+          (item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly,
+        )
+
+        if (alreadyContainInPreviousBarrelFile) {
+          return
+        }
+
+        barrelFile.exports!.push({
+          name: [source.name],
+          path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+          isTypeOnly: source.isTypeOnly,
+        })
+
+        barrelFile.sources.push({
+          name: source.name,
+          isTypeOnly: source.isTypeOnly,
+          //TODO use parser to generate import
+          value: '',
+          isExportable: false,
+          isIndexable: false,
+        })
+      })
+    })
+
+    if (previousBarrelFile) {
+      previousBarrelFile.sources.push(...barrelFile.sources)
+      previousBarrelFile.exports?.push(...(barrelFile.exports || []))
+    } else {
+      cachedFiles.set(barrelFile.path, barrelFile)
+    }
+  })
+
+  return [...cachedFiles.values()]
+}
+
 function trimExtName(text: string): string {
   const dotIndex = text.lastIndexOf('.')
   // Only strip when the dot is found and no path separator follows it
@@ -37,24 +105,26 @@ function trimExtName(text: string): string {
   return text
 }
 
-export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<KubbFile.File[]> {
+/**
+ * Generates `index.ts` barrel files for all directories under `root/output.path`.
+ *
+ * - Returns an empty array when `type` is falsy or `'propagate'`.
+ * - Skips generation when the output path itself ends with `index` (already a barrel).
+ * - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
+ * - Attaches `meta` to each barrel file for downstream plugin identification.
+ */
+export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<KubbFile.File>> {
   if (!type || type === 'propagate') {
     return []
   }
 
-  const barrelManager = new BarrelManager()
-
   const pathToBuildFrom = join(root, output.path)
 
   if (trimExtName(pathToBuildFrom).endsWith('index')) {
     return []
   }
 
-  const barrelFiles = barrelManager.getFiles({
-    files,
-    root: pathToBuildFrom,
-    meta,
-  })
+  const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files)
 
   if (type === 'all') {
     return barrelFiles.map((file) => {

package/src/utils/getConfigs.ts

@@ -1,30 +1,16 @@
-import type { CLIOptions, ConfigInput } from '../config.ts'
+import type { CLIOptions, ConfigInput } from '../defineConfig.ts'
 import type { Config, UserConfig } from '../types.ts'
-import { getPlugins } from './getPlugins.ts'
 
 /**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+ * Resolves a {@link ConfigInput} into a normalized array of {@link Config} objects.
+ *
+ * - Awaits the config when it is a `Promise`.
+ * - Calls the factory function with `args` when the config is a function.
+ * - Wraps a single config object in an array for uniform downstream handling.
  */
 export async function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>> {
-  const resolvedConfig: Promise<UserConfig | Array<UserConfig>> =
-    typeof config === 'function' ? Promise.resolve(config(args as CLIOptions)) : Promise.resolve(config)
+  const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
 
-  let userConfigs = await resolvedConfig
-
-  if (!Array.isArray(userConfigs)) {
-    userConfigs = [userConfigs]
-  }
-
-  const results: Array<Config> = []
-
-  for (const item of userConfigs) {
-    const plugins = item.plugins ? await getPlugins(item.plugins) : undefined
-
-    results.push({
-      ...item,
-      plugins,
-    } as Config)
-  }
-
-  return results
+  return userConfigs.map((item) => ({ plugins: [], ...item }) as Config)
 }

package/src/utils/getPreset.ts

@@ -0,0 +1,78 @@
+import { composeTransformers } from '@kubb/ast'
+import type { Visitor } from '@kubb/ast/types'
+import type { CompatibilityPreset, Generator, Preset, Presets, Resolver } from '../types.ts'
+
+/**
+ * Returns a copy of `defaults` where each function in `userOverrides` is wrapped
+ * so a `null`/`undefined` return falls back to the original. Non-function values
+ * are assigned directly. All calls use the merged object as `this`.
+ */
+function withFallback<T extends object>(defaults: T, userOverrides: Partial<T>): T {
+  const merged = { ...defaults } as T
+
+  for (const key of Object.keys(userOverrides) as Array<keyof T>) {
+    const userVal = userOverrides[key]
+    const defaultVal = defaults[key]
+
+    if (typeof userVal === 'function' && typeof defaultVal === 'function') {
+      ;(merged as any)[key] = (...args: any[]) => (userVal as Function).apply(merged, args) ?? (defaultVal as Function).apply(merged, args)
+    } else if (userVal !== undefined) {
+      merged[key] = userVal as T[typeof key]
+    }
+  }
+
+  return merged
+}
+
+type GetPresetParams<TResolver extends Resolver> = {
+  preset: CompatibilityPreset
+  presets: Presets<TResolver>
+  /**
+   * Optional single resolver whose methods override the preset resolver.
+   * When a method returns `null` or `undefined` the preset resolver's method is used instead.
+   */
+  resolver?: Partial<TResolver> & ThisType<TResolver>
+  /**
+   * User-supplied generators to append after the preset's generators.
+   */
+  generators?: Array<Generator<any>>
+  /**
+   * Optional single transformer visitor whose methods override the preset transformer.
+   * When a method returns `null` or `undefined` the preset transformer's method is used instead.
+   */
+  transformer?: Visitor
+}
+
+type GetPresetResult<TResolver extends Resolver> = {
+  resolver: TResolver
+  transformer: Visitor | undefined
+  generators: Array<Generator<any>>
+  preset: Preset<TResolver> | undefined
+}
+
+/**
+ * Resolves a named preset into a resolver, transformer, and generators.
+ *
+ * - Selects the preset resolver; wraps it with user overrides using null/undefined fallback.
+ * - Composes the preset's transformers into a single visitor; wraps it with the user transformer using null/undefined fallback.
+ * - Combines preset generators with user-supplied generators; falls back to the `default` preset's generators when neither provides any.
+ */
+export function getPreset<TResolver extends Resolver = Resolver>(params: GetPresetParams<TResolver>): GetPresetResult<TResolver> {
+  const { preset: presetName, presets, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = params
+  const preset = presets[presetName]
+
+  const presetResolver = preset?.resolver ?? presets['default']!.resolver
+  const resolver = userResolver ? withFallback(presetResolver, userResolver) : presetResolver
+
+  const presetTransformers = preset?.transformers ?? []
+  const presetTransformer = presetTransformers.length > 0 ? composeTransformers(...presetTransformers) : undefined
+  const transformer = presetTransformer && userTransformer ? withFallback(presetTransformer, userTransformer) : (userTransformer ?? presetTransformer)
+
+  const presetGenerators = preset?.generators ?? []
+  const defaultGenerators = presets['default']?.generators ?? []
+  const generators = (presetGenerators.length > 0 || userGenerators.length > 0 ? [...presetGenerators, ...userGenerators] : defaultGenerators) as Array<
+    Generator<any>
+  >
+
+  return { resolver, transformer, generators, preset }
+}

package/src/utils/isInputPath.ts

@@ -0,0 +1,8 @@
+import type { InputPath, UserConfig } from '../types'
+
+/**
+ * Type guard to check if a given config has an `input.path`.
+ */
+export function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> {
+  return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
+}

package/src/utils/linters.ts

@@ -3,6 +3,12 @@ import type { linters } from '../constants.ts'
 
 type Linter = keyof typeof linters
 
+/**
+ * Returns `true` when the given linter is installed and callable.
+ *
+ * Availability is detected by running `<linter> --version` and checking
+ * that the process exits without error.
+ */
 async function isLinterAvailable(linter: Linter): Promise<boolean> {
   try {
     await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
@@ -12,8 +18,22 @@ async function isLinterAvailable(linter: Linter): Promise<boolean> {
   }
 }
 
-export async function detectLinter(): Promise<Linter | undefined> {
-  const linterNames: Linter[] = ['biome', 'oxlint', 'eslint']
+/**
+ * Detects the first available linter on the current system.
+ *
+ * - Checks in preference order: `biome`, `oxlint`, `eslint`.
+ * - Returns `null` when none are found.
+ *
+ * @example
+ * ```ts
+ * const linter = await detectLinter()
+ * if (linter) {
+ *   console.log(`Using ${linter} for linting`)
+ * }
+ * ```
+ */
+export async function detectLinter(): Promise<Linter | null> {
+  const linterNames = new Set(['biome', 'oxlint', 'eslint'] as const)
 
   for (const linter of linterNames) {
     if (await isLinterAvailable(linter)) {
@@ -21,5 +41,5 @@ export async function detectLinter(): Promise<Linter | undefined> {
     }
   }
 
-  return undefined
+  return null
 }

package/src/utils/packageJSON.ts

@@ -0,0 +1,76 @@
+import { readSync } from '@internals/utils'
+import * as pkg from 'empathic/package'
+import { coerce, satisfies } from 'semver'
+
+type PackageJSON = {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+type DependencyName = string
+type DependencyVersion = string
+
+function getPackageJSONSync(cwd?: string): PackageJSON | null {
+  const pkgPath = pkg.up({ cwd })
+  if (!pkgPath) {
+    return null
+  }
+
+  return JSON.parse(readSync(pkgPath)) as PackageJSON
+}
+
+function match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | null {
+  const dependencies = {
+    ...(packageJSON.dependencies || {}),
+    ...(packageJSON.devDependencies || {}),
+  }
+
+  if (typeof dependency === 'string' && dependencies[dependency]) {
+    return dependencies[dependency]
+  }
+
+  const matched = Object.keys(dependencies).find((dep) => dep.match(dependency))
+
+  return matched ? (dependencies[matched] ?? null) : null
+}
+
+function getVersionSync(dependency: DependencyName | RegExp, cwd?: string): DependencyVersion | null {
+  const packageJSON = getPackageJSONSync(cwd)
+
+  return packageJSON ? match(packageJSON, dependency) : null
+}
+
+/**
+ * Returns `true` when the nearest `package.json` declares a dependency that
+ * satisfies the given semver range.
+ *
+ * - Searches both `dependencies` and `devDependencies`.
+ * - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
+ * - Uses `semver.satisfies` for range comparison; returns `false` when the
+ *   version string cannot be coerced into a valid semver.
+ *
+ * @example
+ * ```ts
+ * satisfiesDependency('react', '>=18')          // true when react@18.x is installed
+ * satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
+ * ```
+ */
+export function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean {
+  const packageVersion = getVersionSync(dependency, cwd)
+
+  if (!packageVersion) {
+    return false
+  }
+
+  if (packageVersion === version) {
+    return true
+  }
+
+  const semVer = coerce(packageVersion)
+
+  if (!semVer) {
+    return false
+  }
+
+  return satisfies(semVer, version)
+}

package/dist/chunk--u3MIqq1.js

@@ -1,8 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-//#endregion
-export { __name as t };