@budsbox/lib-es 2.2.0 → 3.0.0

package/dist/string.js

@@ -1,27 +1,44 @@
-import { isNil, isNotNil, isString } from './guards.js';
+/* eslint-disable jsdoc/informative-docs */
+import { assertArray, assertBoolean, assertNotNil, assertObject, assertOptionalProp, assertProp, assertSome, assertString, isBoolean, isNil, isNotNil, isNumber, isObject, isPropKey, isString, isUndef, somePredicate, } from '#guards';
+import { joinWithConjunction as _joinWithConjunction, formatAccessString, } from '#guards/format';
 /**
  * Parses a package name string to extract its scope and name.
  *
  * @param packageName - The full name of the package, potentially including a scope.
  * @param clean - A flag indicating whether to return a cleaned version (i.e., without a leading `@` and trailing `/`) of the scope. Defaults to false.
  * @returns An object containing the parsed scope and name of the package. The scope will be `null` if no scope is present.
+ * @category Package Name
  */
 export function parsePackageName(packageName, clean = false) {
+    assertString(packageName, 'packageName');
+    assertBoolean(clean, 'clean');
     const [scope, cleanScope] = /^@([^/]+)\//.exec(packageName) ?? [null, null];
     return {
         scope: clean ? cleanScope : scope,
         name: packageName.replace(scope ?? '', ''),
     };
 }
