dl-common-util 0.0.2 → 0.0.4

package/88b0986a7186d029-atomicfu-js-ir.js

@@ -0,0 +1,15 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports);
+  else
+    root['88b0986a7186d029-atomicfu-js-ir'] = factory(typeof this['88b0986a7186d029-atomicfu-js-ir'] === 'undefined' ? {} : this['88b0986a7186d029-atomicfu-js-ir']);
+}(this, function (_) {
+  'use strict';
+  //region block: pre-declaration
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=88b0986a7186d029-atomicfu-js-ir.js.map

package/88b0986a7186d029-atomicfu-js-ir.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/buffer-kt.js

@@ -0,0 +1,266 @@
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'));
+  else {
+    if (typeof this['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'buffer-kt'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'buffer-kt'.");
+    }
+    root['buffer-kt'] = factory(typeof this['buffer-kt'] === 'undefined' ? {} : this['buffer-kt'], this['kotlin-kotlin-stdlib']);
+  }
+}(this, function (_, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var protoOf = kotlin_kotlin.$_$.s1;
+  var objectMeta = kotlin_kotlin.$_$.r1;
+  var setMetadataFor = kotlin_kotlin.$_$.t1;
+  var classMeta = kotlin_kotlin.$_$.g1;
+  var Unit_instance = kotlin_kotlin.$_$.s;
+  var Enum = kotlin_kotlin.$_$.c3;
+  var interfaceMeta = kotlin_kotlin.$_$.n1;
+  var VOID = kotlin_kotlin.$_$.b;
+  var ByteCompanionObject_instance = kotlin_kotlin.$_$.q;
+  var THROW_CCE = kotlin_kotlin.$_$.e3;
+  var contentEquals = kotlin_kotlin.$_$.u;
+  var getBooleanHashCode = kotlin_kotlin.$_$.k1;
+  var hashCode = kotlin_kotlin.$_$.m1;
+  //endregion
+  //region block: pre-declaration
+  setMetadataFor(AllocationZone, 'AllocationZone', classMeta);
+  setMetadataFor(Heap, 'Heap', objectMeta, AllocationZone);
+  setMetadataFor(SharedMemory, 'SharedMemory', objectMeta, AllocationZone);
+  setMetadataFor(Custom, 'Custom', classMeta, AllocationZone);
+  setMetadataFor(ByteOrder, 'ByteOrder', classMeta, Enum);
+  setMetadataFor(Companion, 'Companion', objectMeta);
+  function remaining() {
+    return this.v9() - this.w9() | 0;
+  }
+  function hasRemaining() {
+    return this.w9() < this.v9();
+  }
+  setMetadataFor(PositionBuffer, 'PositionBuffer', interfaceMeta);
+  function writeBytes(bytes) {
+    return this.ca(bytes, 0, bytes.length);
+  }
+  setMetadataFor(WriteBuffer, 'WriteBuffer', interfaceMeta, VOID, [PositionBuffer]);
+  setMetadataFor(JsBuffer, 'JsBuffer', classMeta, VOID, [WriteBuffer, PositionBuffer], VOID, VOID, VOID, [0]);
+  //endregion
+  function Heap() {
+    Heap_instance = this;
+    AllocationZone.call(this);
+  }
+  var Heap_instance;
+  function Heap_getInstance() {
+    if (Heap_instance == null)
+      new Heap();
+    return Heap_instance;
+  }
+  function SharedMemory() {
+  }
+  function Custom() {
+  }
+  function AllocationZone() {
+  }
+  var ByteOrder_BIG_ENDIAN_instance;
+  var ByteOrder_LITTLE_ENDIAN_instance;
+  var ByteOrder_entriesInitialized;
+  function ByteOrder_initEntries() {
+    if (ByteOrder_entriesInitialized)
+      return Unit_instance;
+    ByteOrder_entriesInitialized = true;
+    ByteOrder_BIG_ENDIAN_instance = new ByteOrder('BIG_ENDIAN', 0);
+    ByteOrder_LITTLE_ENDIAN_instance = new ByteOrder('LITTLE_ENDIAN', 1);
+  }
+  function ByteOrder(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  function ByteOrder_BIG_ENDIAN_getInstance() {
+    ByteOrder_initEntries();
+    return ByteOrder_BIG_ENDIAN_instance;
+  }
+  function ByteOrder_LITTLE_ENDIAN_getInstance() {
+    ByteOrder_initEntries();
+    return ByteOrder_LITTLE_ENDIAN_instance;
+  }
+  function Companion() {
+  }
+  var Companion_instance;
+  function Companion_getInstance() {
+    return Companion_instance;
+  }
+  function PositionBuffer() {
+  }
+  function WriteBuffer() {
+  }
+  function wrap(_this__u8e3s4, array, byteOrder) {
+    byteOrder = byteOrder === VOID ? ByteOrder_BIG_ENDIAN_getInstance() : byteOrder;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return new JsBuffer(array, byteOrder.equals(ByteOrder_LITTLE_ENDIAN_getInstance()));
+  }
+  function allocate(_this__u8e3s4, size, zone, byteOrder) {
+    zone = zone === VOID ? Heap_getInstance() : zone;
+    byteOrder = byteOrder === VOID ? ByteOrder_BIG_ENDIAN_getInstance() : byteOrder;
+    if (zone instanceof Custom) {
+      return zone.da_1(size);
+    }
+    var tmp;
+    try {
+      var tmp_0;
+      if (zone instanceof SharedMemory) {
+        tmp_0 = new SharedArrayBuffer(size);
+      } else {
+        tmp_0 = null;
+      }
+      tmp = tmp_0;
+    } catch ($p) {
+      var tmp_1;
+      if ($p instanceof Error) {
+        var t = $p;
+        tmp_1 = null;
+      } else {
+        throw $p;
+      }
+      tmp = tmp_1;
+    }
+    var sharedArrayBuffer = tmp;
+    var tmp_2;
+    if (sharedArrayBuffer == null) {
+      tmp_2 = zone instanceof SharedMemory;
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      console.warn('Failed to allocate shared buffer in BufferFactory.kt. Please check and validate the appropriate headers are set on the http request as defined in the SharedArrayBuffer MDN docs.see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer#security_requirements');
+    }
+    var tmp_3;
+    if (!(sharedArrayBuffer == null)) {
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      var arrayBuffer = sharedArrayBuffer.slice(0, size);
+      tmp_3 = new JsBuffer(new Uint8Array(arrayBuffer), byteOrder.equals(ByteOrder_LITTLE_ENDIAN_getInstance()), VOID, VOID, VOID, sharedArrayBuffer);
+    } else {
+      tmp_3 = new JsBuffer(new Uint8Array(size), byteOrder.equals(ByteOrder_LITTLE_ENDIAN_getInstance()));
+    }
+    return tmp_3;
+  }
+  function JsBuffer(buffer, littleEndian, position, limit, capacity, sharedArrayBuffer) {
+    littleEndian = littleEndian === VOID ? false : littleEndian;
+    position = position === VOID ? 0 : position;
+    limit = limit === VOID ? 0 : limit;
+    capacity = capacity === VOID ? buffer.byteLength : capacity;
+    sharedArrayBuffer = sharedArrayBuffer === VOID ? null : sharedArrayBuffer;
+    this.ea_1 = buffer;
+    this.fa_1 = littleEndian;
+    this.ga_1 = position;
+    this.ha_1 = limit;
+    this.ia_1 = capacity;
+    this.ja_1 = sharedArrayBuffer;
+    this.ka_1 = this.fa_1 ? ByteOrder_LITTLE_ENDIAN_getInstance() : ByteOrder_BIG_ENDIAN_getInstance();
+    this.ha_1 = this.ea_1.length;
+  }
+  protoOf(JsBuffer).la = function () {
+    return this.ia_1;
+  };
+  protoOf(JsBuffer).ma = function () {
+    var tmp = this.ea_1.buffer;
+    var tmp1 = this.ga_1;
+    this.ga_1 = tmp1 + 1 | 0;
+    var dataView = new DataView(tmp, tmp1, 1);
+    return dataView.getInt8(0);
+  };
+  protoOf(JsBuffer).t = function (index) {
+    var dataView = new DataView(this.ea_1.buffer, index, 1);
+    return dataView.getInt8(0);
+  };
+  protoOf(JsBuffer).na = function (size) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var byteArray = new Int8Array(this.ea_1.buffer, this.ga_1, size);
+    this.ga_1 = this.ga_1 + size | 0;
+    return byteArray;
+  };
+  protoOf(JsBuffer).aa = function (index, byte) {
+    var tmp = this.ea_1.buffer;
+    var dataView = new DataView(tmp, index, 1);
+    dataView.setInt8(0, byte);
+    return this;
+  };
+  protoOf(JsBuffer).ca = function (bytes, offset, length) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var uint8Array = bytes.subarray(offset, offset + length | 0);
+    this.ea_1.set(uint8Array, this.ga_1);
+    this.ga_1 = this.ga_1 + uint8Array.length | 0;
+    return this;
+  };
+  protoOf(JsBuffer).v9 = function () {
+    return this.ha_1;
+  };
+  protoOf(JsBuffer).w9 = function () {
+    return this.ga_1;
+  };
+  protoOf(JsBuffer).x9 = function (newPosition) {
+    this.ga_1 = newPosition;
+  };
+  protoOf(JsBuffer).equals = function (other) {
+    if (this === other)
+      return true;
+    if (other == null ? true : !(this.constructor == other.constructor))
+      return false;
+    if (!(other instanceof JsBuffer))
+      THROW_CCE();
+    if (!(this.fa_1 === other.fa_1))
+      return false;
+    if (!(this.ga_1 === other.ga_1))
+      return false;
+    if (!(this.ha_1 === other.ha_1))
+      return false;
+    if (!(this.ia_1 === other.ia_1))
+      return false;
+    var size = this.y9();
+    try {
+      if (!contentEquals(this.na(size), other.na(size)))
+        return false;
+    }finally {
+      this.ga_1 = this.ga_1 - size | 0;
+      other.ga_1 = other.ga_1 - size | 0;
+    }
+    return true;
+  };
+  protoOf(JsBuffer).hashCode = function () {
+    var result = getBooleanHashCode(this.fa_1);
+    result = imul(31, result) + this.ga_1 | 0;
+    result = imul(31, result) + this.ha_1 | 0;
+    result = imul(31, result) + this.ia_1 | 0;
+    var size = this.y9();
+    try {
+      result = imul(31, result) + hashCode(this.na(size)) | 0;
+    }finally {
+      this.ga_1 = this.ga_1 - size | 0;
+    }
+    return result;
+  };
+  protoOf(JsBuffer).toString = function () {
+    return 'JsBuffer(buffer=' + this.ea_1 + ', littleEndian=' + this.fa_1 + ', position=' + this.ga_1 + ', limit=' + this.ha_1 + ', capacity=' + this.ia_1 + ', sharedArrayBuffer=' + this.ja_1 + ')';
+  };
+  //region block: post-declaration
+  protoOf(JsBuffer).y9 = remaining;
+  protoOf(JsBuffer).z9 = hasRemaining;
+  protoOf(JsBuffer).ba = writeBytes;
+  //endregion
+  //region block: init
+  Companion_instance = new Companion();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = allocate;
+  _.$_$.b = wrap;
+  _.$_$.c = Companion_instance;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=buffer-kt.js.map

package/buffer-kt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../runner/work/buffer/buffer/src/commonMain/kotlin/com/ditchoom/buffer/PositionBuffer.kt","../../../../../../../../../../runner/work/buffer/buffer/src/commonMain/kotlin/com/ditchoom/buffer/WriteBuffer.kt","../../../../../../../../../../runner/work/buffer/buffer/src/commonMain/kotlin/com/ditchoom/buffer/AllocationZone.kt","../../../../../../../../../../runner/work/buffer/buffer/src/commonMain/kotlin/com/ditchoom/buffer/ByteOrder.kt","../../../../../../../../../../runner/work/buffer/buffer/src/commonMain/kotlin/com/ditchoom/buffer/PlatformBuffer.kt","../../../../../../../../../../runner/work/buffer/buffer/src/jsMain/kotlin/com/ditchoom/buffer/BufferFactory.kt","src/jsMainSources/libraries/stdlib/js/src/kotlin/dynamic.kt","../../../../../../../../../../runner/work/buffer/buffer/src/jsMain/kotlin/com/ditchoom/buffer/JsBuffer.kt"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":["remaining","hasRemaining","writeBytes","bytes","<init>","wrap","<this>","array","byteOrder","allocate","size","zone","t","sharedArrayBuffer","arrayBuffer","buffer","littleEndian","position","limit","capacity","<get-capacity>","readByte","dataView","get","index","readByteArray","byteArray","set","byte","offset","length","uint8Array","newPosition","equals","other","hashCode","result","toString"],"mappings":"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"}

package/dl-common-util.d.ts

@@ -1,76 +1,61 @@
 type Nullable<T> = T | null | undefined
-export declare namespace com.d10ng.common {
-    function toUnsignedInt(_this_: Int8Array): number;
-    function toUnsignedLong(_this_: Int8Array): any/* kotlin.Long */;
-    function toBinString(_this_: Int8Array, space?: boolean): string;
-    function toHexString(_this_: Int8Array, space?: boolean, uppercase?: boolean): string;
-    function indexOf(_this_: Int8Array, bs: Int8Array): number;
-    function fillLengthByByteArray(_this_: Int8Array, length: number, filler?: number, isInStart?: boolean, isForced?: boolean): Int8Array;
+export declare namespace com.d10ng.common.base {
+    function byteArrayToBinString(_this_: Int8Array, space?: boolean): string;
+    function byteArrayToHexString(_this_: Int8Array, space?: boolean, uppercase?: boolean): string;
+    function byteArrayToUnsignedInt(_this_: Int8Array): number;
+    function byteArrayToUnsignedLong(_this_: Int8Array): any/* kotlin.Long */;
+    function indexOfByteArray(_this_: Int8Array, bs: Int8Array): number;
+    function byteArrayPadStart(_this_: Int8Array, length: number, padByte?: number): Int8Array;
+    function byteArrayPadEnd(_this_: Int8Array, length: number, padByte?: number): Int8Array;
+    function byteArrayGetBitRange(_this_: Int8Array, start: number, length: number): Int8Array;
 }
-export declare namespace com.d10ng.common {
-    function toBinStringByByte(_this_: number): string;
-    function toHexStringByByte(_this_: number, uppercase?: boolean): string;
-    function toUnsignedIntByByte(_this_: number): number;
+export declare namespace com.d10ng.common.base {
+    function byteToBinString(_this_: number): string;
+    function byteToHexString(_this_: number, uppercase?: boolean): string;
+    function byteToUnsignedInt(_this_: number): number;
+    function byteGetBit(_this_: number, bitIndex: number): number;
 }
-export declare namespace com.d10ng.common {
-    function toByteArrayByCharArray(_this_: any /*CharArray*/): Int8Array;
+export declare namespace com.d10ng.common.base {
+    function binStringToByte(_this_: string): number;
+    function binStringToByteArray(_this_: string): Int8Array;
+    function hexStringToByte(_this_: string): number;
+    function hexStringToByteArray(_this_: string): Int8Array;
+    function getStringByteLength(_this_: string): number;
+    function getStringFirstUpperCase(_this_: string): string;
+    function stringToFullWidthString(_this_: string): string;
 }
-export declare namespace com.d10ng.common {
-    function encodeGBK(_this_: string): Int8Array;
-    function decodeGBK(_this_: Int8Array): string;
-    function encodeUTF8(_this_: string): Int8Array;
-    function decodeUTF8(_this_: Int8Array): string;
-    function encodeUnicode(_this_: string): Int8Array;
-    function encodeUnicodeString(_this_: string, isNeedU: boolean): string;
-    function decodeUnicodeByByteArray(_this_: Int8Array): string;
-    function decodeUnicode(_this_: string): string;
-    function encodeASCII(_this_: string): Int8Array;
-    function encodeASCIIString(_this_: string): string;
-    function decodeASCII(_this_: string): string;
-    function decodeASCIIByByteArray(_this_: Int8Array): string;
-}
-export declare namespace com.d10ng.common {
+export declare namespace com.d10ng.common.calculate {
     abstract class ChecksumType {
         private constructor();
-        static get AND(): com.d10ng.common.ChecksumType & {
+        static get AND(): com.d10ng.common.calculate.ChecksumType & {
             get name(): "AND";
             get ordinal(): 0;
         };
-        static get OR(): com.d10ng.common.ChecksumType & {
+        static get OR(): com.d10ng.common.calculate.ChecksumType & {
             get name(): "OR";
             get ordinal(): 1;
         };
-        static get XOR(): com.d10ng.common.ChecksumType & {
+        static get XOR(): com.d10ng.common.calculate.ChecksumType & {
             get name(): "XOR";
             get ordinal(): 2;
         };
-        static values(): Array<com.d10ng.common.ChecksumType>;
-        static valueOf(value: string): com.d10ng.common.ChecksumType;
+        static values(): Array<com.d10ng.common.calculate.ChecksumType>;
+        static valueOf(value: string): com.d10ng.common.calculate.ChecksumType;
         get name(): "AND" | "OR" | "XOR";
         get ordinal(): 0 | 1 | 2;
     }
-    function assertChecksum(_this_: Int8Array, type?: com.d10ng.common.ChecksumType): boolean;
-    function getChecksum(_this_: Int8Array, type?: com.d10ng.common.ChecksumType, start?: number, end?: number): number;
-    function addChecksum(_this_: Int8Array, type?: com.d10ng.common.ChecksumType): Int8Array;
-}
-export declare namespace com.d10ng.common {
-    function toStringByDouble(_this_: number, maxDecimalCount: number): string;
-}
-export declare namespace com.d10ng.common {
-    function toString(_this_: number, maxDecimalCount: number): string;
-}
-export declare namespace com.d10ng.common {
-    function takeHighByte(_this_: number): number;
-    function takeLowByte(_this_: number): number;
-    function toByteArray(_this_: number): Int8Array;
+    function assertChecksum(_this_: Int8Array, type?: com.d10ng.common.calculate.ChecksumType): boolean;
+    function getChecksum(_this_: Int8Array, type?: com.d10ng.common.calculate.ChecksumType, start?: number, length?: number): number;
+    function addChecksum(_this_: Int8Array, type?: com.d10ng.common.calculate.ChecksumType): Int8Array;
 }
-export declare namespace com.d10ng.common {
-    function toByteArrayByLong(_this_: any/* kotlin.Long */): Int8Array;
+export declare namespace com.d10ng.common.calculate {
+    function isDarkColor(color: string): boolean;
+    function getNextLevelColor(color: string, level: number): string;
+    function getMiddleColor(color1: string, color2: string, present: number): string;
+    function getRgbValueArrayFromHexColorString(str: string): Array<number>;
+    function getHexColorStringFromRgbValueArray(rgb: Array<number>): string;
 }
-export declare namespace com.d10ng.common {
-    function toPinYin(_this_: string, separator?: string): string;
-}
-export declare namespace com.d10ng.common {
+export declare namespace com.d10ng.common.calculate {
     function keepByRegexStr(_this_: string, regStr: string): string;
     function filterByRegexStr(_this_: string, regStr: string): string;
     function isIdCard(_this_: string): boolean;
@@ -83,14 +68,129 @@ export declare namespace com.d10ng.common {
     function isOnlyNumber(_this_: string): boolean;
     function isOnlyCode(_this_: string): boolean;
     function isOnlyChSymbol(_this_: string): boolean;
+    function isColor(_this_: string): boolean;
+}
+export declare namespace com.d10ng.common.coordinate {
+    class Coordinate {
+        constructor(lat?: number, lng?: number);
+        get lat(): number;
+        set lat(value: number);
+        get lng(): number;
+        set lng(value: number);
+        copy(lat?: number, lng?: number): com.d10ng.common.coordinate.Coordinate;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace com.d10ng.common.coordinate {
+    abstract class CoordinateSystemType {
+        private constructor();
+        static get WGS84(): com.d10ng.common.coordinate.CoordinateSystemType & {
+            get name(): "WGS84";
+            get ordinal(): 0;
+        };
+        static get GCJ02(): com.d10ng.common.coordinate.CoordinateSystemType & {
+            get name(): "GCJ02";
+            get ordinal(): 1;
+        };
+        static get BD09(): com.d10ng.common.coordinate.CoordinateSystemType & {
+            get name(): "BD09";
+            get ordinal(): 2;
+        };
+        static values(): Array<com.d10ng.common.coordinate.CoordinateSystemType>;
+        static valueOf(value: string): com.d10ng.common.coordinate.CoordinateSystemType;
+        get name(): "WGS84" | "GCJ02" | "BD09";
+        get ordinal(): 0 | 1 | 2;
+    }
+}
+export declare namespace com.d10ng.common.coordinate {
+    function convert(_this_: com.d10ng.common.coordinate.Coordinate, from: com.d10ng.common.coordinate.CoordinateSystemType, to: com.d10ng.common.coordinate.CoordinateSystemType): com.d10ng.common.coordinate.Coordinate;
+    function isEastLongitude(_this_: number): boolean;
+    function isNorthLatitude(_this_: number): boolean;
+    function toLongitudeNoPre(_this_: number): number;
+    function toLatitudeNoPre(_this_: number): number;
+    function toFullLongitude(_this_: number, isEast: boolean, isPositive?: boolean): number;
+    function toFullLatitude(_this_: number, isNorth: boolean, isPositive?: boolean): number;
+    function toDMS(_this_: number, isLongitude: boolean): com.d10ng.common.coordinate.DMS;
+    function toLatLng(_this_: com.d10ng.common.coordinate.DMS): number;
+    function toLatLngString(_this_: number, isLongitude: boolean, pattern?: string): string;
+    function toLongitudeString(_this_: number, pattern?: string): string;
+    function toLatitudeString(_this_: number, pattern?: string): string;
+    function toLatLngByString(_this_: string, pattern: string): number;
+    function toLongitude(_this_: string, pattern: string): number;
+    function toLatitude(_this_: string, pattern: string): number;
+    function ddmmpmmmm2LatLng(_this_: number): number;
+    function latLng2ddmmpmmmm(_this_: number): number;
+}
+export declare namespace com.d10ng.common.coordinate {
+    class DMS {
+        constructor(degrees?: number, minutes?: number, seconds?: number);
+        get degrees(): number;
+        set degrees(value: number);
+        get minutes(): number;
+        set minutes(value: number);
+        get seconds(): number;
+        set seconds(value: number);
+        toString(): string;
+        copy(degrees?: number, minutes?: number, seconds?: number): com.d10ng.common.coordinate.DMS;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace com.d10ng.common.coordinate {
+    class DistanceAndBearing {
+        constructor(distance?: number, initialBearing?: number, finalBearing?: number);
+        get distance(): number;
+        set distance(value: number);
+        get initialBearing(): number;
+        set initialBearing(value: number);
+        get finalBearing(): number;
+        set finalBearing(value: number);
+        copy(distance?: number, initialBearing?: number, finalBearing?: number): com.d10ng.common.coordinate.DistanceAndBearing;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+}
+export declare namespace com.d10ng.common.coordinate {
+    function getDistanceAndBearing(point1: com.d10ng.common.coordinate.Coordinate, point2: com.d10ng.common.coordinate.Coordinate): com.d10ng.common.coordinate.DistanceAndBearing;
+    function getDistanceOn2Points(point1: com.d10ng.common.coordinate.Coordinate, point2: com.d10ng.common.coordinate.Coordinate, highPrecision?: boolean): number;
+    function toRadians(degree: number): number;
+    function toDegrees(radian: number): number;
+    function isPointInCircle(point: com.d10ng.common.coordinate.Coordinate, center: com.d10ng.common.coordinate.Coordinate, radius: number): boolean;
+    function getAngleOn2Points(point1: com.d10ng.common.coordinate.Coordinate, point2: com.d10ng.common.coordinate.Coordinate, highPrecision?: boolean): number;
+    function getPointOn2Points(point1: com.d10ng.common.coordinate.Coordinate, point2: com.d10ng.common.coordinate.Coordinate, present: number): com.d10ng.common.coordinate.Coordinate;
+    function getTotalDistance(points: Array<com.d10ng.common.coordinate.Coordinate>): number;
+    function getPointsOnDistance(points: Array<com.d10ng.common.coordinate.Coordinate>, distance: number): Array<com.d10ng.common.coordinate.Coordinate>;
+    function compressTrack(points: Array<com.d10ng.common.coordinate.Coordinate>): Array<com.d10ng.common.coordinate.Coordinate>;
+    function getPointByBasePoint(point: com.d10ng.common.coordinate.Coordinate, distance: number, angle: number): com.d10ng.common.coordinate.Coordinate;
+    function getRandomPoint(point: com.d10ng.common.coordinate.Coordinate, radius: number): com.d10ng.common.coordinate.Coordinate;
+    function getNearPartsOnLine(point: com.d10ng.common.coordinate.Coordinate, line: Array<com.d10ng.common.coordinate.Coordinate>, offset?: number): Array<number>;
+    function getProjectionPointOnLinePart(point: com.d10ng.common.coordinate.Coordinate, part: Array<com.d10ng.common.coordinate.Coordinate>): com.d10ng.common.coordinate.Coordinate;
+    function getProjectionPointOnLine(point: com.d10ng.common.coordinate.Coordinate, line: Array<com.d10ng.common.coordinate.Coordinate>): com.d10ng.common.coordinate.Coordinate;
+    function getProjectionLineOnLineWithPoint(point: com.d10ng.common.coordinate.Coordinate, targetLine: Array<com.d10ng.common.coordinate.Coordinate>): Array<com.d10ng.common.coordinate.Coordinate>;
+    function getProjectionLineOnLineWithLine(line: Array<com.d10ng.common.coordinate.Coordinate>, targetLine: Array<com.d10ng.common.coordinate.Coordinate>, offset?: number): Array<com.d10ng.common.coordinate.Coordinate>;
+}
+export declare namespace com.d10ng.common.transform {
+    function encodeGBK(_this_: string): Int8Array;
+    function decodeGBK(_this_: Int8Array): string;
+    function encodeUTF8(_this_: string): Int8Array;
+    function decodeUTF8(_this_: Int8Array): string;
+    function encodeUnicode(_this_: string): Int8Array;
+    function encodeUnicodeString(_this_: string, isNeedU?: boolean): string;
+    function decodeUnicode(_this_: Int8Array): string;
+    function decodeUnicodeString(_this_: string): string;
+    function encodeASCII(_this_: string): Int8Array;
+    function encodeASCIIString(_this_: string): string;
+    function decodeASCII(_this_: Int8Array): string;
+    function decodeASCIIString(_this_: string): string;
+}
+export declare namespace com.d10ng.common.transform {
+    function toPinYin(_this_: string, separator?: string): string;
 }
-export declare namespace com.d10ng.common {
-    function toByteFromBin(_this_: string): number;
-    function toByteArrayFromBin(_this_: string): Int8Array;
-    function toByteFromHex(_this_: string): number;
-    function toByteArrayFromHex(_this_: string): Int8Array;
-    function fillLength(_this_: string, length: number, filler?: any/* kotlin.Char */, isInStart?: boolean, isForced?: boolean): string;
-    function getByteLength(_this_: string): number;
-    function getFirstUpperCase(_this_: string): string;
+export declare namespace com.d10ng.common.base {
+    function numberToString(_this_: any/* kotlin.Number */, maxDecimalCount: number): string;
+    function numberToByteArray(_this_: any/* kotlin.Number */, size?: number): Int8Array;
 }
-export as namespace dl_common_util;
+export as namespace com_github_D10NGYANG_DLCommonUtil;