@ls-stack/utils 3.65.0 → 3.66.0

package/dist/tsResult.d.ts

@@ -1,114 +0,0 @@
-type Ok<T> = {
-    ok: true;
-    error: false;
-    value: T;
-} & AnyResultMethods;
-type AnyResultMethods = Record<ResultMethodsKeys, never>;
-/** @deprecated Use `t-result` library instead. */
-type ResultValidErrors = Error | Record<string, unknown> | unknown[] | readonly unknown[] | true;
-type Err<E extends ResultValidErrors> = {
-    ok: false;
-    error: E;
-    /** @deprecated Use `t-result` library instead. */
-    errorResult: () => Err<E>;
-} & AnyResultMethods;
-type ResultMethods<T, E extends ResultValidErrors> = {
-    /** @deprecated Use `t-result` library instead. */
-    unwrapOrNull: () => T | null;
-    /** @deprecated Use `t-result` library instead. */
-    unwrapOr: <R extends T>(defaultValue: R) => T | R;
-    /** @deprecated Use `t-result` library instead. */
-    unwrap: () => T;
-    /** @deprecated Use `t-result` library instead. */
-    mapOk: <NewValue>(mapFn: (value: T) => NewValue) => Result<NewValue, E>;
-    /** @deprecated Use `t-result` library instead. */
-    mapErr: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Result<T, NewError>;
-    /** @deprecated Use `t-result` library instead. */
-    mapOkAndErr: <NewValue, NewError extends ResultValidErrors>(mapFns: {
-        ok: (value: T) => NewValue;
-        err: (error: E) => NewError;
-    }) => Result<NewValue, NewError>;
-    /** @deprecated Use `t-result` library instead. */
-    ifOk: (fn: (value: T) => void) => Result<T, E>;
-    /** @deprecated Use `t-result` library instead. */
-    ifErr: (fn: (error: E) => void) => Result<T, E>;
-};
-type ResultMethodsKeys = keyof ResultMethods<any, any>;
-/** @deprecated Use `t-result` library instead. */
-declare function ok(): Ok<void>;
-/**
- * @deprecated Use `t-result` library instead.
- * @param value
- */
-declare function ok<T>(value: T): Ok<T>;
-/**
- * @deprecated Use `t-result` library instead.
- * @param error
- */
-declare function err<E extends ResultValidErrors>(error: E): Err<E>;
-declare function unknownToResultError(error: unknown): Err<Error>;
-/**
- * Unwraps a promise result
- *
- * @param result
- */
-declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
-declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
-    err: <NewError extends ResultValidErrors>(mapFn: (error: E) => NewError) => Promise<Result<T, NewError>>;
-    ok: <NewValue>(mapFn: (value: T) => NewValue) => Promise<Result<NewValue, E>>;
-    okAndErr: <NewValue, NewError extends ResultValidErrors>({ ok: mapFn, err: mapErrFn, }: {
-        ok: (value: T) => NewValue;
-        err: (error: E) => NewError;
-    }) => Promise<Result<NewValue, NewError>>;
-};
-/** @deprecated Use `t-result` library instead. */
-type Result<T, E extends ResultValidErrors = Error> = (Omit<Ok<T>, ResultMethodsKeys> | Omit<Err<E>, ResultMethodsKeys>) & ResultMethods<T, E>;
-/** @deprecated Use `t-result` library instead. */
-declare const Result: {
-    ok: typeof ok;
-    err: typeof err;
-    unknownToError: typeof unknownToResultError;
-    asyncUnwrap: typeof asyncUnwrap;
-    asyncMap: typeof asyncMap;
-    getOkErr: typeof getOkErr;
-};
-/**
- * @deprecated Use `t-result` library instead.
- * @param fn
- * @param errorNormalizer
- */
-declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T extends Promise<any> ? never : T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
-/**
- * @deprecated Use `t-result` library instead.
- * @param fn
- * @param errorNormalizer
- */
-declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
-/**
- * @deprecated Use `t-result` library instead.
- * @param fn
- * @param errorNormalizer
- */
-declare function resultify<T, E extends ResultValidErrors = Error>(fn: Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<T, E>>;
-/**
- * @deprecated Use `t-result` library instead.
- * @param error
- */
-declare function unknownToError(error: unknown): Error;
-/** @deprecated Use `t-result` library instead. */
-type TypedResult<T, E extends ResultValidErrors = Error> = {
-    /** @deprecated Use `t-result` library instead. */
-    ok: (value: T) => Ok<T>;
-    /** @deprecated Use `t-result` library instead. */
-    err: (error: E) => Err<E>;
-    /** @deprecated Use `t-result` library instead. */
-    _type: Result<T, E>;
-};
-/** @deprecated Use `t-result` library instead. */
-type GetTypedResult<R extends Result<any, any>> = TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
-declare function getOkErr<F extends (...args: any[]) => Promise<Result<any, any>>>(): TypedResult<Awaited<ReturnType<F>> extends Result<infer T, any> ? T : never, Awaited<ReturnType<F>> extends Result<any, infer E> ? E : never>;
-declare function getOkErr<F extends (...args: any[]) => Result<any, any>>(): TypedResult<ReturnType<F> extends Result<infer T, any> ? T : never, ReturnType<F> extends Result<any, infer E> ? E : never>;
-declare function getOkErr<R extends Result<any, any>>(): TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
-declare function getOkErr<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
-
-export { type GetTypedResult, Result, type ResultValidErrors, type TypedResult, err, ok, resultify, unknownToError };

package/dist/tsResult.js

@@ -1,180 +0,0 @@
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
-import {
-  isFunction,
-  isObject,
-  isPromise
-} from "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
-
-// src/tsResult.ts
-function okUnwrapOr() {
-  return this.value;
-}
-function okMap(mapFn) {
-  return this.ok ? ok(mapFn(this.value)) : this;
-}
-function errMap(mapFn) {
-  return this.ok ? this : err(mapFn(this.error));
-}
-function mapOkAndErr({
-  ok: mapFn,
-  err: mapErrFn
-}) {
-  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
-}
-function returnResult() {
-  return this;
-}
-function okOnOk(fn) {
-  if (this.ok) {
-    fn(this.value);
-  }
-  return this;
-}
-function errOnErr(fn) {
-  if (!this.ok) {
-    fn(this.error);
-  }
-  return this;
-}
-function ok(value = void 0) {
-  const methods = {
-    unwrapOrNull: okUnwrapOr,
-    unwrapOr: okUnwrapOr,
-    unwrap: okUnwrapOr,
-    mapOk: okMap,
-    mapErr: returnResult,
-    mapOkAndErr,
-    ifOk: okOnOk,
-    ifErr: returnResult
-  };
-  return {
-    ok: true,
-    error: false,
-    value,
-    ...methods
-  };
-}
-function err(error) {
-  const methods = {
-    unwrapOrNull: () => null,
-    unwrapOr: (defaultValue) => defaultValue,
-    unwrap: () => {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw unknownToError(error);
-    },
-    mapOk: returnResult,
-    mapErr: errMap,
-    mapOkAndErr,
-    ifOk: returnResult,
-    ifErr: errOnErr
-  };
-  return {
-    ok: false,
-    error,
-    errorResult() {
-      return err(error);
-    },
-    ...methods
-  };
-}
-function unknownToResultError(error) {
-  return err(unknownToError(error));
-}
-async function asyncUnwrap(result) {
-  const unwrapped = await result;
-  if (unwrapped.ok) {
-    return unwrapped.value;
-  }
-  if (unwrapped.error instanceof Error) {
-    throw unwrapped.error;
-  }
-  throw unknownToError(unwrapped.error);
-}
-function asyncMap(resultPromise) {
-  return {
-    err: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(result.value) : err(mapFn(result.error));
-    },
-    ok: async (mapFn) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(result.error);
-    },
-    okAndErr: async ({
-      ok: mapFn,
-      err: mapErrFn
-    }) => {
-      const result = await resultPromise;
-      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
-    }
-  };
-}
-var Result = {
-  ok,
-  err,
-  unknownToError: unknownToResultError,
-  asyncUnwrap,
-  asyncMap,
-  getOkErr
-};
-function resultify(fn, errorNormalizer) {
-  if (!isFunction(fn)) {
-    return fn.then((value) => ok(value)).catch(
-      (error) => err(
-        errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-      )
-    );
-  }
-  try {
-    const result = fn();
-    if (isPromise(result)) {
-      return result.then((value) => ok(value)).catch(
-        (error) => err(
-          errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-        )
-      );
-    }
-    return ok(result);
-  } catch (error) {
-    return err(
-      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
-    );
-  }
-}
-function unknownToError(error) {
-  if (error instanceof Error) return error;
-  if (typeof error === "string") {
-    return new Error(error);
-  }
-  if (isObject(error)) {
-    return new Error(
-      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
-      { cause: error }
-    );
-  }
-  return new Error(safeJsonStringify(error) ?? "unknown", {
-    cause: error
-  });
-}
-var typedResult = {
-  ok,
-  err,
-  get _type() {
-    throw new Error("usage as value is not allowed");
-  }
-};
-function getOkErr() {
-  return typedResult;
-}
-export {
-  Result,
-  err,
-  ok,
-  resultify,
-  unknownToError
-};