+function normalizePackageName(ident, clean) {
+    assertSome(ident, 'ident', isString, isObject);
+    if (isObject(ident)) {
+        assertProp(ident, 'name', isString);
+        assertOptionalProp(ident, 'scope', somePredicate(isString, isNil));
+        return {
+            ...ident,
+            scope: ident.scope ?? null,
+        };
+    }
+    return parsePackageName(ident, clean);
+}
 export function serializePackageName(parsedPackageName, allowNil = false) {
-    if (!allowNil && isNil(parsedPackageName)) {
-        throw new TypeError('Expected a non-nil value');
+    if (!allowNil) {
+        assertNotNil(parsedPackageName, 'parsedPackageName');
     }
-    const { scope, name } = parsedPackageName ?? { scope: null, name: '' };
+    const { scope, name } = normalizePackageName(parsedPackageName ?? { scope: null, name: '' });
     return joinPath(scope?.replace(/^@?/, '@'), name);
 }
 export function resolvePackageName(ident, { baseScope, parsed = false, } = {}) {
-    const { scope, name } = isString(ident) ? parsePackageName(ident) : ident;
+    const { scope, name } = normalizePackageName(ident);
     const parsedIdent = {
         scope: scope ?? baseScope ?? null,
         name,
@@ -40,15 +57,32 @@ export function resolvePackageName(ident, { baseScope, parsed = false, } = {}) {
  * @param options.nameDelimiter - The delimiter used to separate parents name from the base name of the package. Defaults to `'_'`.
  * @param options.excludePathChunks - Array of path chunks to be excluded when constructing the path. Defaults to `['packages']`.
  * @returns The formatted package name as a string.
+ * @category Package Name
  */
-export function formatPackageName(base, { root = null, parent = root, relCwd = '', pathDelimiter = '-', nameDelimiter = '_', excludePathChunks = ['packages'], } = {}) {
+export function formatPackageName(base, options = {}) {
+    assertString(base, 'base');
+    assertObject(options, 'options');
+    ['root', 'parent'].forEach((key) => {
+        assertOptionalProp(options, key, somePredicate(isString, isNil), 'options');
+    });
+    ['relCwd', 'pathDelimiter', 'nameDelimiter'].forEach((key) => {
+        assertOptionalProp(options, key, somePredicate(isString, isUndef), 'options');
+    });
+    const { root = null, parent = root, relCwd = '', pathDelimiter = '-', nameDelimiter = '_', excludePathChunks = ['packages'], } = options;
+    assertArray(excludePathChunks, isString, 'excludePathChunks');
+    [
+        ['relCwd', relCwd],
+        ['pathDelimiter', pathDelimiter],
+        ['nameDelimiter', nameDelimiter],
+    ].forEach(([name, value]) => void assertString(value, name));
+    assertArray(excludePathChunks, isString, 'options.excludePathChunks');
     const topLevel = parent === root;
     const exclude = new Set(excludePathChunks);
     const pathChunks = splitPath(relCwd).filter((chunk) => !exclude.has(chunk));
     if (pathChunks.at(-1) === base) {
         pathChunks.pop();
     }
-    const { scope, name: parentName } = parsePackageName(parent ?? '');
+    const { scope, name: parentName } = normalizePackageName(parent ?? '');
     return serializePackageName({
         scope,
         name: [
@@ -63,6 +97,7 @@ export function formatPackageName(base, { root = null, parent = root, relCwd = '
  * @param value - The value to be converted to its string representation. Can be of any type.
  * @returns A string representation of the input value.
  * If the value cannot be serialized using JSON.stringify, it falls back to using String conversion.
+ * @deprecated Use `formatDebugValue` from `@budsbox/lib-es/guards` instead.
  */
 export function debugString(value) {
     try {
@@ -80,6 +115,7 @@ export function debugString(value) {
  * @returns The processed string with trimmed and normalized whitespace.
  */
 export function clampWS(str) {
+    assertString(str, 'str');
     return str.trim().replace(/\s+/g, ' ');
 }
 /**
@@ -90,8 +126,10 @@ export function clampWS(str) {
  * @param parts - An array of path parts to join. Each part can be a string, number, boolean, null, or undefined.
  * Non-string values will be serialized, and null/undefined values are ignored.
  * @returns The combined path as a single string, with proper slash formatting.
+ * @category Paths
  */
 export function joinPath(...parts) {
+    assertArray(parts, somePredicate(isString, isNumber, isBoolean, isNil), 'parts');
     return parts
         .filter(isNotNil)
         .reduce((acc, part) => acc.length === 0 ?
@@ -106,20 +144,38 @@ export function joinPath(...parts) {
  * @param keepEmptyChunks - A boolean indicating whether empty strings (resulting from consecutive delimiters)
  * should be preserved in the output array. Defaults to `false`.
  * @returns An array of strings representing the components of the path.
+ * @category Paths
  */
 export function splitPath(path, keepEmptyChunks = false) {
-    const splitted = path.split(/\/+/);
+    assertString(path, 'path');
+    assertBoolean(keepEmptyChunks, 'keepEmptyChunks');
+    const splitted = path.split(keepEmptyChunks ? '/' : /\/+/);
     return keepEmptyChunks ? splitted : (splitted.filter((chunk) => chunk.length > 0));
 }
 export function camelCase(name) {
-    return clampWS(name).replace(/[-_\s]+([^-_\s])/g, (_, suffix) => suffix.toUpperCase());
+    assertString(name, 'name');
+    return clampWS(name)
+        .replace(/[-_\s]+([^-_\s])/g, (_, suffix) => suffix.toUpperCase())
+        .replace(/^./, (char) => char.toLowerCase())
+        .replace(/[-_\s]+/g, '');
 }
 export function pascalCase(name) {
-    return camelCase(name).replace(/^./, (c) => c.toUpperCase());
+    return camelCase(name).replace(/^./, (char) => char.toUpperCase());
 }
 export function delimCase(name, delimiter = '-') {
-    return clampWS(name)
-        .replace(/(.)([A-Z])/g, `$1${delimiter}$2`)
+    assertString(name, 'name');
+    assertString(delimiter, 'delimiter');
+    const clamped = clampWS(name);
+    const chars = [];
+    for (let i = 0; i < clamped.length; i++) {
+        const char = clamped[i];
+        if (/^[A-Z]$/.test(char) && i !== 0) {
+            chars.push(delimiter);
+        }
+        chars.push(char);
+    }
+    return chars
+        .join('')
         .replace(/[-_\s]+/g, delimiter)
         .toLowerCase();
 }
@@ -129,4 +185,34 @@ export function kebabCase(name) {
 export function snakeCase(name) {
     return delimCase(name, '_');
 }
+/**
+ * Joins an array of strings into a single formatted string using the specified conjunction.
+ *
+ * @param items - An array of strings to be joined. If the array is empty, an empty string is returned.
+ * @param conjunction - A word or phrase (`and` or `or`) to be used as the conjunction between the last two items.
+ * @returns A formatted string where the items are separated by commas and the conjunction is added before the final item.
+ */
+export function joinWithConjunction(items, conjunction) {
+    assertArray(items, isString, 'items');
+    assertString(conjunction, 'conjunction');
+    return _joinWithConjunction(items, conjunction);
+}
+/**
+ * Constructs a dot-notation or bracket-notation string representation
+ * for accessing nested properties of an object based on the provided keys.
+ *
+ * @internal
+ * @param sourceName - The base name of the object or source from which properties are being accessed.
+ * @param keys - A variadic list of property keys representing the nested path.
+ * Each key will be used to generate the accessor string.
+ * @returns A string representing the accessor path in dot-notation for valid identifiers
+ * or bracket-notation for non-identifier keys.
+ * @remarks This function considers "valid" for identifiers only alphanumeric characters,
+ * underscores, and dollar signs.
+ */
+export function formatPropAccessor(sourceName, ...keys) {
+    assertString(sourceName, 'sourceName');
+    assertArray(keys, isPropKey, 'keys');
+    return formatAccessString(sourceName, ...keys);
+}
 //# sourceMappingURL=string.js.map

package/dist/types.d.ts

@@ -1,94 +1,40 @@
+import type { FValue, Maybe, Predicate, TypePredicate, Undef, ValuePredicate } from '@budsbox/lib-types';
 /**
- * The `FValue` type represents a union type that can be either a value of type `T` or a function
- * that takes a parameter of type `A` and returns a value of type `T`.
+ * Resolves to a type based on a predicate or type guard and the selected branch.
  *
- * @typeParam A - The type of the parameter for the function.
- * @typeParam T - The type of the value or the return type of the function.
+ * @typeParam TValue - The value type under test.
+ * @typeParam TTestFn - A `Predicate` or `TypePredicate` applied to `TValue`.
+ * @typeParam TBranch - If `true`, keep the narrowed part; if `false`, exclude it.
  */
-export type FValue<A, T> = T | ((value: A) => T);
+export type TestFnResult<TValue, TTestFn extends Predicate, TBranch extends boolean> = TTestFn extends TypePredicate<unknown, infer TNarrowed> ? TBranch extends true ? Extract<TValue, TNarrowed> : Exclude<TValue, TNarrowed> : TTestFn extends ValuePredicate<infer TOriginal> ? TOriginal : never;
 /**
- * A type representing a type guard function that determines if a given value of type `T`
- * conforms to a more specific type `V`, where `V` is a subtype of `T`.
+ * Maps the "true" branch of a test to a value or function result type.
  *
- * This function should be implemented to return `true` if the provided value matches
- * the more specific type `V`, and `false` otherwise. By using a type guard, TypeScript can
- * narrow the type of variable within the scope of a condition.
- *
- * @typeParam T - The broader type against which the value will be checked.
- * @typeParam V - The narrowed type that `T` is tested against. V must extend T.
- * @param value - The value of type `T` to be tested against the narrowed type `V`.
- * @returns A boolean value indicating whether the input value is of type `V`.
- */
-export type TypeGuard<T, V extends T> = (value: T) => value is V;
-/**
- * A type definition for a function that performs a boolean test on a given value.
- *
- * This generic type accepts a parameter `T`, which represents the type of the input
- * that the function will evaluate. The function returns a boolean indicating the
- * result of the test.
- *
- * @typeParam T - The type of the input value that the function will evaluate.
- * @param value - The input value to test.
- * @returns A boolean indicating the result of the test.
- */
-export type Predicate<T> = (value: T) => boolean;
-/**
- * Represents a type that can either be a `TypeGuard` or a `TestFn`.
- *
- * `TestParam` is a utility type that allows defining parameters used in testing or
- * type-checking procedures. It accommodates both type guard functions and test
- * functions for more comprehensive type handling.
- *
- * @typeParam TValue - The base type to be tested or narrowed. Defaults to `any`.
- * @typeParam TNarrowed - A subtype of `ValueType` that represents the narrowed type.
- *                          Defaults to `ValueType`.
- */
-export type TestFn<TValue = any, TNarrowed extends TValue = TValue> = Predicate<TValue> | TypeGuard<TValue, TNarrowed>;
-/**
- * Represents a type that evaluates to a specific result based on the provided test conditions.
- *
- * @typeParam TValue - The type of value being tested.
- * @typeParam TTestFn - The type of test being applied. This could be a type guard or a test function.
- * @typeParam TBranch - A boolean that determines the branch type. If true, the resulting type will
- * focus on the narrowed type; otherwise, it excludes the narrowed type.
- *
- * The type resolves based on the following rules:
- * 1. If `TestType` is a type guard:
- *    - If `BranchType` is `true`, the resulting type includes only the portion of `ValueType` that
- *      conforms to the narrowed type.
- *    - If `BranchType` is `false`, the resulting type excludes the portion of `ValueType` that
- *      conforms to the narrowed type.
- * 2. If `TestType` is a test function, the resulting type will be the original type inferred by
- *    the test function.
- * 3. If neither condition applies, the resulting type will be `never`.
- */
-export type TestFnResult<TValue, TTestFn extends TestFn, TBranch extends boolean> = TTestFn extends TypeGuard<unknown, infer TNarrowed> ? TBranch extends true ? Extract<TValue, TNarrowed> : Exclude<TValue, TNarrowed> : TTestFn extends Predicate<infer TOriginal> ? TOriginal : never;
-/**
- * A type definition that represents a resolved value when a certain test condition is true.
- *
- * @typeParam ValueType - Represents the type of the input value being tested.
- * @typeParam TestType - Extends the `TestParam` type and defines the parameters for the test condition.
- * @typeParam ReturnType - Specifies the type of the resulting value after the test condition is satisfied.
- *
- * This type combines the test result with a return type, capturing the transformed value
- * or operation result when the test evaluates to `true`.
+ * @typeParam TValue - The input value type being tested.
+ * @typeParam TTestFn - The test (predicate or type guard).
+ * @typeParam TResult - The resulting value type.
  */
-export type FValueTrue<TValue, TTestFn extends TestFn, TResult> = FValue<TestFnResult<TValue, TTestFn, true>, TResult>;
+export type FValueTrue<TValue, TTestFn extends Predicate, TResult> = FValue<TestFnResult<TValue, TTestFn, true>, TResult>;
 /**
- * Represents a type that maps a test result to a specific return type when the test evaluates to false.
- *
- * This type is a utility that processes the result of a test operation (`TestResultType`)
- * when the provided test condition evaluates as false, associating it with a specific return type (`ReturnType`).
+ * Maps the "false" branch of a test to a value or function result type.
  *
- * @typeParam ValueType - The type of the primary value being tested.
- * @typeParam TestType - A type extending `TestParam` representing the condition being tested.
- * @typeParam ReturnType - The type of the result or output when the test condition evaluates to false.
+ * @typeParam TValue - The input value type being tested.
+ * @typeParam TTestFn - The test (predicate or type guard).
+ * @typeParam TResult - The resulting value type.
  */
-export type FValueFalse<TValue, TTestFn extends TestFn, TResult> = FValue<TestFnResult<TValue, TTestFn, false>, TResult>;
+export type FValueFalse<TValue, TTestFn extends Predicate, TResult> = FValue<TestFnResult<TValue, TTestFn, false>, TResult>;
 /**
  * Represents a parsed Node.js (npm) package name split into its optional scope and the bare name.
+ *
+ * @inline
+ * @category Package Name
  */
 export interface ParsedPackageName {
+    /**
+     * The unscoped package name (the segment after the scope or the whole name if unscoped).
+     * For "@scope/pkg", this is "pkg"; for "pkg", this is "pkg".
+     */
+    name: string;
     /**
      * The scope part of the package name (organization/user), with or without the leading "@" and trail "/".
      * If the package is unscoped, this will be `null` or `undefined`.
@@ -96,10 +42,49 @@ export interface ParsedPackageName {
      * @example "scope" for "@scope/pkg", or "undefined" for "pkg"
      */
     scope?: string | null;
+}
+/**
+ * Options for formatting the package name.
+ *
+ * @inline
+ * @category Package Name
+ */
+export interface PackageNameFormatOptions {
     /**
-     * The unscoped package name (the segment after the scope or the whole name if unscoped).
-     * For "@scope/pkg", this is "pkg"; for "pkg", this is "pkg".
+     * Array of path chunks to be excluded when constructing the path.
+     *
+     * @defaultValue `['packages']`
      */
-    name: string;
+    excludePathChunks?: Undef<readonly string[]>;
+    /**
+     * The delimiter used to separate parents name from the base name of the package.
+     *
+     * @defaultValue `'_'`
+     */
+    nameDelimiter?: Undef<string>;
+    /**
+     * The parent package name.
+     *
+     * @defaultValue `options.root`
+     */
+    parent?: Maybe<string>;
+    /**
+     * The delimiter used to separate path chunks.
+     *
+     * @defaultValue `'-'`
+     */
+    pathDelimiter?: Undef<string>;
+    /**
+     * The path to the package, relative to its parent.
+     *
+     * @defaultValue `''`
+     */
+    relCwd?: Undef<string>;
+    /**
+     * The root identifier for the package.
+     *
+     * @defaultValue `null`
+     */
+    root?: Maybe<string>;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,117 +1,86 @@
 {
   "name": "@budsbox/lib-es",
-  "version": "2.2.0",
-  "homepage": "https://gitlab.com/budsbox/fe/seed",
+  "version": "3.0.0",
+  "homepage": "https://github.com/budsbox/seed",
   "bugs": {
-    "url": "https://gitlab.com/budsbox/fe/seed/-/issues"
+    "url": "https://github.com/budsbox/seed/issues"
   },
-  "repository": "gitlab:budsbox/fe/seed",
+  "repository": "git@github.com:budsbox/seed.git",
   "license": "MIT",
   "author": "Konstantin Kutsyllo <trikadin@pm.me>",
   "type": "module",
   "imports": {
     "#package.json": "./package.json",
+    "#types": "./dist/types.d.ts",
     "#array": {
-      "import": {
-        "default": "./dist/array.js",
-        "types": "./dist/array.d.ts"
-      },
-      "require": {
-        "default": "./dist/array.js",
-        "types": "./dist/array.d.ts"
-      }
+      "types": "./dist/array.d.ts",
+      "default": "./dist/array.js"
     },
     "#object": {
-      "import": {
-        "default": "./dist/object.js",
-        "types": "./dist/object.d.ts"
-      },
-      "require": {
-        "default": "./dist/object.js",
-        "types": "./dist/object.d.ts"
-      }
+      "types": "./dist/object.d.ts",
+      "default": "./dist/object.js"
     },
     "#string": {
-      "import": {
-        "default": "./dist/string.js",
-        "types": "./dist/string.d.ts"
-      },
-      "require": {
-        "default": "./dist/string.js",
-        "types": "./dist/string.d.ts"
-      }
+      "types": "./dist/string.d.ts",
+      "default": "./dist/string.js"
     },
     "#guards": {
-      "import": {
-        "default": "./dist/guards.js",
-        "types": "./dist/guards.d.ts"
-      },
-      "require": {
-        "default": "./dist/guards.js",
-        "types": "./dist/guards.d.ts"
-      }
+      "types": "./dist/guards/index.d.ts",
+      "default": "./dist/guards/index.js"
+    },
+    "#guards/*": {
+      "types": "./dist/guards/*.d.ts",
+      "default": "./dist/guards/*.js"
     },
     "#logical": {
-      "import": {
-        "default": "./dist/logical.js",
-        "types": "./dist/logical.d.ts"
-      },
-      "require": {
-        "default": "./dist/logical.js",
-        "types": "./dist/logical.d.ts"
-      }
+      "types": "./dist/logical.d.ts",
+      "default": "./dist/logical.js"
+    },
+    "#function": {
+      "types": "./dist/function.d.ts",
+      "default": "./dist/function.js"
+    },
+    "#set": {
+      "types": "./dist/set.d.ts",
+      "default": "./dist/set.js"
+    },
+    "#map": {
+      "types": "./dist/map.d.ts",
+      "default": "./dist/map.js"
     }
   },
   "exports": {
     "./array": {
-      "import": {
-        "default": "./dist/array.js",
-        "types": "./dist/array.d.ts"
-      },
-      "require": {
-        "default": "./dist/array.js",
-        "types": "./dist/array.d.ts"
-      }
+      "types": "./dist/array.d.ts",
+      "default": "./dist/array.js"
     },
     "./object": {
-      "import": {
-        "default": "./dist/object.js",
-        "types": "./dist/object.d.ts"
-      },
-      "require": {
-        "default": "./dist/object.js",
-        "types": "./dist/object.d.ts"
-      }
+      "types": "./dist/object.d.ts",
+      "default": "./dist/object.js"
     },
     "./string": {
-      "import": {
-        "default": "./dist/string.js",
-        "types": "./dist/string.d.ts"
-      },
-      "require": {
-        "default": "./dist/string.js",
-        "types": "./dist/string.d.ts"
-      }
+      "types": "./dist/string.d.ts",
+      "default": "./dist/string.js"
     },
     "./guards": {
-      "import": {
-        "default": "./dist/guards.js",
-        "types": "./dist/guards.d.ts"
-      },
-      "require": {
-        "default": "./dist/guards.js",
-        "types": "./dist/guards.d.ts"
-      }
+      "types": "./dist/guards/index.d.ts",
+      "default": "./dist/guards/index.js"
     },
     "./logical": {
-      "import": {
-        "default": "./dist/logical.js",
-        "types": "./dist/logical.d.ts"
-      },
-      "require": {
-        "default": "./dist/logical.js",
-        "types": "./dist/logical.d.ts"
-      }
+      "types": "./dist/logical.d.ts",
+      "default": "./dist/logical.js"
+    },
+    "./function": {
+      "types": "./dist/function.d.ts",
+      "default": "./dist/function.js"
+    },
+    "./set": {
+      "types": "./dist/set.d.ts",
+      "default": "./dist/set.js"
+    },
+    "./map": {
+      "types": "./dist/map.d.ts",
+      "default": "./dist/map.js"
     },
     "./package.json": "./package.json"
   },
@@ -120,34 +89,38 @@
     "dist/**/*.js"
   ],
   "scripts": {
+    "build": "run p:ts:build",
     "name": "echo $npm_package_name",
-    "prepack": "yarn p:ts:prepack"
+    "prepack": "yarn p:ts:prepack",
+    "test": "run p:vitest",
+    "watch": "yarn p:ts:watch"
   },
   "dependencies": {
-    "@budsbox/lib-types": "^1.1.0",
-    "@types/node": "^22.15.2",
+    "@budsbox/lib-types": "^1.4.0",
+    "@types/node": "^22.19.1",
     "tslib": "^2.8.1",
-    "type-fest": "^4.32.0"
+    "type-fest": "^5.3.1"
   },
   "devDependencies": {
-    "@budsbox/eslint": "^1.2.0",
-    "@budsbox/eslint_presets-lib": "^1.0.3",
-    "@budsbox/eslint_presets-tools": "^1.0.3",
-    "@budsbox/tsconfigs": "^4.3.0",
-    "@eslint/js": "^9.26.0",
+    "@budsbox/eslint": "^1.3.0",
+    "@budsbox/eslint_presets-lib": "^1.0.5",
+    "@budsbox/eslint_presets-tools": "^1.0.5",
+    "@budsbox/tsconfigs": "^4.4.0",
+    "@eslint/js": "^9.39.1",
     "@types/eslint": "^9.6.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "eslint": "^9.26.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-import-resolver-typescript": "^4.3.4",
-    "eslint-plugin-import-x": "^4.11.1",
-    "eslint-plugin-jsdoc": "^50.6.17",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-jsdoc": "^61.5.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.20",
-    "globals": "^16.1.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.32.1"
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1",
+    "vitest": "^4.1.0"
   },
   "packageManager": "yarn@4.9.2"
 }

package/dist/class-name.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=class-name.d.ts.map

package/dist/class-name.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=class-name.js.map