ansuko 1.3.1 → 1.3.3

package/README.ja.md

@@ -167,6 +167,17 @@ extended.toPointGeoJson({ lat: 35.6895, lng: 139.6917 })
 
 // 複数のポリゴンを結合
 const unified = extended.unionPolygon([polygon1, polygon2])
+
+// MapBoxユーティリティ
+extended.mZoomInterpolate({ 10: 1, 15: 5, 20: 10 })
+// => ["interpolate", ["linear"], ["zoom"], 10, 1, 15, 5, 20, 10]
+
+extended.mProps({
+  fillColor: "#ff0000",
+  sourceLayer: "buildings",
+  visibility: true
+})
+// => { "fill-color": "#ff0000", "source-layer": "buildings", "visibility": "visible" }
 ```
 
 #### Prototypeプラグイン
@@ -254,6 +265,8 @@ extended.toPointGeoJson([139.7, 35.6])
 - **`toMultiLineStringGeoJson`** - 複数の線をMultiLineStringに変換
 - **`unionPolygon`** - 複数のPolygon/MultiPolygonを単一のジオメトリに結合
 - **`parseToTerraDraw`** - GeoJSONをTerra Draw互換のフィーチャーに変換
+- **`mZoomInterpolate`** - ズームオブジェクトをMapBox補間式に変換
+- **`mProps`** - camelCaseプロパティをMapBox互換形式に変換（minzoom、visibilityなどの特殊ケースに対応）
 
 ### Prototype拡張（プラグイン: `ansuko/plugins/prototype`）
 

package/README.md

@@ -143,6 +143,8 @@ const value = _.equalsOr(a, b, defaultValue)  // null == undefined
 - **`toMultiLineStringGeoJson`** - Convert multiple lines to MultiLineString
 - **`unionPolygon`** - Union multiple Polygon/MultiPolygon into single geometry
 - **`parseToTerraDraw`** - Convert GeoJSON to Terra Draw compatible features
+- **`mZoomInterpolate`** - Convert zoom object to MapBox interpolation expression
+- **`mProps`** - Convert camelCase properties to MapBox-compatible format (handles special cases like minzoom, visibility)
 
 ### Prototype Extensions (plugin: `ansuko/plugins/prototype`)
 
@@ -244,6 +246,17 @@ extended.toPointGeoJson({ lat: 35.6895, lng: 139.6917 })
 
 // Union multiple polygons
 const unified = extended.unionPolygon([polygon1, polygon2])
+
+// MapBox utilities
+extended.mZoomInterpolate({ 10: 1, 15: 5, 20: 10 })
+// => ["interpolate", ["linear"], ["zoom"], 10, 1, 15, 5, 20, 10]
+
+extended.mProps({
+  fillColor: "#ff0000",
+  sourceLayer: "buildings",
+  visibility: true
+})
+// => { "fill-color": "#ff0000", "source-layer": "buildings", "visibility": "visible" }
 ```
 
 #### Prototype Plugin

package/README.zh.md

@@ -142,6 +142,8 @@ const value = _.equalsOr(a, b, defaultValue)  // null == undefined
 - **`toMultiLineStringGeoJson`** - 将多条线转换为 MultiLineString
 - **`unionPolygon`** - 将多个 Polygon/MultiPolygon 合并为单个几何
 - **`parseToTerraDraw`** - 将 GeoJSON 转换为 Terra Draw 兼容的要素
+- **`mZoomInterpolate`** - 将缩放对象转换为 MapBox 插值表达式
+- **`mProps`** - 将 camelCase 属性转换为 MapBox 兼容格式（处理 minzoom、visibility 等特殊情况）
 
 ### 原型扩展（插件：`ansuko/plugins/prototype`）
 
@@ -243,6 +245,17 @@ extended.toPointGeoJson({ lat: 35.6895, lng: 139.6917 })
 
 // 合并多个多边形
 const unified = extended.unionPolygon([polygon1, polygon2])