package/dist/typeGuards.cjs

@@ -1,70 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typeGuards.ts
-var typeGuards_exports = {};
-__export(typeGuards_exports, {
-  arrayHasAtLeastXItems: () => arrayHasAtLeastXItems,
-  isFunction: () => isFunction,
-  isNonEmptyArray: () => isNonEmptyArray,
-  isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
-  isPromise: () => isPromise,
-  isTruthy: () => isTruthy
-});
-module.exports = __toCommonJS(typeGuards_exports);
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPromise(value) {
-  return isObject(value) && "then" in value && isFunction(value.then);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object) return true;
-  const objectCtorString = Object.prototype.constructor.toString();
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-function isNonEmptyArray(value) {
-  return value.length > 0;
-}
-function arrayHasAtLeastXItems(array, minLength) {
-  return array.length >= minLength;
-}
-function isTruthy(value) {
-  return !!value;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  arrayHasAtLeastXItems,
-  isFunction,
-  isNonEmptyArray,
-  isObject,
-  isPlainObject,
-  isPromise,
-  isTruthy
-});

package/dist/typeGuards.d.ts

@@ -1,111 +0,0 @@
-/**
- * Type guard to check if a value is a plain object (not null, not an array).
- *
- * Returns true if the value is an object that is not null and not an array.
- * This is useful for distinguishing between objects and other types.
- *
- * @example
- *   ```typescript
- *   if (isObject(value)) {
- *     // TypeScript knows value is Record<string, unknown>
- *     console.log(value.someProperty);
- *   }
- *
- *   isObject({});           // true
- *   isObject({ a: 1 });     // true
- *   isObject(null);         // false
- *   isObject([]);           // false
- *   isObject('string');     // false
- *   ```;
- *
- * @param value - The value to check
- * @returns True if the value is a plain object, false otherwise
- */
-declare function isObject(value: unknown): value is Record<string, unknown>;
-/**
- * Type guard to check if a value is a function.
- *
- * Returns true if the value is a function of any kind (regular function, arrow
- * function, method, constructor, etc.).
- *
- * @example
- *   ```typescript
- *   if (isFunction(value)) {
- *     // TypeScript knows value is (...args: any[]) => any
- *     const result = value();
- *   }
- *
- *   isFunction(() => {});           // true
- *   isFunction(function() {});      // true
- *   isFunction(Math.max);           // true
- *   isFunction('string');           // false
- *   isFunction({});                 // false
- *   ```;
- *
- * @param value - The value to check
- * @returns True if the value is a function, false otherwise
- */
-declare function isFunction(value: unknown): value is (...args: any[]) => any;
-/**
- * Type guard to check if a value is a Promise or thenable object.
- *
- * Returns true if the value is an object with a `then` method that is a
- * function. This covers both native Promises and thenable objects that
- * implement the Promise interface.
- *
- * @example
- *   ```typescript
- *   if (isPromise(value)) {
- *     // TypeScript knows value is Promise<unknown>
- *     const result = await value;
- *   }
- *
- *   isPromise(Promise.resolve());           // true
- *   isPromise(new Promise(() => {}));       // true
- *   isPromise({ then: () => {} });          // true
- *   isPromise({ then: 'not a function' });  // false
- *   isPromise('string');                    // false
- *   ```;
- *
- * @param value - The value to check
- * @returns True if the value is a Promise or thenable, false otherwise
- */
-declare function isPromise(value: unknown): value is Promise<unknown>;
-/**
- * Type guard to check if a value is a plain object (created by Object literal
- * or Object constructor).
- *
- * Returns true if the value is a plain object - an object created by the Object
- * constructor or object literal syntax. This excludes instances of classes,
- * built-in objects like Date, RegExp, etc.
- *
- * @example
- *   ```typescript
- *   if (isPlainObject(value)) {
- *     // TypeScript knows value is Record<string, unknown>
- *     console.log(Object.keys(value));
- *   }
- *
- *   isPlainObject({});                    // true
- *   isPlainObject({ a: 1 });              // true
- *   isPlainObject(Object.create(null));   // true
- *   isPlainObject(new Date());            // false
- *   isPlainObject(/regex/);               // false
- *   isPlainObject(new MyClass());         // false
- *   isPlainObject([]);                    // false
- *   ```;
- *
- * @param value - The value to check
- * @returns True if the value is a plain object, false otherwise
- */
-declare function isPlainObject(value: any): value is Record<string, unknown>;
-type NonEmptyArray<T> = [T, ...T[]];
-declare function isNonEmptyArray<T>(value: T[] | readonly T[]): value is NonEmptyArray<T>;
-declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 1): array is [T, ...T[]];
-declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 2): array is [T, T, ...T[]];
-declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 3): array is [T, T, T, ...T[]];
-declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 4): array is [T, T, T, T, ...T[]];
-declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 5): array is [T, T, T, T, T, ...T[]];
-declare function isTruthy<T>(value: T): value is Exclude<T, null | undefined | false | 0 | '' | 0n>;
-
-export { type NonEmptyArray, arrayHasAtLeastXItems, isFunction, isNonEmptyArray, isObject, isPlainObject, isPromise, isTruthy };

