ansuko 1.3.13 → 1.3.15

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import _ from "lodash";
+import lodash from "lodash";
 /**
  * Checks if the value is a non-empty string. null/undefined/empty string -> false.
  * @param str - Value to check
@@ -213,7 +213,7 @@ declare const arrayDepth: (ary: unknown) => number;
  * Extends ansuko with a plugin and returns the augmented instance.
  * @param plugin - Plugin function
  * @returns Extended instance
- * @example const extended = _.extend(jaPlugin)
+ * @example const extended = lodash.extend(jaPlugin)
  * @category Core Functions
  */
 declare const extend: <T extends AnsukoType, E>(this: T, plugin: (a: T) => T & E) => T & E;
@@ -242,311 +242,311 @@ export interface AnsukoType {
     isEmpty: typeof isEmpty;
     toNumber: typeof toNumber;
     castArray: typeof castArray;
-    isEmptyOrg: typeof _.isEmpty;
-    toNumberOrg: typeof _.toNumber;
-    castArrayOrg: typeof _.castArray;
-    add: typeof _.add;
-    after: typeof _.after;
-    ary: typeof _.ary;
-    assign: typeof _.assign;
-    assignIn: typeof _.assignIn;
-    assignInWith: typeof _.assignInWith;
-    assignWith: typeof _.assignWith;
-    at: typeof _.at;
-    attempt: typeof _.attempt;
-    before: typeof _.before;
-    bind: typeof _.bind;
-    bindAll: typeof _.bindAll;
-    bindKey: typeof _.bindKey;
-    camelCase: typeof _.camelCase;
-    capitalize: typeof _.capitalize;
-    ceil: typeof _.ceil;
-    chain: typeof _.chain;
-    chunk: typeof _.chunk;
-    clamp: typeof _.clamp;
-    clone: typeof _.clone;
-    cloneDeep: typeof _.cloneDeep;
-    cloneDeepWith: typeof _.cloneDeepWith;
-    cloneWith: typeof _.cloneWith;
-    compact: typeof _.compact;
-    concat: typeof _.concat;
-    cond: typeof _.cond;
-    conforms: typeof _.conforms;
-    conformsTo: typeof _.conformsTo;
-    constant: typeof _.constant;
-    countBy: typeof _.countBy;
-    create: typeof _.create;
-    curry: typeof _.curry;
-    curryRight: typeof _.curryRight;
-    debounce: typeof _.debounce;
-    deburr: typeof _.deburr;
-    defaultTo: typeof _.defaultTo;
-    defaults: typeof _.defaults;
-    defaultsDeep: typeof _.defaultsDeep;
-    defer: typeof _.defer;
-    delay: typeof _.delay;
-    difference: typeof _.difference;
-    differenceBy: typeof _.differenceBy;
-    differenceWith: typeof _.differenceWith;
-    divide: typeof _.divide;
-    drop: typeof _.drop;
-    dropRight: typeof _.dropRight;
-    dropRightWhile: typeof _.dropRightWhile;
-    dropWhile: typeof _.dropWhile;
-    each: typeof _.each;
-    eachRight: typeof _.eachRight;
-    endsWith: typeof _.endsWith;
-    entries: typeof _.entries;
-    entriesIn: typeof _.entriesIn;
-    eq: typeof _.eq;
-    escape: typeof _.escape;
-    escapeRegExp: typeof _.escapeRegExp;
-    every: typeof _.every;
-    extendWith: typeof _.extendWith;
-    fill: typeof _.fill;
-    filter: typeof _.filter;
-    find: typeof _.find;
-    findIndex: typeof _.findIndex;
-    findKey: typeof _.findKey;
-    findLast: typeof _.findLast;
-    findLastIndex: typeof _.findLastIndex;
-    findLastKey: typeof _.findLastKey;
-    first: typeof _.first;
-    flatMap: typeof _.flatMap;
-    flatMapDeep: typeof _.flatMapDeep;
-    flatMapDepth: typeof _.flatMapDepth;
-    flatten: typeof _.flatten;
-    flattenDeep: typeof _.flattenDeep;
-    flattenDepth: typeof _.flattenDepth;
-    flip: typeof _.flip;
-    floor: typeof _.floor;
-    flow: typeof _.flow;
-    flowRight: typeof _.flowRight;
-    forEach: typeof _.forEach;
-    forEachRight: typeof _.forEachRight;
-    forIn: typeof _.forIn;
-    forInRight: typeof _.forInRight;
-    forOwn: typeof _.forOwn;
-    forOwnRight: typeof _.forOwnRight;
-    fromPairs: typeof _.fromPairs;
-    functions: typeof _.functions;
-    functionsIn: typeof _.functionsIn;
-    get: typeof _.get;
-    groupBy: typeof _.groupBy;
-    gt: typeof _.gt;
-    gte: typeof _.gte;
-    has: typeof _.has;
-    hasIn: typeof _.hasIn;
-    head: typeof _.head;
-    identity: typeof _.identity;
-    inRange: typeof _.inRange;
-    includes: typeof _.includes;
-    indexOf: typeof _.indexOf;
-    initial: typeof _.initial;
-    intersection: typeof _.intersection;
-    intersectionBy: typeof _.intersectionBy;
-    intersectionWith: typeof _.intersectionWith;
-    invert: typeof _.invert;
-    invertBy: typeof _.invertBy;
-    invoke: typeof _.invoke;
-    invokeMap: typeof _.invokeMap;
-    isArguments: typeof _.isArguments;
-    isArray: typeof _.isArray;
-    isArrayBuffer: typeof _.isArrayBuffer;
-    isArrayLike: typeof _.isArrayLike;
-    isArrayLikeObject: typeof _.isArrayLikeObject;
-    isBoolean: typeof _.isBoolean;
-    isBuffer: typeof _.isBuffer;
-    isDate: typeof _.isDate;
-    isElement: typeof _.isElement;
-    isEqual: typeof _.isEqual;
-    isEqualWith: typeof _.isEqualWith;
-    isError: typeof _.isError;
-    isFinite: typeof _.isFinite;
-    isFunction: typeof _.isFunction;
-    isInteger: typeof _.isInteger;
-    isLength: typeof _.isLength;
-    isMap: typeof _.isMap;
-    isMatch: typeof _.isMatch;
-    isMatchWith: typeof _.isMatchWith;
-    isNaN: typeof _.isNaN;
-    isNative: typeof _.isNative;
-    isNil: typeof _.isNil;
-    isNull: typeof _.isNull;
-    isNumber: typeof _.isNumber;
-    isObject: typeof _.isObject;
-    isObjectLike: typeof _.isObjectLike;
-    isPlainObject: typeof _.isPlainObject;
-    isRegExp: typeof _.isRegExp;
-    isSafeInteger: typeof _.isSafeInteger;
-    isSet: typeof _.isSet;
-    isString: typeof _.isString;
-    isSymbol: typeof _.isSymbol;
-    isTypedArray: typeof _.isTypedArray;
-    isUndefined: typeof _.isUndefined;
-    isWeakMap: typeof _.isWeakMap;
-    isWeakSet: typeof _.isWeakSet;
-    iteratee: typeof _.iteratee;
-    join: typeof _.join;
-    kebabCase: typeof _.kebabCase;
-    keyBy: typeof _.keyBy;
-    keys: typeof _.keys;
-    keysIn: typeof _.keysIn;
-    last: typeof _.last;
-    lastIndexOf: typeof _.lastIndexOf;
-    lowerCase: typeof _.lowerCase;
-    lowerFirst: typeof _.lowerFirst;
-    lt: typeof _.lt;
-    lte: typeof _.lte;
-    map: typeof _.map;
-    mapKeys: typeof _.mapKeys;
-    mapValues: typeof _.mapValues;
-    matches: typeof _.matches;
-    matchesProperty: typeof _.matchesProperty;
-    max: typeof _.max;
-    maxBy: typeof _.maxBy;
-    mean: typeof _.mean;
-    meanBy: typeof _.meanBy;
-    memoize: typeof _.memoize;
-    merge: typeof _.merge;
-    mergeWith: typeof _.mergeWith;
-    method: typeof _.method;
-    methodOf: typeof _.methodOf;
-    min: typeof _.min;
-    minBy: typeof _.minBy;
-    mixin: typeof _.mixin;
-    multiply: typeof _.multiply;
-    negate: typeof _.negate;
-    noConflict: typeof _.noConflict;
-    noop: typeof _.noop;
-    now: typeof _.now;
-    nth: typeof _.nth;
-    nthArg: typeof _.nthArg;
-    omit: typeof _.omit;
-    omitBy: typeof _.omitBy;
-    once: typeof _.once;
-    orderBy: typeof _.orderBy;
-    over: typeof _.over;
-    overArgs: typeof _.overArgs;
-    overEvery: typeof _.overEvery;
-    overSome: typeof _.overSome;
-    pad: typeof _.pad;
-    padEnd: typeof _.padEnd;
-    padStart: typeof _.padStart;
-    parseInt: typeof _.parseInt;
-    partial: typeof _.partial;
-    partialRight: typeof _.partialRight;
-    partition: typeof _.partition;
-    pick: typeof _.pick;
-    pickBy: typeof _.pickBy;
-    property: typeof _.property;
-    propertyOf: typeof _.propertyOf;
-    pull: typeof _.pull;
-    pullAll: typeof _.pullAll;
-    pullAllBy: typeof _.pullAllBy;
-    pullAllWith: typeof _.pullAllWith;
-    pullAt: typeof _.pullAt;
-    random: typeof _.random;
-    range: typeof _.range;
-    rangeRight: typeof _.rangeRight;
-    rearg: typeof _.rearg;
-    reduce: typeof _.reduce;
-    reduceRight: typeof _.reduceRight;
-    reject: typeof _.reject;
-    remove: typeof _.remove;
-    repeat: typeof _.repeat;
-    replace: typeof _.replace;
-    rest: typeof _.rest;
-    result: typeof _.result;
-    reverse: typeof _.reverse;
-    round: typeof _.round;
-    runInContext: typeof _.runInContext;
-    sample: typeof _.sample;
-    sampleSize: typeof _.sampleSize;
-    set: typeof _.set;
-    setWith: typeof _.setWith;
-    shuffle: typeof _.shuffle;
-    size: typeof _.size;
-    slice: typeof _.slice;
-    snakeCase: typeof _.snakeCase;
-    some: typeof _.some;
-    sortBy: typeof _.sortBy;
-    sortedIndex: typeof _.sortedIndex;
-    sortedIndexBy: typeof _.sortedIndexBy;
-    sortedIndexOf: typeof _.sortedIndexOf;
-    sortedLastIndex: typeof _.sortedLastIndex;
-    sortedLastIndexBy: typeof _.sortedLastIndexBy;
-    sortedLastIndexOf: typeof _.sortedLastIndexOf;
-    sortedUniq: typeof _.sortedUniq;
-    sortedUniqBy: typeof _.sortedUniqBy;
-    split: typeof _.split;
-    spread: typeof _.spread;
-    startCase: typeof _.startCase;
-    startsWith: typeof _.startsWith;
-    stubArray: typeof _.stubArray;
-    stubFalse: typeof _.stubFalse;
-    stubObject: typeof _.stubObject;
-    stubString: typeof _.stubString;
-    stubTrue: typeof _.stubTrue;
-    subtract: typeof _.subtract;
-    sum: typeof _.sum;
-    sumBy: typeof _.sumBy;
-    tail: typeof _.tail;
-    take: typeof _.take;
-    takeRight: typeof _.takeRight;
-    takeRightWhile: typeof _.takeRightWhile;
-    takeWhile: typeof _.takeWhile;
-    tap: typeof _.tap;
-    template: typeof _.template;
-    throttle: typeof _.throttle;
-    thru: typeof _.thru;
-    times: typeof _.times;
-    toArray: typeof _.toArray;
-    toFinite: typeof _.toFinite;
-    toInteger: typeof _.toInteger;
-    toLength: typeof _.toLength;
-    toLower: typeof _.toLower;
-    toPairs: typeof _.toPairs;
-    toPairsIn: typeof _.toPairsIn;
-    toPath: typeof _.toPath;
-    toPlainObject: typeof _.toPlainObject;
-    toSafeInteger: typeof _.toSafeInteger;
-    toString: typeof _.toString;
-    toUpper: typeof _.toUpper;
-    transform: typeof _.transform;
-    trim: typeof _.trim;
-    trimEnd: typeof _.trimEnd;
-    trimStart: typeof _.trimStart;
-    truncate: typeof _.truncate;
-    unary: typeof _.unary;
-    unescape: typeof _.unescape;
-    union: typeof _.union;
-    unionBy: typeof _.unionBy;
-    unionWith: typeof _.unionWith;
-    uniq: typeof _.uniq;
-    uniqBy: typeof _.uniqBy;
-    uniqWith: typeof _.uniqWith;
-    uniqueId: typeof _.uniqueId;
-    unset: typeof _.unset;
-    unzip: typeof _.unzip;
-    unzipWith: typeof _.unzipWith;
-    update: typeof _.update;
-    updateWith: typeof _.updateWith;
-    upperCase: typeof _.upperCase;
-    upperFirst: typeof _.upperFirst;
-    values: typeof _.values;
-    valuesIn: typeof _.valuesIn;
-    without: typeof _.without;
-    words: typeof _.words;
-    wrap: typeof _.wrap;
-    xor: typeof _.xor;
-    xorBy: typeof _.xorBy;
-    xorWith: typeof _.xorWith;
-    zip: typeof _.zip;
-    zipObject: typeof _.zipObject;
-    zipObjectDeep: typeof _.zipObjectDeep;
-    zipWith: typeof _.zipWith;
+    isEmptyOrg: typeof lodash.isEmpty;
+    toNumberOrg: typeof lodash.toNumber;
+    castArrayOrg: typeof lodash.castArray;
+    add: typeof lodash.add;
+    after: typeof lodash.after;
+    ary: typeof lodash.ary;
+    assign: typeof lodash.assign;
+    assignIn: typeof lodash.assignIn;
+    assignInWith: typeof lodash.assignInWith;
+    assignWith: typeof lodash.assignWith;
+    at: typeof lodash.at;
+    attempt: typeof lodash.attempt;
+    before: typeof lodash.before;
+    bind: typeof lodash.bind;
+    bindAll: typeof lodash.bindAll;
+    bindKey: typeof lodash.bindKey;
+    camelCase: typeof lodash.camelCase;
+    capitalize: typeof lodash.capitalize;
+    ceil: typeof lodash.ceil;
+    chain: typeof lodash.chain;
+    chunk: typeof lodash.chunk;
+    clamp: typeof lodash.clamp;
+    clone: typeof lodash.clone;
+    cloneDeep: typeof lodash.cloneDeep;
+    cloneDeepWith: typeof lodash.cloneDeepWith;
+    cloneWith: typeof lodash.cloneWith;
+    compact: typeof lodash.compact;
+    concat: typeof lodash.concat;
+    cond: typeof lodash.cond;
+    conforms: typeof lodash.conforms;
+    conformsTo: typeof lodash.conformsTo;
+    constant: typeof lodash.constant;
+    countBy: typeof lodash.countBy;
+    create: typeof lodash.create;
+    curry: typeof lodash.curry;
+    curryRight: typeof lodash.curryRight;
+    debounce: typeof lodash.debounce;
+    deburr: typeof lodash.deburr;
+    defaultTo: typeof lodash.defaultTo;
+    defaults: typeof lodash.defaults;
+    defaultsDeep: typeof lodash.defaultsDeep;
+    defer: typeof lodash.defer;
+    delay: typeof lodash.delay;
+    difference: typeof lodash.difference;
+    differenceBy: typeof lodash.differenceBy;
+    differenceWith: typeof lodash.differenceWith;
+    divide: typeof lodash.divide;
+    drop: typeof lodash.drop;
+    dropRight: typeof lodash.dropRight;
+    dropRightWhile: typeof lodash.dropRightWhile;
+    dropWhile: typeof lodash.dropWhile;
+    each: typeof lodash.each;
+    eachRight: typeof lodash.eachRight;
+    endsWith: typeof lodash.endsWith;
+    entries: typeof lodash.entries;
+    entriesIn: typeof lodash.entriesIn;
+    eq: typeof lodash.eq;
+    escape: typeof lodash.escape;
+    escapeRegExp: typeof lodash.escapeRegExp;
+    every: typeof lodash.every;
+    extendWith: typeof lodash.extendWith;
+    fill: typeof lodash.fill;
+    filter: typeof lodash.filter;
+    find: typeof lodash.find;
+    findIndex: typeof lodash.findIndex;
+    findKey: typeof lodash.findKey;
+    findLast: typeof lodash.findLast;
+    findLastIndex: typeof lodash.findLastIndex;
+    findLastKey: typeof lodash.findLastKey;
+    first: typeof lodash.first;
+    flatMap: typeof lodash.flatMap;
+    flatMapDeep: typeof lodash.flatMapDeep;
+    flatMapDepth: typeof lodash.flatMapDepth;
+    flatten: typeof lodash.flatten;
+    flattenDeep: typeof lodash.flattenDeep;
+    flattenDepth: typeof lodash.flattenDepth;
+    flip: typeof lodash.flip;
+    floor: typeof lodash.floor;
+    flow: typeof lodash.flow;
+    flowRight: typeof lodash.flowRight;
+    forEach: typeof lodash.forEach;
+    forEachRight: typeof lodash.forEachRight;
+    forIn: typeof lodash.forIn;
+    forInRight: typeof lodash.forInRight;
+    forOwn: typeof lodash.forOwn;
+    forOwnRight: typeof lodash.forOwnRight;
+    fromPairs: typeof lodash.fromPairs;
+    functions: typeof lodash.functions;
+    functionsIn: typeof lodash.functionsIn;
+    get: typeof lodash.get;
+    groupBy: typeof lodash.groupBy;
+    gt: typeof lodash.gt;
+    gte: typeof lodash.gte;
+    has: typeof lodash.has;
+    hasIn: typeof lodash.hasIn;
+    head: typeof lodash.head;
+    identity: typeof lodash.identity;
+    inRange: typeof lodash.inRange;
+    includes: typeof lodash.includes;
+    indexOf: typeof lodash.indexOf;
+    initial: typeof lodash.initial;
+    intersection: typeof lodash.intersection;
+    intersectionBy: typeof lodash.intersectionBy;
+    intersectionWith: typeof lodash.intersectionWith;
+    invert: typeof lodash.invert;
+    invertBy: typeof lodash.invertBy;
+    invoke: typeof lodash.invoke;
+    invokeMap: typeof lodash.invokeMap;
+    isArguments: typeof lodash.isArguments;
+    isArray: typeof lodash.isArray;
+    isArrayBuffer: typeof lodash.isArrayBuffer;
+    isArrayLike: typeof lodash.isArrayLike;
+    isArrayLikeObject: typeof lodash.isArrayLikeObject;
+    isBoolean: typeof lodash.isBoolean;
+    isBuffer: typeof lodash.isBuffer;
+    isDate: typeof lodash.isDate;
+    isElement: typeof lodash.isElement;
+    isEqual: typeof lodash.isEqual;
+    isEqualWith: typeof lodash.isEqualWith;
+    isError: typeof lodash.isError;
+    isFinite: typeof lodash.isFinite;
+    isFunction: typeof lodash.isFunction;
+    isInteger: typeof lodash.isInteger;
+    isLength: typeof lodash.isLength;
+    isMap: typeof lodash.isMap;
+    isMatch: typeof lodash.isMatch;
+    isMatchWith: typeof lodash.isMatchWith;
+    isNaN: typeof lodash.isNaN;
+    isNative: typeof lodash.isNative;
+    isNil: typeof lodash.isNil;
+    isNull: typeof lodash.isNull;
+    isNumber: typeof lodash.isNumber;
+    isObject: typeof lodash.isObject;
+    isObjectLike: typeof lodash.isObjectLike;
+    isPlainObject: typeof lodash.isPlainObject;
+    isRegExp: typeof lodash.isRegExp;
+    isSafeInteger: typeof lodash.isSafeInteger;
+    isSet: typeof lodash.isSet;
+    isString: typeof lodash.isString;
+    isSymbol: typeof lodash.isSymbol;
+    isTypedArray: typeof lodash.isTypedArray;
+    isUndefined: typeof lodash.isUndefined;
+    isWeakMap: typeof lodash.isWeakMap;
+    isWeakSet: typeof lodash.isWeakSet;
+    iteratee: typeof lodash.iteratee;
+    join: typeof lodash.join;
+    kebabCase: typeof lodash.kebabCase;
+    keyBy: typeof lodash.keyBy;
+    keys: typeof lodash.keys;
+    keysIn: typeof lodash.keysIn;
+    last: typeof lodash.last;
+    lastIndexOf: typeof lodash.lastIndexOf;
+    lowerCase: typeof lodash.lowerCase;
+    lowerFirst: typeof lodash.lowerFirst;
+    lt: typeof lodash.lt;
+    lte: typeof lodash.lte;
+    map: typeof lodash.map;
+    mapKeys: typeof lodash.mapKeys;
+    mapValues: typeof lodash.mapValues;
+    matches: typeof lodash.matches;
+    matchesProperty: typeof lodash.matchesProperty;
+    max: typeof lodash.max;
+    maxBy: typeof lodash.maxBy;
+    mean: typeof lodash.mean;
+    meanBy: typeof lodash.meanBy;
+    memoize: typeof lodash.memoize;
+    merge: typeof lodash.merge;
+    mergeWith: typeof lodash.mergeWith;
+    method: typeof lodash.method;
+    methodOf: typeof lodash.methodOf;
+    min: typeof lodash.min;
+    minBy: typeof lodash.minBy;
+    mixin: typeof lodash.mixin;
+    multiply: typeof lodash.multiply;
+    negate: typeof lodash.negate;
+    noConflict: typeof lodash.noConflict;
+    noop: typeof lodash.noop;
+    now: typeof lodash.now;
+    nth: typeof lodash.nth;
+    nthArg: typeof lodash.nthArg;
+    omit: typeof lodash.omit;
+    omitBy: typeof lodash.omitBy;
+    once: typeof lodash.once;
+    orderBy: typeof lodash.orderBy;
+    over: typeof lodash.over;
+    overArgs: typeof lodash.overArgs;
+    overEvery: typeof lodash.overEvery;
+    overSome: typeof lodash.overSome;
+    pad: typeof lodash.pad;
+    padEnd: typeof lodash.padEnd;
+    padStart: typeof lodash.padStart;
+    parseInt: typeof lodash.parseInt;
+    partial: typeof lodash.partial;
+    partialRight: typeof lodash.partialRight;
+    partition: typeof lodash.partition;
+    pick: typeof lodash.pick;
+    pickBy: typeof lodash.pickBy;
+    property: typeof lodash.property;
+    propertyOf: typeof lodash.propertyOf;
+    pull: typeof lodash.pull;
+    pullAll: typeof lodash.pullAll;
+    pullAllBy: typeof lodash.pullAllBy;
+    pullAllWith: typeof lodash.pullAllWith;
+    pullAt: typeof lodash.pullAt;
+    random: typeof lodash.random;
+    range: typeof lodash.range;
+    rangeRight: typeof lodash.rangeRight;
+    rearg: typeof lodash.rearg;
+    reduce: typeof lodash.reduce;
+    reduceRight: typeof lodash.reduceRight;
+    reject: typeof lodash.reject;
+    remove: typeof lodash.remove;
+    repeat: typeof lodash.repeat;
+    replace: typeof lodash.replace;
+    rest: typeof lodash.rest;
+    result: typeof lodash.result;
+    reverse: typeof lodash.reverse;
+    round: typeof lodash.round;
+    runInContext: typeof lodash.runInContext;
+    sample: typeof lodash.sample;
+    sampleSize: typeof lodash.sampleSize;
+    set: typeof lodash.set;
+    setWith: typeof lodash.setWith;
+    shuffle: typeof lodash.shuffle;
+    size: typeof lodash.size;
+    slice: typeof lodash.slice;
+    snakeCase: typeof lodash.snakeCase;
+    some: typeof lodash.some;
+    sortBy: typeof lodash.sortBy;
+    sortedIndex: typeof lodash.sortedIndex;
+    sortedIndexBy: typeof lodash.sortedIndexBy;
+    sortedIndexOf: typeof lodash.sortedIndexOf;
+    sortedLastIndex: typeof lodash.sortedLastIndex;
+    sortedLastIndexBy: typeof lodash.sortedLastIndexBy;
+    sortedLastIndexOf: typeof lodash.sortedLastIndexOf;
+    sortedUniq: typeof lodash.sortedUniq;
+    sortedUniqBy: typeof lodash.sortedUniqBy;
+    split: typeof lodash.split;
+    spread: typeof lodash.spread;
+    startCase: typeof lodash.startCase;
+    startsWith: typeof lodash.startsWith;
+    stubArray: typeof lodash.stubArray;
+    stubFalse: typeof lodash.stubFalse;
+    stubObject: typeof lodash.stubObject;
+    stubString: typeof lodash.stubString;
+    stubTrue: typeof lodash.stubTrue;
+    subtract: typeof lodash.subtract;
+    sum: typeof lodash.sum;
+    sumBy: typeof lodash.sumBy;
+    tail: typeof lodash.tail;
+    take: typeof lodash.take;
+    takeRight: typeof lodash.takeRight;
+    takeRightWhile: typeof lodash.takeRightWhile;
+    takeWhile: typeof lodash.takeWhile;
+    tap: typeof lodash.tap;
+    template: typeof lodash.template;
+    throttle: typeof lodash.throttle;
+    thru: typeof lodash.thru;
+    times: typeof lodash.times;
+    toArray: typeof lodash.toArray;
+    toFinite: typeof lodash.toFinite;
+    toInteger: typeof lodash.toInteger;
+    toLength: typeof lodash.toLength;
+    toLower: typeof lodash.toLower;
+    toPairs: typeof lodash.toPairs;
+    toPairsIn: typeof lodash.toPairsIn;
+    toPath: typeof lodash.toPath;
+    toPlainObject: typeof lodash.toPlainObject;
+    toSafeInteger: typeof lodash.toSafeInteger;
+    toString: typeof lodash.toString;
+    toUpper: typeof lodash.toUpper;
+    transform: typeof lodash.transform;
+    trim: typeof lodash.trim;
+    trimEnd: typeof lodash.trimEnd;
+    trimStart: typeof lodash.trimStart;
+    truncate: typeof lodash.truncate;
+    unary: typeof lodash.unary;
+    unescape: typeof lodash.unescape;
+    union: typeof lodash.union;
+    unionBy: typeof lodash.unionBy;
+    unionWith: typeof lodash.unionWith;
+    uniq: typeof lodash.uniq;
+    uniqBy: typeof lodash.uniqBy;
+    uniqWith: typeof lodash.uniqWith;
+    uniqueId: typeof lodash.uniqueId;
+    unset: typeof lodash.unset;
+    unzip: typeof lodash.unzip;
+    unzipWith: typeof lodash.unzipWith;
+    update: typeof lodash.update;
+    updateWith: typeof lodash.updateWith;
+    upperCase: typeof lodash.upperCase;
+    upperFirst: typeof lodash.upperFirst;
+    values: typeof lodash.values;
+    valuesIn: typeof lodash.valuesIn;
+    without: typeof lodash.without;
+    words: typeof lodash.words;
+    wrap: typeof lodash.wrap;
+    xor: typeof lodash.xor;
+    xorBy: typeof lodash.xorBy;
+    xorWith: typeof lodash.xorWith;
+    zip: typeof lodash.zip;
+    zipObject: typeof lodash.zipObject;
+    zipObjectDeep: typeof lodash.zipObjectDeep;
+    zipWith: typeof lodash.zipWith;
 }