+
+// MapBox 工具
+extended.mZoomInterpolate({ 10: 1, 15: 5, 20: 10 })
+// => ["interpolate", ["linear"], ["zoom"], 10, 1, 15, 5, 20, 10]
+
+extended.mProps({
+  fillColor: "#ff0000",
+  sourceLayer: "buildings",
+  visibility: true
+})
+// => { "fill-color": "#ff0000", "source-layer": "buildings", "visibility": "visible" }
 ```
 
 #### 原型插件

package/dist/index.d.ts

@@ -22,6 +22,18 @@ type MaybePromise<T> = T | Promise<T>;
 type MaybeFunction<T> = T | (() => MaybePromise<T>);
 declare const valueOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, els?: E | (() => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
 declare const emptyOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, els?: E | ((val: T | null | undefined) => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
+/**
+ * Ensures that all given paths exist on the resolved value; otherwise returns a default.
+ * Supports functions and Promises.
+ * @param value - Object or thunk
+ * @param paths - Paths to check
+ * @param els - Default value or thunk receiving the resolved value
+ * @returns Value or default
+ * @example await hasOr(fetchUser(), ['profile.name','id'], null)
+ * @example hasOr({a:{b:1}}, 'a.b', {}) // returns original object
+ * @category Promise Utilities
+ */
+declare const hasOr: <T, E>(value: MaybeFunction<MaybePromise<T | null | undefined>>, paths: string | string[], els?: E | ((val: T | null | undefined) => MaybePromise<E>)) => MaybePromise<T | E | undefined | null>;
 /**
  * Checks emptiness with intuitive rules: numbers and booleans are NOT empty.
  * @param value - Value to check
@@ -206,40 +218,329 @@ export type ChangesOptions = {
 };
 type ChangesAfterCallback<T> = (value: T) => any | Promise<any>;
 type ChangesAfterFinallyCallback<T> = (value: T, res: any) => any | Promise<any>;
-export interface AnsukoType extends Omit<_.LoDashStatic, "castArray" | "isEmpty" | "toNumber"> {
+export interface AnsukoType {
     extend: typeof extend;
     isValidStr: typeof isValidStr;
     valueOr: typeof valueOr;
     emptyOr: typeof emptyOr;
-    isEmpty: typeof isEmpty;
-    toNumber: typeof toNumber;
+    hasOr: typeof hasOr;
     toBool: typeof toBool;
     boolIf: typeof boolIf;
     waited: typeof waited;
     equalsOr: typeof equalsOr;
     parseJSON: typeof parseJSON;
     jsonStringify: typeof jsonStringify;
-    castArray: typeof castArray;
     changes: typeof changes;
     swallow: typeof swallow;
     swallowMap: typeof swallowMap;
-    size: typeof _.size;
-    isNil: typeof _.isNil;
+    arrayDepth: typeof arrayDepth;
+    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;
-    isEqual: typeof _.isEqual;
+    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;
-    first: typeof _.first;
+    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;
-    has: typeof _.has;
-    keys: typeof _.keys;
+    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;
-    some: typeof _.some;
-    arrayDepth: typeof arrayDepth;
-    isEmptyOrg: typeof _.isEmpty;
-    toNumberOrg: typeof _.toNumber;
-    castArrayOrg: typeof _.castArray;
+    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;
 }
 declare const _default: AnsukoType;
 export default _default;

package/dist/plugins/geo.d.ts

@@ -21,6 +21,8 @@ export interface AnsukoGeoPluginExtension {
     toMultiPolygonGeoJson: (geo: any, digit?: number) => GeoJSON.MultiPolygon | null;
     toMultiLineStringGeoJson: (geo: any, digit?: number) => GeoJSON.MultiLineString | null;
     unionPolygon: (geo: any, digit?: number) => GeoJSON.Polygon | GeoJSON.MultiPolygon | null;
+    mZoomInterpolate: (zoomValues: Record<number, number>, type?: string) => any;
+    mProps: (properties: Record<string, any>, excludeKeys?: string[]) => Record<string, any>;
 }
 declare const ansukoGeoPlugin: <T extends AnsukoType>(ansuko: T) => T & AnsukoGeoPluginExtension;
 export default ansukoGeoPlugin;

package/dist/plugins/geo.js

@@ -551,6 +551,108 @@ const ansukoGeoPlugin = (ansuko) => {
         }
         return features;
     };
+    /**
+     * Creates a MapBox zoom interpolation expression from a simple object mapping.
+     * Converts `{10: 1, 15: 5, 20: 10}` into MapBox's interpolation array format.
+     *
+     * @param zoomValues - Object mapping zoom levels to values
+     * @param type - Interpolation type: "linear", "exponential", or "cubic-bezier" (default: "linear")
+     * @returns MapBox interpolation expression array
+     * @example
+     * _.mZoomInterpolate({ 10: 1, 15: 5, 20: 10 })
+     * // Returns: ["interpolate", ["linear"], ["zoom"], 10, 1, 15, 5, 20, 10]
+     * @example
+     * _.mZoomInterpolate({ 12: 0.5, 18: 2 }, "exponential")
+     * @category Geo Utilities
+     */
+    const mZoomInterpolate = (zoomValues, type = "linear") => {
+        let vals = [];
+        Object.entries(zoomValues).sort((v1, v2) => {
+            return parseFloat(v1[0]) - parseFloat(v2[0]);
+        }).map(([zoom, val]) => {
+            vals.push(parseFloat(zoom));
+            vals.push(val);
+        });
+        return [
+            "interpolate",
+            [type],
+            ["zoom"],
+            ...vals,
+        ];
+    };
+    /**
+     * Converts camelCase properties to MapBox-compatible format.
+     * Handles special cases like minzoom, maxzoom, tileSize, cluster properties, and converts
+     * visibility boolean to "visible"/"none". Recursively processes nested objects and arrays.
+     *
+     * @param properties - Object with camelCase properties
+     * @param excludeKeys - Keys to exclude from conversion (keeps original key and value)
+     * @returns Converted properties object compatible with MapBox
+     * @example
+     * _.mProps({
+     *   fillColor: "#ff0000",
+     *   fillOpacity: 0.5,
+     *   sourceLayer: "buildings"
+     * })
+     * // Returns: { "fill-color": "#ff0000", "fill-opacity": 0.5, "source-layer": "buildings" }
+     * @example
+     * _.mProps({ visibility: true }) // Returns: { visibility: "visible" }
+     * @example
+     * _.mProps({ minZoom: 10, maxZoom: 20 }) // Returns: { minzoom: 10, maxzoom: 20 }
+     * @category Geo Utilities
+     */
+    const mProps = (properties, excludeKeys = []) => {
+        if (_.isEmpty(properties)) {
+            return properties;
+        }
+        if (Array.isArray(properties)) {
+            return properties.map(p => mProps(p, excludeKeys));
+        }
+        if (typeof properties === "object") {
+            return Object.fromEntries(Object.entries(properties).map(([key, value]) => {
+                let newKey = key;
+                const lKey = key.toLowerCase();
+                if (lKey === "minzoom") {
+                    newKey = "minzoom";
+                }
+                else if (lKey === "maxzoom") {
+                    newKey = "maxzoom";
+                }
+                else if (lKey === "tilesize") {
+                    newKey = "tileSize";
+                }
+                else if (lKey === "clusterradius") {
+                    newKey = "clusterRadius";
+                }
+                else if (lKey === "clustermaxzoom") {
+                    newKey = "clusterMaxZoom";
+                }
+                else if (lKey === "clusterminpoints") {
+                    newKey = "clusterMinPoints";
+                }
+                else if (lKey === "clusterproperties") {
+                    newKey = "clusterProperties";
+                }
+                else if (lKey === "linemetrics") {
+                    newKey = "lineMetrics";
+                }
+                else {
+                    newKey = _.kebabCase(newKey).toLowerCase();
+                }
+                if (key === "visibility" && _.isBoolean(value)) {
+                    return ["visibility", value ? "visible" : "none"];
+                }
+                if (excludeKeys.includes(key) || excludeKeys.includes(newKey)) {
+                    return [key, value];
+                }
+                if (Array.isArray(value) || typeof value === "object") {
+                    value = mProps(value, excludeKeys);
+                }
+                return [newKey, value];
+            }));
+        }
+        return properties;
+    };
     const a = ansuko;
     a.toLngLatArray = toLngLatArray;
     a.toGeoJson = toGeoJson;
@@ -562,6 +664,8 @@ const ansukoGeoPlugin = (ansuko) => {
     a.toMultiPolygonGeoJson = toMultiPolygonGeoJson;
     a.unionPolygon = unionPolygon;
     a.parseToTerraDraw = parseToTerraDraw;
+    a.mZoomInterpolate = mZoomInterpolate;
+    a.mProps = mProps;
     return ansuko;
 };
 export default ansukoGeoPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ansuko",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "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",