package/dist/typeGuards.js

@@ -1,18 +0,0 @@
-import {
-  arrayHasAtLeastXItems,
-  isFunction,
-  isNonEmptyArray,
-  isObject,
-  isPlainObject,
-  isPromise,
-  isTruthy
-} from "./chunk-JF2MDHOJ.js";
-export {
-  arrayHasAtLeastXItems,
-  isFunction,
-  isNonEmptyArray,
-  isObject,
-  isPlainObject,
-  isPromise,
-  isTruthy
-};

package/dist/typeUtils.cjs

@@ -1,18 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typeUtils.ts
-var typeUtils_exports = {};
-module.exports = __toCommonJS(typeUtils_exports);

package/dist/typeUtils.d.cts

@@ -1,61 +0,0 @@
-type PartialRecord<K extends keyof any, T> = {
-    [P in K]?: T;
-};
-type NonPartial<T> = {
-    [K in keyof Required<T>]: T[K];
-};
-/**
- * @deprecated Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils`
- *   instead
- */
-type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
-    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
-}[keyof Obj];
-type IsAny<T> = unknown extends T ? [
-    keyof T
-] extends [never] ? false : true : false;
-type Prettify<T extends Record<string, unknown>> = {
-    [P in keyof T]: T[P];
-} & {};
-type DeepPrettify<T> = {
-    [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
-} & {};
-type DefaultSkipTransverseDeepReplace = Date | RegExp | ((...args: any[]) => any) | Error | Set<any> | Map<any, any> | WeakSet<any> | WeakMap<any, any>;
-type PathMatches<CurrentPath extends string, SkipPaths extends string> = true extends (SkipPaths extends any ? CurrentPath extends SkipPaths ? true : SkipPaths extends `${infer Prefix}[*]${infer Suffix}` ? CurrentPath extends `${Prefix}[${string}]${Suffix}` ? true : false : false : false) ? true : false;
-type BuildPath<BasePath extends string, Key extends PropertyKey> = BasePath extends '$' ? Key extends string | number ? `${Key}` : never : Key extends string | number ? `${BasePath}.${Key}` : never;
-type BuildArrayPath<BasePath extends string> = BasePath extends '$' ? '[*]' : `${BasePath}[*]`;
-type DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths extends string | undefined, SkipType, Path extends string = '$'> = SkipPaths extends string ? PathMatches<Path, SkipPaths> extends true ? T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
-    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
-} : T : T extends ReplaceType ? T extends SkipType ? T : NewType : T extends readonly (infer U)[] ? Array<DeepReplaceValueImpl<U, ReplaceType, NewType, SkipPaths, SkipType, BuildArrayPath<Path>>> : T extends SkipType ? T : T extends Record<string, any> ? {
-    [K in keyof T]: DeepReplaceValueImpl<T[K], ReplaceType, NewType, SkipPaths, SkipType, BuildPath<Path, K>>;
-} : T;
-/**
- * Replaces all values that extends `ReplaceType` with `NewType` in a deeply
- * nested object or array.
- *
- * @template T - The object or array to replace values in.
- * @template ReplaceType - The type to replace.
- * @template NewType - The new type to replace with.
- * @template SkipPaths - The paths to skip in transverse. e.g. 'a.b.c' |
- *   'array[*].b'
- * @template SkipTypes - The types to skip in transverse and replace.
- */
-type DeepReplaceValue<T, ReplaceType, NewType, SkipPaths extends string | undefined = undefined, SkipTypes = DefaultSkipTransverseDeepReplace> = DeepReplaceValueImpl<T, ReplaceType, NewType, SkipPaths, SkipTypes>;
-type KeysWithUndefinedValues<T extends Record<string, unknown>> = {
-    [K in keyof T]: undefined extends T[K] ? K : never;
-}[keyof T];
-/**
- * Marks all possible undefined values as partial at the root level of the
- * object.
- */
-type PartialPossiblyUndefinedValues<T extends Record<string, unknown>> = Prettify<Partial<Pick<T, KeysWithUndefinedValues<T>>> & Omit<T, KeysWithUndefinedValues<T>>>;
-type PickUndefinedKeys<T> = {
-    [K in keyof T]: undefined extends T[K] ? K : never;
-}[keyof T];
-type PickRequiredKeys<T> = {
-    [K in keyof T]: undefined extends T[K] ? never : K;
-}[keyof T];
-type MakeUndefinedKeysOptional<T> = Prettify<Partial<Pick<T, PickUndefinedKeys<T>>> & Pick<T, PickRequiredKeys<T>>>;
-type StringWithAutoComplete<T extends string> = T | (string & {});
-
-export type { DeepPrettify, DeepReplaceValue, DefaultSkipTransverseDeepReplace, IsAny, MakeUndefinedKeysOptional, NonPartial, ObjKeysWithValuesOfType, PartialPossiblyUndefinedValues, PartialRecord, Prettify, StringWithAutoComplete };

