@naturalcycles/js-lib 14.276.0 → 15.0.0

package/dist/promise/pMap.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pMap = pMap;
-const __1 = require("..");
+import { END, ErrorMode, SKIP } from '../index.js';
 /**
  * Forked from https://github.com/sindresorhus/p-map
  *
@@ -36,12 +33,12 @@ const __1 = require("..");
  * 	//=> ['http://ava.li/', 'http://todomvc.com/']
  * })();
  */
-async function pMap(iterable, mapper, opt = {}) {
+export async function pMap(iterable, mapper, opt = {}) {
     const items = [...iterable];
     const itemsLength = items.length;
     if (itemsLength === 0)
         return []; // short circuit
-    const { concurrency = Infinity, errorMode = __1.ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
+    const { concurrency = Infinity, errorMode = ErrorMode.THROW_IMMEDIATELY, logger = console } = opt;
     // Special cases that are able to preserve async stack traces
     // Special case: serial execution
     if (concurrency === 1) {
@@ -67,7 +64,7 @@ async function pMap(iterable, mapper, opt = {}) {
             if (currentIndex > itemsLength) {
                 if (resolvingCount === 0) {
                     isSettled = true;
-                    const r = ret.filter(r => r !== __1.SKIP);
+                    const r = ret.filter(r => r !== SKIP);
                     if (errors.length) {
                         reject(new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`));
                     }
@@ -81,20 +78,20 @@ async function pMap(iterable, mapper, opt = {}) {
             Promise.resolve(nextItem)
                 .then(async (element) => await mapper(element, i))
                 .then(value => {
-                if (value === __1.END) {
+                if (value === END) {
                     isSettled = true;
-                    return resolve(ret.filter(r => r !== __1.SKIP));
+                    return resolve(ret.filter(r => r !== SKIP));
                 }
                 ret[i] = value;
                 resolvingCount--;
                 next();
             }, (err) => {
-                if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
+                if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
                     isSettled = true;
                     reject(err);
                 }
                 else {
-                    if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
                         errors.push(err);
                     }
                     else {
@@ -124,15 +121,15 @@ async function pMap1(items, mapper, errorMode, logger) {
     for (const item of items) {
         try {
             const r = await mapper(item, i++);
-            if (r === __1.END)
+            if (r === END)
                 break;
-            if (r !== __1.SKIP)
+            if (r !== SKIP)
                 ret.push(r);
         }
         catch (err) {
-            if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY)
+            if (errorMode === ErrorMode.THROW_IMMEDIATELY)
                 throw err;
-            if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+            if (errorMode === ErrorMode.THROW_AGGREGATED) {
                 errors.push(err);
             }
             else {
@@ -150,19 +147,19 @@ async function pMap1(items, mapper, errorMode, logger) {
  pMap with fully concurrent execution, like Promise.all
  */
 async function pMapAll(items, mapper, errorMode, logger) {
-    if (errorMode === __1.ErrorMode.THROW_IMMEDIATELY) {
-        return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== __1.SKIP && r !== __1.END);
+    if (errorMode === ErrorMode.THROW_IMMEDIATELY) {
+        return (await Promise.all(items.map((item, i) => mapper(item, i)))).filter(r => r !== SKIP && r !== END);
     }
     const ret = [];
     const errors = [];
     for (const r of await Promise.allSettled(items.map((item, i) => mapper(item, i)))) {
         if (r.status === 'fulfilled') {
-            if (r.value === __1.END)
+            if (r.value === END)
                 break;
-            if (r.value !== __1.SKIP)
+            if (r.value !== SKIP)
                 ret.push(r.value);
         }
-        else if (errorMode === __1.ErrorMode.THROW_AGGREGATED) {
+        else if (errorMode === ErrorMode.THROW_AGGREGATED) {
             errors.push(r.reason);
         }
         else {

package/dist/promise/pProps.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pProps = pProps;
 /**
  * Promise.all for Object instead of Array.
  *
@@ -15,7 +12,7 @@ exports.pProps = pProps;
  * Concurrency implementation via pMap was removed in favor of preserving async
  * stack traces (more important!).
  */
-async function pProps(input) {
+export async function pProps(input) {
     const keys = Object.keys(input);
     // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion

package/dist/promise/pQueue.d.ts

@@ -1,5 +1,5 @@
-import { ErrorMode } from '../error/errorMode';
-import type { CommonLogger } from '../log/commonLogger';
+import { ErrorMode } from '../error/errorMode.js';
+import type { CommonLogger } from '../log/commonLogger.js';
 export interface PQueueCfg {
     concurrency: number;
     /**

package/dist/promise/pQueue.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PQueue = void 0;
-const errorMode_1 = require("../error/errorMode");
-const pDefer_1 = require("./pDefer");
+import { ErrorMode } from '../error/errorMode.js';
+import { pDefer } from './pDefer.js';
 /**
  * Inspired by: https://github.com/sindresorhus/p-queue
  *
@@ -11,11 +8,11 @@ const pDefer_1 = require("./pDefer");
  *
  * API is @experimental
  */
-class PQueue {
+export class PQueue {
     constructor(cfg) {
         this.cfg = {
             // concurrency: Number.MAX_SAFE_INTEGER,
-            errorMode: errorMode_1.ErrorMode.THROW_IMMEDIATELY,
+            errorMode: ErrorMode.THROW_IMMEDIATELY,
             logger: console,
             debug: false,
             resolveOn: 'finish',
@@ -43,7 +40,7 @@ class PQueue {
     async onIdle() {
         if (this.queue.length === 0 && this.inFlight === 0)
             return;
-        const listener = (0, pDefer_1.pDefer)();
+        const listener = pDefer();
         this.onIdleListeners.push(listener);
         return await listener;
     }
@@ -55,7 +52,7 @@ class PQueue {
         const { concurrency } = this.cfg;
         const resolveOnStart = this.cfg.resolveOn === 'start';
         const fn = fn_;
-        fn.defer ||= (0, pDefer_1.pDefer)();
+        fn.defer ||= pDefer();
         if (this.inFlight < concurrency) {
             // There is room for more jobs. Can start immediately
             this.inFlight++;
@@ -71,7 +68,7 @@ class PQueue {
                 this.cfg.logger.error(err);
                 if (resolveOnStart)
                     return;
-                if (this.cfg.errorMode === errorMode_1.ErrorMode.SUPPRESS) {
+                if (this.cfg.errorMode === ErrorMode.SUPPRESS) {
                     fn.defer.resolve(); // resolve with `void`
                 }
                 else {
@@ -103,4 +100,3 @@ class PQueue {
         return await fn.defer;
     }
 }
-exports.PQueue = PQueue;

package/dist/promise/pRetry.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction, CommonLogger, ErrorData } from '..';
+import type { AnyFunction, CommonLogger, ErrorData } from '../index.js';
 export interface PRetryOptions {
     /**
      * If set - will be included in the error message.

package/dist/promise/pRetry.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pRetryFn = pRetryFn;
-exports.pRetry = pRetry;
-const __1 = require("..");
+import { _errorDataAppend, _since, pDelay, pTimeout } from '../index.js';
 /**
  * Returns a Function (!), enhanced with retry capabilities.
  * Implements "Exponential back-off strategy" by multiplying the delay by `delayMultiplier` with each try.
  */
-function pRetryFn(fn, opt = {}) {
+export function pRetryFn(fn, opt = {}) {
     return async function pRetryFunction(...args) {
         return await pRetry(() => fn.call(this, ...args), opt);
     };
 }
-async function pRetry(fn, opt = {}) {
+export async function pRetry(fn, opt = {}) {
     const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, timeout, } = opt;
     const fakeError = timeout ? new Error('TimeoutError') : undefined;
     let { logFirstAttempt = false, logRetries = true, logFailures = true, logSuccess = false } = opt;
@@ -34,7 +30,7 @@ async function pRetry(fn, opt = {}) {
             }
             let result;
             if (timeout) {
-                result = await (0, __1.pTimeout)(async () => await fn(attempt), {
+                result = await pTimeout(async () => await fn(attempt), {
                     timeout,
                     name: fname,
                     errorData: opt.errorData,
@@ -45,7 +41,7 @@ async function pRetry(fn, opt = {}) {
                 result = await fn(attempt);
             }
             if (logSuccess) {
-                logger.log(`${fname} attempt #${attempt} succeeded in ${(0, __1._since)(started)}`);
+                logger.log(`${fname} attempt #${attempt} succeeded in ${_since(started)}`);
             }
             return result;
         }
@@ -53,15 +49,15 @@ async function pRetry(fn, opt = {}) {
             if (logFailures) {
                 // Logger at warn (not error) level, because it's not a fatal error, but a retriable one
                 // Fatal one is not logged either, because it's been thrown instead
-                logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
+                logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
             }
             if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                 // Give up
-                throw (0, __1._errorDataAppend)(err, opt.errorData);
+                throw _errorDataAppend(err, opt.errorData);
             }
             // Retry after delay
             delay *= delayMultiplier;
-            await (0, __1.pDelay)(delay);
+            await pDelay(delay);
             // back to while(true) loop
         }
     }

package/dist/promise/pState.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pState = pState;
 const UNIQUE_VALUE = Symbol('unique');
 /**
  * Returns the state of the Promise, one of:
@@ -10,7 +7,7 @@ const UNIQUE_VALUE = Symbol('unique');
  *
  * Based on: https://makandracards.com/makandra/46681-javascript-how-to-query-the-state-of-a-native-promise
  */
-async function pState(p) {
+export async function pState(p) {
     return await Promise.race([p, Promise.resolve(UNIQUE_VALUE)]).then(v => {
         return v === UNIQUE_VALUE ? 'pending' : 'resolved';
     }, () => 'rejected');

package/dist/promise/pTimeout.d.ts

@@ -1,6 +1,6 @@
-import type { ErrorData } from '../error/error.model';
-import { TimeoutError } from '../error/error.util';
-import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types';
+import type { ErrorData } from '../error/error.model.js';
+import { TimeoutError } from '../error/error.util.js';
+import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types.js';
 export interface PTimeoutOptions {
     /**
      * Timeout in milliseconds.

package/dist/promise/pTimeout.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pTimeoutFn = pTimeoutFn;
-exports.pTimeout = pTimeout;
-const error_util_1 = require("../error/error.util");
-const types_1 = require("../types");
+import { _errorDataAppend, TimeoutError } from '../error/error.util.js';
+import { _typeCast } from '../types.js';
 /**
  * Decorates a Function with a timeout.
  * Returns a decorated Function.
@@ -11,7 +7,7 @@ const types_1 = require("../types");
  * Throws an Error if the Function is not resolved in a certain time.
  * If the Function rejects - passes this rejection further.
  */
-function pTimeoutFn(fn, opt) {
+export function pTimeoutFn(fn, opt) {
     opt.name ||= fn.name;
     if (!opt.timeout) {
         return fn;
@@ -26,7 +22,7 @@ function pTimeoutFn(fn, opt) {
  * Throws an Error if the Function is not resolved in a certain time.
  * If the Function rejects - passes this rejection further.
  */
-async function pTimeout(fn, opt) {
+export async function pTimeout(fn, opt) {
     if (!opt.timeout) {
         // short-circuit to direct execution if 0 timeout is passed
         return await fn();
@@ -37,7 +33,7 @@ async function pTimeout(fn, opt) {
     return await new Promise(async (resolve, reject) => {
         // Prepare the timeout timer
         const timer = setTimeout(() => {
-            const err = new error_util_1.TimeoutError(`"${name}" timed out after ${timeout} ms`, opt.errorData);
+            const err = new TimeoutError(`"${name}" timed out after ${timeout} ms`, opt.errorData);
             // keep original stack
             err.stack = fakeError.stack.replace('Error: TimeoutError', 'TimeoutError: ' + err.message);
             if (onTimeout) {
@@ -45,10 +41,10 @@ async function pTimeout(fn, opt) {
                     resolve(onTimeout(err));
                 }
                 catch (err) {
-                    (0, types_1._typeCast)(err);
+                    _typeCast(err);
                     // keep original stack
                     err.stack = fakeError.stack.replace('Error: TimeoutError', err.name + ': ' + err.message);
-                    reject((0, error_util_1._errorDataAppend)(err, opt.errorData));
+                    reject(_errorDataAppend(err, opt.errorData));
                 }
                 return;
             }

package/dist/semver.d.ts

@@ -1,4 +1,4 @@
-import type { SortDirection } from './types';
+import type { SortDirection } from './types.js';
 export type SemverInput = string | Semver;
 export type SemverInputNullable = SemverInput | null | undefined;
 export type SemverTokens = [major: number, minor: number, patch: number];

package/dist/semver.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.semver2 = exports.Semver = void 0;
-exports._quickSemverCompare = _quickSemverCompare;
-const range_1 = require("./array/range");
-const assert_1 = require("./error/assert");
+import { _range } from './array/range.js';
+import { _assert } from './error/assert.js';
 /**
  * Simple Semver implementation.
  *
@@ -20,7 +16,7 @@ const assert_1 = require("./error/assert");
  *
  * @experimental
  */
-class Semver {
+export class Semver {
     tokens;
     constructor(tokens) {
         this.tokens = tokens;
@@ -45,7 +41,7 @@ class Semver {
      * returns -1 if this < other
      */
     compare(other) {
-        const { tokens } = exports.semver2.fromInput(other);
+        const { tokens } = semver2.fromInput(other);
         for (let i = 0; i < 3; i++) {
             if (this.tokens[i] < tokens[i])
                 return -1;
@@ -59,11 +55,10 @@ class Semver {
         return this.tokens.join('.');
     }
 }
-exports.Semver = Semver;
 class SemverFactory {
     fromInput(input) {
         const s = this.fromInputOrUndefined(input);
-        (0, assert_1._assert)(s, `Cannot parse "${input}" into Semver`, {
+        _assert(s, `Cannot parse "${input}" into Semver`, {
             input,
         });
         return s;
@@ -74,7 +69,7 @@ class SemverFactory {
         if (input instanceof Semver)
             return input;
         const t = input.split('.');
-        return new Semver((0, range_1._range)(3).map(i => parseInt(t[i]) || 0));
+        return new Semver(_range(3).map(i => parseInt(t[i]) || 0));
     }
     /**
      * Returns the highest (max) Semver from the array, or undefined if the array is empty.
@@ -95,7 +90,7 @@ class SemverFactory {
      */
     max(items) {
         const max = this.maxOrUndefined(items);
-        (0, assert_1._assert)(max, 'semver.max called on empty array');
+        _assert(max, 'semver.max called on empty array');
         return max;
     }
     /**
@@ -117,7 +112,7 @@ class SemverFactory {
      */
     min(items) {
         const min = this.minOrUndefined(items);
-        (0, assert_1._assert)(min, 'semver.min called on empty array');
+        _assert(min, 'semver.min called on empty array');
         return min;
     }
     /**
@@ -129,10 +124,10 @@ class SemverFactory {
     }
 }
 const semverFactory = new SemverFactory();
-exports.semver2 = semverFactory.fromInput.bind(semverFactory);
+export const semver2 = semverFactory.fromInput.bind(semverFactory);
 // The line below is the blackest of black magic I have ever written in 2024.
 // And probably 2023 as well.
-Object.setPrototypeOf(exports.semver2, semverFactory);
+Object.setPrototypeOf(semver2, semverFactory);
 /**
  * Returns 1 if a > b
  * returns 0 if they are equal
@@ -142,13 +137,13 @@ Object.setPrototypeOf(exports.semver2, semverFactory);
  *
  * Credit: https://stackoverflow.com/a/47159772/4919972
  */
-function _quickSemverCompare(a, b) {
+export function _quickSemverCompare(a, b) {
     const t1 = a.split('.');
     const t2 = b.split('.');
-    const s1 = (0, range_1._range)(3)
+    const s1 = _range(3)
         .map(i => (t1[i] || '').padStart(5))
         .join('');
-    const s2 = (0, range_1._range)(3)
+    const s2 = _range(3)
         .map(i => (t2[i] || '').padStart(5))
         .join('');
     return s1 < s2 ? -1 : s1 > s2 ? 1 : 0;

package/dist/string/case.js

@@ -1,28 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._camelCase = _camelCase;
-exports._snakeCase = _snakeCase;
-exports._kebabCase = _kebabCase;
-const words_1 = require("./lodash/words");
-const string_util_1 = require("./string.util");
-function _camelCase(s) {
+import { words } from './lodash/words.js';
+import { _upperFirst } from './string.util.js';
+export function _camelCase(s) {
     let r = '';
-    for (let word of (0, words_1.words)(s.replaceAll(/['\u2019]/g, ''))) {
+    for (let word of words(s.replaceAll(/['\u2019]/g, ''))) {
         word = word.toLowerCase();
-        r += r ? (0, string_util_1._upperFirst)(word) : word;
+        r += r ? _upperFirst(word) : word;
     }
     return r;
 }
-function _snakeCase(s) {
+export function _snakeCase(s) {
     let r = '';
-    for (const word of (0, words_1.words)(s.replaceAll(/['\u2019]/g, ''))) {
+    for (const word of words(s.replaceAll(/['\u2019]/g, ''))) {
         r += (r ? '_' : '') + word.toLowerCase();
     }
     return r;
 }
-function _kebabCase(s) {
+export function _kebabCase(s) {
     let r = '';
-    for (const word of (0, words_1.words)(s.replaceAll(/['\u2019]/g, ''))) {
+    for (const word of words(s.replaceAll(/['\u2019]/g, ''))) {
         r += (r ? '-' : '') + word.toLowerCase();
     }
     return r;

package/dist/string/escape.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 
 Vendored:
@@ -11,9 +10,6 @@ Reasons:
 2. ESM-only
 
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.htmlEscape = htmlEscape;
-exports.htmlUnescape = htmlUnescape;
 // Multiple `.replace()` calls are actually faster than using replacer functions
 function _htmlEscape(s) {
     return s
@@ -31,7 +27,7 @@ function _htmlUnescape(html) {
         .replaceAll('"', '"')
         .replaceAll('&', '&'); // Must happen last or else it will unescape other characters in the wrong order.
 }
-function htmlEscape(strings, ...values) {
+export function htmlEscape(strings, ...values) {
     if (typeof strings === 'string') {
         return _htmlEscape(strings);
     }
@@ -41,7 +37,7 @@ function htmlEscape(strings, ...values) {
     }
     return output;
 }
-function htmlUnescape(strings, ...values) {
+export function htmlUnescape(strings, ...values) {
     if (typeof strings === 'string') {
         return _htmlUnescape(strings);
     }

package/dist/string/hash.util.d.ts

@@ -1,4 +1,4 @@
-import type { Integer } from '../types';
+import type { Integer } from '../types.js';
 /**
  * Returns hashCode as hex (radix 16).
  *

package/dist/string/hash.util.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashCode16 = hashCode16;
-exports.hashCode36 = hashCode36;
-exports.hashCode64 = hashCode64;
-exports.hashCode = hashCode;
 const BASE62 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 // const BASE64 = BASE62 + '+/'
 const BASE64URL = BASE62 + '-_';
@@ -24,7 +18,7 @@ const BASE64URL = BASE62 + '-_';
  * Perf: it runs ~10 times faster than CryptoJS md5, and ~3 times smaller String hash size (for
  * hashCode64).
  */
-function hashCode16(s) {
+export function hashCode16(s) {
     return hashCode(s).toString(16);
 }
 /**
@@ -33,14 +27,14 @@ function hashCode16(s) {
  *
  * See the hashCode16 for full description.
  */
-function hashCode36(s) {
+export function hashCode36(s) {
     return hashCode(s).toString(36);
 }
 /**
  * Returns hashCode as "radix 64", using Base64url alphabet.
  * See the hashCode16 for full description.
  */
-function hashCode64(s) {
+export function hashCode64(s) {
     return numberToBase(hashCode(s), BASE64URL);
 }
 /**
@@ -49,7 +43,7 @@ function hashCode64(s) {
  * by adding 2147483647 + 1 to the end result.
  * Source: https://stackoverflow.com/a/33647870/4919972
  */
-function hashCode(s) {
+export function hashCode(s) {
     let hash = 0;
     let i = 0;
     const len = s.length;

package/dist/string/json.util.d.ts

@@ -1,4 +1,4 @@
-import type { Reviver } from '../types';
+import type { Reviver } from '../types.js';
 /**
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).

package/dist/string/json.util.js

@@ -1,16 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._jsonParseIfPossible = _jsonParseIfPossible;
-exports._jsonParseOrUndefined = _jsonParseOrUndefined;
-exports._jsonParse = _jsonParse;
-const error_util_1 = require("../error/error.util");
+import { JsonParseError } from '../error/error.util.js';
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/;
 /**
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).
  */
-function _jsonParseIfPossible(obj, reviver) {
+export function _jsonParseIfPossible(obj, reviver) {
     // Optimization: only try to parse if it looks like JSON: starts with a json possible character
     if (typeof obj === 'string' && obj && DETECT_JSON.test(obj)) {
         try {
@@ -24,7 +19,7 @@ function _jsonParseIfPossible(obj, reviver) {
  * Convenience function that does JSON.parse, but doesn't throw on error,
  * instead - safely returns `undefined`.
  */
-function _jsonParseOrUndefined(obj, reviver) {
+export function _jsonParseOrUndefined(obj, reviver) {
     // Optimization: only try to parse if it looks like JSON: starts with a json possible character
     if (typeof obj === 'string' && obj && DETECT_JSON.test(obj)) {
         try {
@@ -39,12 +34,12 @@ function _jsonParseOrUndefined(obj, reviver) {
  * 1. It's message includes a piece of source text (truncated)
  * 2. It's data.text contains full source text
  */
-function _jsonParse(s, reviver) {
+export function _jsonParse(s, reviver) {
     try {
         return JSON.parse(s, reviver);
     }
     catch {
-        throw new error_util_1.JsonParseError({
+        throw new JsonParseError({
             text: s,
         });
     }

package/dist/string/leven.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._leven = _leven;
 const array = [];
 const characterCodeCache = [];
 /* eslint-disable unicorn/prefer-code-point, no-bitwise */
@@ -12,7 +9,7 @@ const characterCodeCache = [];
  * `limit` optional parameter can be used to limit the distance calculation
  * and skip unnecessary iterations when limit is reached.
  */
-function _leven(first, second, limit) {
+export function _leven(first, second, limit) {
     if (first === second || limit === 0) {
         return 0;
     }

package/dist/string/lodash/unicodeWords.js

@@ -1,8 +1,5 @@
-"use strict";
 // from: https://github.com/lodash/lodash/blob/master/.internal/unicodeWords.js
 /* eslint-disable */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unicodeWords = unicodeWords;
 /** Used to compose unicode character classes. */
 const rsAstralRange = '\\ud800-\\udfff';
 const rsComboMarksRange = '\\u0300-\\u036f';
@@ -66,6 +63,6 @@ const reUnicodeWords = new RegExp([
  *
  * @returns {Array} Returns the words of `string`.
  */
-function unicodeWords(s) {
+export function unicodeWords(s) {
     return s.match(reUnicodeWords);
 }

package/dist/string/lodash/words.js

@@ -1,9 +1,6 @@
-"use strict";
 // from: https://github.com/lodash/lodash/blob/master/words.js
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.words = words;
 /* eslint-disable */
-const unicodeWords_1 = require("./unicodeWords");
+import { unicodeWords } from './unicodeWords.js';
 const hasUnicodeWord = RegExp.prototype.test.bind(/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/);
 /** Used to match words composed of alphanumeric characters. */
 // biome-ignore lint/suspicious/noControlCharactersInRegex: ok
@@ -25,9 +22,9 @@ function asciiWords(s) {
  * words('fred, barney, & pebbles', /[^, ]+/g)
  * // => ['fred', 'barney', '&', 'pebbles']
  */
-function words(s, pattern) {
+export function words(s, pattern) {
     if (pattern === undefined) {
-        const result = hasUnicodeWord(s) ? (0, unicodeWords_1.unicodeWords)(s) : asciiWords(s);
+        const result = hasUnicodeWord(s) ? unicodeWords(s) : asciiWords(s);
         return result || [];
     }
     return s.match(pattern) || [];