json-as 1.3.0 → 1.3.1

package/assembly/serialize/index/arbitrary.ts

@@ -7,6 +7,7 @@ import { serializeInteger } from "./integer";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
 import { serializeString } from "./string";
+import { serializeDynamic } from "./typedarray";
 
 export function serializeArbitrary(src: JSON.Value): void {
   switch (src.type) {
@@ -60,6 +61,10 @@ export function serializeArbitrary(src: JSON.Value): void {
     case JSON.Types.Map:
       serializeMap(src.get<Map<string, JSON.Value>>());
       break;
+    case JSON.Types.TypedArray:
+    case JSON.Types.ArrayBuffer:
+      serializeDynamic(src.type, src.get<usize>());
+      break;
     default: {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
       const ptr = src.get<usize>();

package/assembly/serialize/index/typedarray.ts

@@ -1 +1,66 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { JSON } from "../..";
 export { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
+import { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";
+
+
+@inline export function serializeDynamic(type: u16, data: usize): void {
+  if (type == JSON.Types.ArrayBuffer) {
+    serializeArrayBufferUnsafe(data, changetype<OBJECT>(data - TOTAL_OVERHEAD).rtSize);
+  } else if (type == JSON.Types.TypedArray) {
+    const id = changetype<OBJECT>(data - TOTAL_OVERHEAD).rtId;
+    if (id == idof<Int8Array>()) {
+      serializeTypedArray<Int8Array>(changetype<Int8Array>(data));
+    } else if (id == idof<Uint8Array>()) {
+      serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
+    } else if (id == idof<Uint8ClampedArray>()) {
+      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+    } else if (id == idof<Int16Array>()) {
+      serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
+    } else if (id == idof<Uint16Array>()) {
+      serializeTypedArray<Uint16Array>(changetype<Uint16Array>(data));
+    } else if (id == idof<Int32Array>()) {
+      serializeTypedArray<Int32Array>(changetype<Int32Array>(data));
+    } else if (id == idof<Uint32Array>()) {
+      serializeTypedArray<Uint32Array>(changetype<Uint32Array>(data));
+    } else if (id == idof<Int64Array>()) {
+      serializeTypedArray<Int64Array>(changetype<Int64Array>(data));
+    } else if (id == idof<Uint64Array>()) {
+      serializeTypedArray<Uint64Array>(changetype<Uint64Array>(data));
+    } else if (id == idof<Float32Array>()) {
+      serializeTypedArray<Float32Array>(changetype<Float32Array>(data));
+    } else if (id == idof<Float64Array>()) {
+      serializeTypedArray<Float64Array>(changetype<Float64Array>(data));
+    } else if (changetype<Int8Array>(data) instanceof Int8Array) {
+      serializeTypedArray<Int8Array>(changetype<Int8Array>(data));
+    } else if (changetype<Uint8Array>(data) instanceof Uint8Array) {
+      serializeTypedArray<Uint8Array>(changetype<Uint8Array>(data));
+    } else if (changetype<Uint8ClampedArray>(data) instanceof Uint8ClampedArray) {
+      serializeTypedArray<Uint8ClampedArray>(changetype<Uint8ClampedArray>(data));
+    } else if (changetype<Int16Array>(data) instanceof Int16Array) {
+      serializeTypedArray<Int16Array>(changetype<Int16Array>(data));
+    } else if (changetype<Uint16Array>(data) instanceof Uint16Array) {
+      serializeTypedArray<Uint16Array>(changetype<Uint16Array>(data));
+    } else if (changetype<Int32Array>(data) instanceof Int32Array) {
+      serializeTypedArray<Int32Array>(changetype<Int32Array>(data));
+    } else if (changetype<Uint32Array>(data) instanceof Uint32Array) {
+      serializeTypedArray<Uint32Array>(changetype<Uint32Array>(data));
+    } else if (changetype<Int64Array>(data) instanceof Int64Array) {
+      serializeTypedArray<Int64Array>(changetype<Int64Array>(data));
+    } else if (changetype<Uint64Array>(data) instanceof Uint64Array) {
+      serializeTypedArray<Uint64Array>(changetype<Uint64Array>(data));
+    } else if (changetype<Float32Array>(data) instanceof Float32Array) {
+      serializeTypedArray<Float32Array>(changetype<Float32Array>(data));
+    } else if (changetype<Float64Array>(data) instanceof Float64Array) {
+      serializeTypedArray<Float64Array>(changetype<Float64Array>(data));
+    } else {
+      throw new Error("Unsupported typed array in JSON.Value");
+    }
+  }
+}
+
+
+@inline export function serializeArrayBuffer(data: ArrayBuffer): void {
+  const dataStart = changetype<usize>(data);
+  serializeArrayBufferUnsafe(dataStart, changetype<OBJECT>(dataStart - TOTAL_OVERHEAD).rtSize);
+}

package/assembly/serialize/simd/string.ts

@@ -2,6 +2,7 @@ import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 // @ts-expect-error: @lazy is a valid decorator
 @lazy const U00_MARKER = 13511005048209500;
 // @ts-expect-error: @lazy is a valid decorator
@@ -118,7 +119,7 @@ export function serializeString_SIMD(src: string): void {
       // unpaired high/low surrogate
       const dstIdx = bs.offset + laneIdx - 1;
       store<u32>(dstIdx, U_MARKER); // \u
-      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
       // memory.copy(dstIdx + 12, srcIdx + 1, 15 - laneIdx);
       store<v128>(dstIdx, load<v128>(srcIdx, 1), 12);
       bs.offset += 10;
@@ -181,15 +182,6 @@ export function serializeString_SIMD(src: string): void {
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
-
-// @ts-expect-error: @inline is a valid decorator
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}

package/assembly/serialize/simple/arbitrary.ts

@@ -7,6 +7,7 @@ import { serializeInteger } from "./integer";
 import { serializeMap } from "./map";
 import { serializeObject } from "./object";
 import { serializeString } from "./string";
+import { serializeDynamic } from "../index/typedarray";
 
 export function serializeArbitrary(src: JSON.Value): void {
   switch (src.type) {
@@ -63,6 +64,11 @@ export function serializeArbitrary(src: JSON.Value): void {
       serializeMap(src.get<Map<string, JSON.Value>>());
       break;
     }
+    case JSON.Types.TypedArray:
+    case JSON.Types.ArrayBuffer: {
+      serializeDynamic(src.type, src.get<usize>());
+      break;
+    }
     default: {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
       const ptr = src.get<usize>();

package/assembly/serialize/simple/string.ts

@@ -3,6 +3,7 @@ import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 import { serializeStruct } from "./struct";
 
 // @ts-ignore: decorator allowed
@@ -68,7 +69,7 @@ import { serializeStruct } from "./struct";
     // unpaired high/low surrogate
     bs.growSize(10);
     store<u32>(bs.offset, U_MARKER); // \u
-    store<u64>(bs.offset, load<u64>(changetype<usize>(code.toString(16))), 4);
+    store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
     bs.offset += 12;
     lastPtr = srcPtr;
     continue;
@@ -84,15 +85,6 @@ import { serializeStruct } from "./struct";
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
-
-// @ts-ignore: inline
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}

package/assembly/serialize/swar/string.ts

@@ -1,6 +1,7 @@
 import { bs, sc } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+import { u16_to_hex4_swar } from "../../util/swar";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 
 // @ts-expect-error: @lazy is a valid decorator
@@ -89,7 +90,7 @@ export function serializeString_SWAR(src: string): void {
       // unpaired high/low surrogate
       const dstIdx = bs.offset + laneIdx - 1;
       store<u32>(dstIdx, U_MARKER); // \u
-      store<u64>(dstIdx, load<u64>(changetype<usize>(code.toString(16))), 4);
+      store<u64>(dstIdx, u16_to_hex4_swar(code), 4);
       store<u64>(dstIdx, load<u64>(srcIdx, 1), 12);
       bs.offset += 10;
     } while (mask !== 0);
@@ -152,19 +153,10 @@ export function serializeString_SWAR(src: string): void {
 @inline function write_u_escape(code: u16): void {
   bs.growSize(10);
   store<u32>(bs.offset, U_MARKER); // "\u"
-  // write hex digits (lowercase, matches tests)
-  store<u16>(bs.offset + 4, hexNibble((code >> 12) & 0xf));
-  store<u16>(bs.offset + 6, hexNibble((code >> 8) & 0xf));
-  store<u16>(bs.offset + 8, hexNibble((code >> 4) & 0xf));
-  store<u16>(bs.offset + 10, hexNibble(code & 0xf));
+  store<u64>(bs.offset, u16_to_hex4_swar(code), 4);
   bs.offset += 12;
 }
 
-// @ts-expect-error: @inline is a valid decorator
-@inline function hexNibble(n: u16): u16 {
-  return n < 10 ? 48 + n : 87 + n;
-}
-
 // @ts-expect-error: @inline is a valid decorator
 @inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
   const lo = block & 0x00ff_00ff_00ff_00ff;

package/assembly/util/swar.ts

@@ -1,3 +1,23 @@
+/**
+ * Decode four lowercase ASCII hex digits packed into UTF-16 lanes into one `u16`.
+ *
+ * The input is a `u64` whose four 16-bit lanes each contain one ASCII hex code
+ * unit in the low byte:
+ *
+ * - lane 0: most-significant hex digit
+ * - lane 1: next hex digit
+ * - lane 2: next hex digit
+ * - lane 3: least-significant hex digit
+ *
+ * For example, `0x0034_0033_0032_0031` represents the UTF-16 string `"1234"`
+ * and decodes to `0x1234`.
+ *
+ * This helper assumes the digits are already valid lowercase hexadecimal
+ * characters in the ranges `0-9` or `a-f`.
+ *
+ * @param block Packed UTF-16 ASCII hex digits.
+ * @returns The decoded 16-bit value.
+ */
 // @ts-expect-error: @inline is a valid decorator
 @inline export function hex4_to_u16_swar(block: u64): u16 {
   // (c & 0xF) + 9 * (c >> 6)
@@ -5,3 +25,32 @@
 
   return <u16>(((block >> 0) << 12) | ((block >> 16) << 8) | ((block >> 32) << 4) | (block >> 48));
 }
+
+/**
+ * Encode one `u16` into four lowercase ASCII hex digits packed into UTF-16 lanes.
+ *
+ * The returned `u64` is laid out so it can be written directly as four UTF-16
+ * code units:
+ *
+ * - lane 0: most-significant hex digit
+ * - lane 1: next hex digit
+ * - lane 2: next hex digit
+ * - lane 3: least-significant hex digit
+ *
+ * Each lane stores the ASCII character in the low byte and zero in the high
+ * byte. For example, `0x1234` becomes `0x0034_0033_0032_0031`, which
+ * represents the UTF-16 string `"1234"`.
+ *
+ * This helper is the inverse of {@link hex4_to_u16_swar}.
+ *
+ * @param code The 16-bit value to encode.
+ * @returns Four packed UTF-16 ASCII hex digits.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function u16_to_hex4_swar(code: u16): u64 {
+  let block = (<u64>((code >> 12) & 0xf)) | ((<u64>((code >> 8) & 0xf)) << 16) | ((<u64>((code >> 4) & 0xf)) << 32) | ((<u64>(code & 0xf)) << 48);
+
+  const alphaMask = ((block + 0x0006_0006_0006_0006) >> 4) & 0x0001_0001_0001_0001;
+  block += 0x0030_0030_0030_0030 + alphaMask * 39;
+  return block;
+}

package/lib/as-bs.ts

@@ -3,7 +3,7 @@ import { heap } from "memory";
 
 // Buffer management constants
 const SHRINK_EVERY_N_MASK: usize = 255; // check every 256 outputs
-const MIN_BUFFER_SIZE: usize = 128;
+const MIN_BUFFER_SIZE: usize = 1024;
 
 // Exponential moving average smoothing factor (0.0 to 1.0)
 // Higher values = more responsive to recent sizes, lower = more stable
@@ -26,8 +26,8 @@ export namespace bs {
   /** Proposed size of output */
   export let stackSize: usize = 0;
 
-  let pauseOffset: usize = 0;
-  let pauseStackSize: usize = 0;
+  let pauseOffsets = new Array<usize>();
+  let pauseStackSizes = new Array<usize>();
 
   // Exponential moving average of output sizes for adaptive buffer sizing
   // This provides smoother adaptation than simple averaging
@@ -50,10 +50,9 @@ export namespace bs {
   // @ts-expect-error: @inline is a valid decorator
   @inline function renewBuffer(newSize: usize): void {
     const oldPtr = buffer;
+    const relOffset = offset - oldPtr;
     const newPtr = heap.realloc(oldPtr, newSize);
-    const delta = newPtr - oldPtr;
-    offset += delta;
-    if (pauseOffset != 0) pauseOffset += delta;
+    offset = newPtr + relOffset;
     buffer = newPtr;
     bufferSize = newSize;
   }
@@ -81,24 +80,13 @@ export namespace bs {
 
   export let cacheOutput: usize = 0;
   export let cacheOutputLen: usize = 0;
-
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function digestArena(): void {
-    if (cacheOutput === 0) return;
-    const len = cacheOutputLen;
-    proposeSize(<u32>len);
-    memory.copy(offset, cacheOutput, len);
-    offset += len;
-    bs.cacheOutput = 0;
-    bs.cacheOutputLen = 0;
-  }
   /**
    * Stores the state of the buffer, allowing further changes to be reset
    */
   // @ts-expect-error: @inline is a valid decorator
   @inline export function saveState(): void {
-    pauseOffset = offset;
-    pauseStackSize = stackSize;
+    pauseOffsets.push(offset - buffer);
+    pauseStackSizes.push(stackSize);
   }
 
   /**
@@ -107,19 +95,13 @@ export namespace bs {
    */
   // @ts-expect-error: @inline is a valid decorator
   @inline export function loadState(): void {
-    offset = pauseOffset;
-    stackSize = pauseStackSize;
-  }
-
-  /**
-   * Resets the buffer to the state it was in when `pause()` was called.
-   * This allows for changes made after the pause to be discarded.
-   */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function resetState(): void {
-    offset = pauseOffset;
-    stackSize = pauseStackSize;
-    pauseOffset = 0;
+    const length = pauseOffsets.length;
+    if (length == 0) return;
+    const index = length - 1;
+    offset = buffer + unchecked(pauseOffsets[index]);
+    stackSize = unchecked(pauseStackSizes[index]);
+    pauseOffsets.length = index;
+    pauseStackSizes.length = index;
   }
 
   /**
@@ -161,13 +143,28 @@ export namespace bs {
   // @ts-expect-error: @inline is a valid decorator
   @inline export function resize(newSize: u32): void {
     const oldPtr = buffer;
+    const relOffset = offset - oldPtr;
     const newPtr = heap.realloc(buffer, newSize);
-    const delta = newPtr - oldPtr;
-    if (pauseOffset != 0) pauseOffset += delta;
     buffer = newPtr;
     bufferSize = newSize;
-    offset = buffer;
-    stackSize = 0;
+    offset = buffer + relOffset;
+  }
+
+  /**
+   * Shrinks the buffer using the same adaptive sizing policy as normal output
+   * finalization. Keeps enough capacity for the recent typical output size while
+   * releasing clearly excess memory.
+   */
+  // @ts-expect-error: @inline is a valid decorator
+  @inline export function shrink(): void {
+    let next = typicalSize << 1;
+    if (next < MIN_BUFFER_SIZE) next = MIN_BUFFER_SIZE;
+    if (bufferSize > next) {
+      resize(u32(next));
+    } else {
+      offset = buffer;
+      stackSize = 0;
+    }
   }
 
   /**
@@ -176,13 +173,14 @@ export namespace bs {
    */
   // @ts-expect-error: @inline is a valid decorator
   @inline export function cpyOut<T>(): T {
-    if (pauseOffset == 0) {
+    if (pauseOffsets.length == 0) {
       const len = offset - buffer;
       // @ts-expect-error: __new is a runtime builtin
       const _out = __new(len, idof<T>());
       memory.copy(_out, buffer, len);
       return changetype<T>(_out);
     } else {
+      const pauseOffset = buffer + unchecked(pauseOffsets[pauseOffsets.length - 1]);
       const len = offset - pauseOffset;
       // @ts-expect-error: __new is a runtime builtin
       const _out = __new(len, idof<T>());
@@ -192,6 +190,59 @@ export namespace bs {
     }
   }
 
+  /**
+   * Copies the slice starting at a caller-provided relative buffer offset and restores
+   * `offset` back to that slice start.
+   *
+   * This is intended for deserializers that borrow `bs` as temporary scratch space and
+   * already know their local slice start as `bs.offset - bs.buffer`.
+   *
+   * Note: this restores only `offset`. Deserialization paths do not currently depend on
+   * `stackSize`, which is tracked for serialization growth heuristics.
+   */
+  // @ts-expect-error: @inline is a valid decorator
+  @inline export function sliceOut<T>(start: usize): T {
+    const sliceStart = buffer + start;
+    const len = offset - sliceStart;
+    // @ts-expect-error: __new is a runtime builtin
+    const _out = __new(len, idof<T>());
+    memory.copy(_out, sliceStart, len);
+    offset = sliceStart;
+    return changetype<T>(_out);
+  }
+
+  /**
+   * Copies the slice starting at a caller-provided relative buffer offset into a string field
+   * and restores `offset` back to that slice start.
+   */
+  // @ts-expect-error: @inline is a valid decorator
+  @inline export function toField(start: usize, dstFieldPtr: usize): void {
+    const sliceStart = buffer + start;
+    const byteLength = <u32>(offset - sliceStart);
+    if (byteLength == 0) {
+      store<usize>(dstFieldPtr, changetype<usize>(""));
+      offset = sliceStart;
+      return;
+    }
+
+    const current = load<usize>(dstFieldPtr);
+    let stringPtr: usize;
+    if (current != 0 && changetype<OBJECT>(current - TOTAL_OVERHEAD).rtSize == byteLength) {
+      stringPtr = current;
+    } else if (current != 0 && current != changetype<usize>("")) {
+      // @ts-expect-error: __renew is a runtime builtin
+      stringPtr = __renew(current, byteLength);
+      store<usize>(dstFieldPtr, stringPtr);
+    } else {
+      // @ts-expect-error: __new is a runtime builtin
+      stringPtr = __new(byteLength, idof<string>());
+      store<usize>(dstFieldPtr, stringPtr);
+    }
+
+    memory.copy(stringPtr, sliceStart, byteLength);
+    offset = sliceStart;
+  }
+
   /**
    * Copies the buffer's content to a new object of a specified type.
    * Uses exponential moving average to track typical output sizes for
@@ -220,38 +271,6 @@ export namespace bs {
     }
     return changetype<T>(out);
   }
-
-  /**
-   * Copies the buffer's content to a new object of a specified type.
-   * @returns The new object containing the buffer's content.
-   */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function view<T>(): T {
-    const len = offset - buffer;
-    // @ts-expect-error: __new is a runtime builtin
-    const _out = __new(len, idof<T>());
-    memory.copy(_out, buffer, len);
-    return changetype<T>(_out);
-  }
-
-  /**
-   * Copies the buffer's content to a given destination pointer.
-   * Uses exponential moving average for adaptive buffer sizing.
-   * @param dst - The destination pointer.
-   * @returns The destination pointer cast to the specified type.
-   */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function outTo<T>(dst: usize): T {
-    const len = offset - buffer;
-    if (len != changetype<OBJECT>(dst - TOTAL_OVERHEAD).rtSize) {
-      // @ts-expect-error: __renew is a runtime builtin
-      dst = __renew(dst, len);
-    }
-    memory.copy(dst, buffer, len);
-
-    finalizeDynamicOutput(len);
-    return changetype<T>(dst);
-  }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -41,6 +41,24 @@
   ],
   "description": "The only JSON library you'll need for AssemblyScript with SIMD and SWAR",
   "homepage": "https://github.com/JairusSW/json-as#readme",
+  "files": [
+    "assembly/custom/",
+    "assembly/deserialize/",
+    "assembly/globals/",
+    "assembly/serialize/",
+    "assembly/util/",
+    "assembly/index.ts",
+    "assembly/index.d.ts",
+    "assembly/types.ts",
+    "assembly/tsconfig.json",
+    "lib/as-bs.ts",
+    "transform/lib/",
+    "transform/package.json",
+    "index.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "keywords": [
     "assemblyscript",
     "json",

package/transform/lib/index.d.ts

@@ -13,6 +13,7 @@ export declare class JSONTransform extends Visitor {
     imports: ImportStatement[];
     simdStatements: string[];
     visitedClasses: Set<string>;
+    private collectInheritedFieldMembers;
     visitClassDeclarationRef(node: ClassDeclaration): void;
     resolveType(type: string, source: Src, visited?: Set<string>): string;
     visitClassDeclaration(node: ClassDeclaration): void;

package/transform/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAA4G,eAAe,EAA8G,MAAM,EAAE,OAAO,EAAS,MAAM,EAA6C,MAAM,uCAAuC,CAAC;AAC3X,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAK7D,OAAO,EAA2B,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA2BvC,qBAAa,aAAc,SAAQ,OAAO;IACxC,MAAM,CAAC,EAAE,EAAE,aAAa,CAAuB;IAExC,OAAO,EAAG,OAAO,CAAC;IAClB,OAAO,EAAG,MAAM,CAAC;IACjB,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAA+B;IAC7D,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,CAAmB;IACrC,OAAO,EAAE,eAAe,EAAE,CAAM;IAChC,cAAc,EAAE,MAAM,EAAE,CAAM;IAE9B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAqB;IAEvD,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAYtD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,cAAoB,GAAG,MAAM;IAsC3E,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAowCnD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAItC,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA6ClD,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAIjD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI/B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAiH9B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,OAAe,GAAG,MAAM,EAAE;IA0BxD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO;CAc3D;AA4BD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,SAAS;IAChD,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBvD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAwDjC;AAoKD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAA4G,eAAe,EAA8G,MAAM,EAAE,OAAO,EAAS,MAAM,EAA6C,MAAM,uCAAuC,CAAC;AAC3X,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAK7D,OAAO,EAA2B,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAkFvC,qBAAa,aAAc,SAAQ,OAAO;IACxC,MAAM,CAAC,EAAE,EAAE,aAAa,CAAuB;IAExC,OAAO,EAAG,OAAO,CAAC;IAClB,OAAO,EAAG,MAAM,CAAC;IACjB,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAA+B;IAC7D,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,CAAmB;IACrC,OAAO,EAAE,eAAe,EAAE,CAAM;IAChC,cAAc,EAAE,MAAM,EAAE,CAAM;IAE9B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAqB;IAEvD,OAAO,CAAC,4BAA4B;IA6CpC,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAYtD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,cAAoB,GAAG,MAAM;IAsC3E,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA0yCnD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAItC,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA6ClD,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAIjD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI/B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAuG9B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,OAAe,GAAG,MAAM,EAAE;IA0BxD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO;CAc3D;AA4BD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,SAAS;IAChD,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBvD,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAwDjC;AAoKD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9C"}