package/dist/typedStrings.cjs

@@ -1,90 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typedStrings.ts
-var typedStrings_exports = {};
-__export(typedStrings_exports, {
-  asNonEmptyStringOrNull: () => asNonEmptyStringOrNull,
-  asNonEmptyStringOrThrow: () => asNonEmptyStringOrThrow,
-  assertStringIsNonEmpty: () => assertStringIsNonEmpty,
-  isNonEmptyString: () => isNonEmptyString,
-  splitTypedString: () => splitTypedString,
-  splitTypedStringAt: () => splitTypedStringAt,
-  stringContains: () => stringContains,
-  stringEndsWith: () => stringEndsWith,
-  stringStartsWith: () => stringStartsWith
-});
-module.exports = __toCommonJS(typedStrings_exports);
-function stringContains(str, substring) {
-  return str.includes(substring);
-}
-function stringStartsWith(str, substring) {
-  return str.startsWith(substring);
-}
-function stringEndsWith(str, substring) {
-  return str.endsWith(substring);
-}
-function splitTypedString(str, separator) {
-  return str.split(separator);
-}
-function splitTypedStringAt(str, separator, splitAtNSeparatorPos = 1) {
-  const parts = str.split(separator);
-  let leftPart = parts[0];
-  let rightPart = parts.slice(1).join(separator);
-  if (leftPart === void 0) {
-    throw new Error("String does not contain the separator");
-  }
-  if (splitAtNSeparatorPos > 1) {
-    leftPart = parts.slice(0, splitAtNSeparatorPos).join(separator);
-    rightPart = parts.slice(splitAtNSeparatorPos).join(separator);
-  }
-  return [leftPart, rightPart];
-}
-function isNonEmptyString(str) {
-  return str.length > 0;
-}
-function asNonEmptyStringOrThrow(str) {
-  if (isNonEmptyString(str)) {
-    return str;
-  }
-  throw new Error("String is empty");
-}
-function asNonEmptyStringOrNull(str) {
-  if (isNonEmptyString(str)) {
-    return str;
-  }
-  return null;
-}
-function assertStringIsNonEmpty(str) {
-  if (!isNonEmptyString(str)) {
-    throw new Error("String is empty");
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  asNonEmptyStringOrNull,
-  asNonEmptyStringOrThrow,
-  assertStringIsNonEmpty,
-  isNonEmptyString,
-  splitTypedString,
-  splitTypedStringAt,
-  stringContains,
-  stringEndsWith,
-  stringStartsWith
-});