-declare const _default: AnsukoType;
-export default _default;
+declare const _: AnsukoType;
+export default _;
 export { isEmpty, toNumber, boolIf, isValidStr, valueOr, equalsOr, waited, parseJSON, jsonStringify, castArray, changes, strWrap, swallow, swallowMap, arrayDepth, };

package/dist/index.js

@@ -1,4 +1,4 @@
-import _ from "lodash";
+import lodash from "lodash";
 import JSON5 from "json5";
 import { toHalfWidth } from "./util.js";
 /**
@@ -10,10 +10,10 @@ import { toHalfWidth } from "./util.js";
  * @category Type Guards
  */
 const isValidStr = (str) => {
-    if (_.isNil(str)) {
+    if (lodash.isNil(str)) {
         return false;
     }
-    if (_.isEmpty(str)) {
+    if (lodash.isEmpty(str)) {
         return false;
     }
     return typeof str === "string";
@@ -26,7 +26,7 @@ const valueOr = (value, els) => {
     // Promiseかチェック
     if (resolvedValue instanceof Promise) {
         return Promise.resolve(resolvedValue).then(res => {
-            if (_.isNil(res) || isEmpty(res)) {
+            if (lodash.isNil(res) || isEmpty(res)) {
                 if (typeof els === "function") {
                     return els();
                 }
@@ -35,7 +35,7 @@ const valueOr = (value, els) => {
             return res;
         });
     }
-    if (!_.isNil(resolvedValue) && !isEmpty(resolvedValue)) {
+    if (!lodash.isNil(resolvedValue) && !isEmpty(resolvedValue)) {
         return resolvedValue;
     }
     if (typeof els === "function") {
@@ -51,7 +51,7 @@ const emptyOr = (value, els) => {
     // Promiseかチェック
     if (resolvedValue instanceof Promise) {
         return Promise.resolve(resolvedValue).then(res => {
-            if (_.isNil(res) || isEmpty(res)) {
+            if (lodash.isNil(res) || isEmpty(res)) {
                 return null;
             }
             if (typeof els === "function") {
@@ -60,7 +60,7 @@ const emptyOr = (value, els) => {
             return els;
         });
     }
-    if (_.isNil(resolvedValue) || isEmpty(resolvedValue)) {
+    if (lodash.isNil(resolvedValue) || isEmpty(resolvedValue)) {
         return null;
     }
     if (typeof els === "function") {
@@ -87,9 +87,9 @@ const hasOr = (value, paths, els) => {
     const pathArray = Array.isArray(paths) ? paths : [paths];
     // パスが全て存在するかチェック
     const checkPaths = (val) => {
-        if (_.isNil(val) || isEmpty(val))
+        if (lodash.isNil(val) || isEmpty(val))
             return false;
-        return pathArray.every(path => _.has(val, path));
+        return pathArray.every(path => lodash.has(val, path));
     };
     // Promiseかチェック
     if (resolvedValue instanceof Promise) {
@@ -120,16 +120,16 @@ const hasOr = (value, paths, els) => {
  * @category Core Functions
  */
 const isEmpty = (value) => {
-    if (_.isNil(value)) {
+    if (lodash.isNil(value)) {
         return true;
     }
-    if (_.isNumber(value)) {
+    if (lodash.isNumber(value)) {
         return false;
     }
-    if (_.isBoolean(value)) {
+    if (lodash.isBoolean(value)) {
         return false;
     }
-    return _.isEmpty(value);
+    return lodash.isEmpty(value);
 };
 /**
  * Converts a value to number (full-width and comma aware). Returns null when invalid.
@@ -144,10 +144,10 @@ const isEmpty = (value) => {
  * @category Core Functions
  */
 const toNumber = (value, toFixed) => {
-    if (_.isNil(value)) {
+    if (lodash.isNil(value)) {
         return null;
     }
-    if (_.isNumber(value)) {
+    if (lodash.isNumber(value)) {
         return value;
     }
     if (isEmpty(value)) {
@@ -155,16 +155,16 @@ const toNumber = (value, toFixed) => {
     }
     let v = toHalfWidth(value);
     if (typeof v === "string" && v.trim().match(/^[0-9][0-9,.]*$/)) {
-        v = _.toNumber(v.trim().replace(/,/g, ""));
+        v = lodash.toNumber(v.trim().replace(/,/g, ""));
     }
     else {
-        v = _.toNumber(v);
+        v = lodash.toNumber(v);
     }
-    if (!_.isNaN(v) && !_.isNil(toFixed)) {
-        const f = _.toNumber(toFixed);
+    if (!lodash.isNaN(v) && !lodash.isNil(toFixed)) {
+        const f = lodash.toNumber(toFixed);
         v = parseFloat(v.toFixed(f));
     }
-    if (_.isNaN(v)) {
+    if (lodash.isNaN(v)) {
         return null;
     }
     return v;
@@ -180,16 +180,16 @@ const toNumber = (value, toFixed) => {
  * @category Core Functions
  */
 const toBool = (value, undetected = null) => {
-    if (_.isNil(value)) {
+    if (lodash.isNil(value)) {
         return false;
     }
     if (isEmpty(value)) {
         return false;
     }
-    if (_.isBoolean(value)) {
+    if (lodash.isBoolean(value)) {
         return value;
     }
-    if (_.isNumber(value)) {
+    if (lodash.isNumber(value)) {
         return value !== 0;
     }
     const n = toNumber(value);
@@ -231,10 +231,10 @@ const toBool = (value, undetected = null) => {
  * @category Core Functions
  */
 const boolIf = (value, defaultValue = false) => {
-    if (_.isBoolean(value)) {
+    if (lodash.isBoolean(value)) {
         return value;
     }
-    if (_.isNumber(value)) {
+    if (lodash.isNumber(value)) {
         return !!value;
     }
     return defaultValue;
@@ -286,10 +286,10 @@ const equalsOr = (...args) => {
             Promise.resolve(p1),
             Promise.resolve(p2)
         ]).then(([v1, v2]) => {
-            if (_.isNil(v1) && _.isNil(v2)) {
+            if (lodash.isNil(v1) && lodash.isNil(v2)) {
                 return null;
             }
-            if (_.isEqual(v1, v2)) {
+            if (lodash.isEqual(v1, v2)) {
                 return v1;
             }
             // elsの解決
@@ -301,10 +301,10 @@ const equalsOr = (...args) => {
     }
     else {
         // 同期処理ブランチ
-        if (_.isNil(p1) && _.isNil(p2)) {
+        if (lodash.isNil(p1) && lodash.isNil(p2)) {
             return null;
         }
-        if (_.isEqual(p1, p2)) {
+        if (lodash.isEqual(p1, p2)) {
             return p1;
         }
         // elsの解決
@@ -323,7 +323,7 @@ const equalsOr = (...args) => {
  * @category Conversion
  */
 const parseJSON = (str) => {
-    if (_.isNil(str)) {
+    if (lodash.isNil(str)) {
         return null;
     }
     if (typeof str === "object") {
@@ -347,7 +347,7 @@ const parseJSON = (str) => {
  * @category Conversion
  */
 const jsonStringify = (obj, replacer, space) => {
-    if (_.isNil(obj)) {
+    if (lodash.isNil(obj)) {
         return null;
     }
     if (typeof obj === "string") {
@@ -378,10 +378,10 @@ const jsonStringify = (obj, replacer, space) => {
  * @category Array Utilities
  */
 const castArray = (value) => {
-    if (_.isNil(value)) {
+    if (lodash.isNil(value)) {
         return [];
     }
-    return _.castArray(value);
+    return lodash.castArray(value);
 };
 /**
  * Computes differences between two objects. Supports deep paths. When `keyExcludes` is true,
@@ -405,7 +405,7 @@ const castArray = (value) => {
  */
 const changes = (sourceValue, currentValue, keys, options, finallyCallback, notEmptyCallback) => {
     const diff = {};
-    if (_.isEmpty(keys)) {
+    if (lodash.isEmpty(keys)) {
         keys = [];
         options = { ...options, keyExcludes: true };
     }
@@ -418,28 +418,28 @@ const changes = (sourceValue, currentValue, keys, options, finallyCallback, notE
         }
     }
     const targetKeys = options?.keyExcludes === true
-        ? _.difference(_.uniq([...Object.keys(sourceValue), ...Object.keys(currentValue)]), keys)
+        ? lodash.difference(lodash.uniq([...Object.keys(sourceValue), ...Object.keys(currentValue)]), keys)
         : keys;
     for (const key of targetKeys) {
-        const v1 = options?.keyExcludes === true ? sourceValue[key] : _.get(sourceValue, key);
-        const v2 = options?.keyExcludes === true ? currentValue[key] : _.get(currentValue, key);
-        if (_.isNil(v1) && _.isNil(v2))
+        const v1 = options?.keyExcludes === true ? sourceValue[key] : lodash.get(sourceValue, key);
+        const v2 = options?.keyExcludes === true ? currentValue[key] : lodash.get(currentValue, key);
+        if (lodash.isNil(v1) && lodash.isNil(v2))
             continue;
-        if (_.isNil(v1) || _.isNil(v2)) {
+        if (lodash.isNil(v1) || lodash.isNil(v2)) {
             if (options?.keyExcludes === true) {
                 diff[key] = v2 ?? null;
             }
             else {
-                _.set(diff, key, v2 ?? null);
+                lodash.set(diff, key, v2 ?? null);
             }
             continue;
         }
-        if (!_.isEqual(v1, v2)) {
+        if (!lodash.isEqual(v1, v2)) {
             if (options?.keyExcludes === true) {
                 diff[key] = v2 ?? null;
             }
             else {
-                _.set(diff, key, v2 ?? null);
+                lodash.set(diff, key, v2 ?? null);
             }
         }
     }
@@ -559,7 +559,7 @@ const arrayDepth = (ary) => {
     if (!Array.isArray(ary)) {
         return 0;
     }
-    if (_.size(ary) === 0) {
+    if (lodash.size(ary) === 0) {
         return 1;
     }
     return 1 + Math.min(...ary.map(arrayDepth));
@@ -568,7 +568,7 @@ const arrayDepth = (ary) => {
  * Extends ansuko with a plugin and returns the augmented instance.
  * @param plugin - Plugin function
  * @returns Extended instance
- * @example const extended = _.extend(jaPlugin)
+ * @example const extended = lodash.extend(jaPlugin)
  * @category Core Functions
  */
 const extend = function (plugin) {
@@ -578,12 +578,13 @@ const extend = function (plugin) {
     return this;
 };
 // Ansuko型へのキャストを外し、より安全な unknown as LoDashStatic に変更
-export default {
-    ..._,
+// 変数名を _ にすることで、VS Code の auto import 候補が `_` として表示される
+const _ = {
+    ...lodash,
     extend,
-    isEmptyOrg: _.isEmpty,
-    toNumberOrg: _.toNumber,
-    castArrayOrg: _.castArray,
+    isEmptyOrg: lodash.isEmpty,
+    toNumberOrg: lodash.toNumber,
+    castArrayOrg: lodash.castArray,
     strWrap,
     isEmpty,
     toNumber,
@@ -603,5 +604,6 @@ export default {
     swallowMap,
     arrayDepth,
 };
+export default _;
 // 個別エクスポートはそのまま
 export { isEmpty, toNumber, boolIf, isValidStr, valueOr, equalsOr, waited, parseJSON, jsonStringify, castArray, changes, strWrap, swallow, swallowMap, arrayDepth, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ansuko",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "A modern JavaScript/TypeScript utility library that extends lodash with practical, intuitive behaviors. Fixes lodash quirks, adds Promise support, Japanese text processing, and GeoJSON utilities.",
   "keywords": [
     "lodash",