@cogeotiff/core 6.1.1 → 7.2.0

package/src/cog.tiff.image.ts

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiff } from './cog.tiff.js';
 import { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
 import { TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
@@ -56,27 +55,27 @@ export class CogTiffImage {
      *
      * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
      */
-    async init(loadGeoTags = false, l: LogType = null as any): Promise<void> {
+    async init(loadGeoTags = false): Promise<void> {
         const requiredTags = [
-            this.fetch(TiffTag.Compression, l),
-            this.fetch(TiffTag.ImageHeight, l),
-            this.fetch(TiffTag.ImageWidth, l),
-            this.fetch(TiffTag.ModelPixelScale, l),
-            this.fetch(TiffTag.ModelTiePoint, l),
-            this.fetch(TiffTag.ModelTransformation, l),
-            this.fetch(TiffTag.TileHeight, l),
-            this.fetch(TiffTag.TileWidth, l),
+            this.fetch(TiffTag.Compression),
+            this.fetch(TiffTag.ImageHeight),
+            this.fetch(TiffTag.ImageWidth),
+            this.fetch(TiffTag.ModelPixelScale),
+            this.fetch(TiffTag.ModelTiePoint),
+            this.fetch(TiffTag.ModelTransformation),
+            this.fetch(TiffTag.TileHeight),
+            this.fetch(TiffTag.TileWidth),
         ];
 
         if (loadGeoTags) {
-            requiredTags.push(this.fetch(TiffTag.GeoKeyDirectory, l));
-            requiredTags.push(this.fetch(TiffTag.GeoAsciiParams, l));
-            requiredTags.push(this.fetch(TiffTag.GeoDoubleParams, l));
+            requiredTags.push(this.fetch(TiffTag.GeoKeyDirectory));
+            requiredTags.push(this.fetch(TiffTag.GeoAsciiParams));
+            requiredTags.push(this.fetch(TiffTag.GeoDoubleParams));
         }
 
         await Promise.all(requiredTags);
         if (loadGeoTags) {
-            await this.loadGeoTiffTags(l);
+            await this.loadGeoTiffTags();
         }
     }
 
@@ -92,7 +91,7 @@ export class CogTiffImage {
     /**
      * Load and unpack the GeoKeyDirectory
      */
-    async loadGeoTiffTags(l: LogType): Promise<void> {
+    async loadGeoTiffTags(): Promise<void> {
         // Already loaded
         if (this.tagsGeoLoaded) return;
         const sourceTag = this.tags.get(TiffTag.GeoKeyDirectory);
@@ -103,9 +102,9 @@ export class CogTiffImage {
         if (!sourceTag.isReady && sourceTag instanceof CogTiffTagLazy) {
             // Load all the required keys
             await Promise.all([
-                this.fetch(TiffTag.GeoKeyDirectory, l),
-                this.fetch(TiffTag.GeoAsciiParams, l),
-                this.fetch(TiffTag.GeoDoubleParams, l),
+                this.fetch(TiffTag.GeoKeyDirectory),
+                this.fetch(TiffTag.GeoAsciiParams),
+                this.fetch(TiffTag.GeoDoubleParams),
             ]);
         }
         this.tagsGeoLoaded = true;
@@ -145,10 +144,10 @@ export class CogTiffImage {
      * Load a tag, if it is not currently loaded, fetch the required data for the tag.
      * @param tag tag to fetch
      */
-    public async fetch<T>(tag: TiffTag, l: LogType): Promise<T | null> {
+    public async fetch<T>(tag: TiffTag): Promise<T | null> {
         const sourceTag = this.tags.get(tag);
         if (sourceTag == null) return null;
-        if (CogTiffTag.isLazy(sourceTag)) return sourceTag.fetch(l) as any;
+        if (CogTiffTag.isLazy(sourceTag)) return sourceTag.fetch() as any;
         return sourceTag.value as T;
     }
 
@@ -342,14 +341,14 @@ export class CogTiffImage {
      * @param index tile index
      * @returns file offset of the specified tile
      */
-    protected async getTileOffset(index: number, l?: LogType): Promise<number> {
+    protected async getTileOffset(index: number): Promise<number> {
         const tileOffset = this.tileOffset;
         if (index < 0 || index > tileOffset.dataCount) {
             throw new Error(`Tile offset: ${index} out of range: 0 -> ${tileOffset.dataCount}`);
         }
 
         // Fetch only the part of the offsets that are needed
-        return tileOffset.getValueAt(index, l);
+        return tileOffset.getValueAt(index);
     }
 
     // Clamp the bounds of the output image to the size of the image, as sometimes the edge tiles are not full tiles
@@ -398,13 +397,12 @@ export class CogTiffImage {
     private async getBytes(
         offset: number,
         byteCount: number,
-        l?: LogType,
     ): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
         const mimeType = this.compression;
         if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
         if (byteCount === 0) return null;
 
-        await this.tif.source.loadBytes(offset, byteCount, l);
+        await this.tif.source.loadBytes(offset, byteCount);
         const bytes = this.tif.source.bytes(offset, byteCount);
 
         if (this.compression === TiffMimeType.JPEG) {
@@ -421,7 +419,7 @@ export class CogTiffImage {
      * @param x Tile x offset
      * @param y Tile y offset
      */
-    async getTile(x: number, y: number, l?: LogType): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
+    async getTile(x: number, y: number): Promise<{ mimeType: TiffMimeType; bytes: Uint8Array } | null> {
         const mimeType = this.compression;
         const size = this.size;
         const tiles = this.tileSize;
@@ -441,22 +439,46 @@ export class CogTiffImage {
         const totalTiles = nxTiles * nyTiles;
         if (idx >= totalTiles) throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
 
-        const { offset, imageSize } = await this.getTileSize(idx, l);
-        return this.getBytes(offset, imageSize, l);
+        const { offset, imageSize } = await this.getTileSize(idx);
+        return this.getBytes(offset, imageSize);
     }
 
-    protected async getTileSize(index: number, l?: LogType): Promise<{ offset: number; imageSize: number }> {
+    /**
+     * Does this tile exist in the tiff and does it actually have a value
+     *
+     * Sparse tiffs can have a lot of empty tiles, this checks to see if the tile actually has data.
+     *
+     * @param x Tile x offset
+     * @param y Tile y offset
+     * @returns if the tile exists and has data
+     */
+    async hasTile(x: number, y: number): Promise<boolean> {
+        const tiles = this.tileSize;
+        const size = this.size;
+
+        if (tiles == null) throw new Error('Tiff is not tiled');
+
+        // TODO support GhostOptionTileOrder
+        const nyTiles = Math.ceil(size.height / tiles.height);
+        const nxTiles = Math.ceil(size.width / tiles.width);
+        if (x >= nxTiles || y >= nyTiles) return false;
+        const idx = y * nxTiles + x;
+        const ret = await this.getTileSize(idx);
+        return ret.offset > 0;
+    }
+
+    protected async getTileSize(index: number): Promise<{ offset: number; imageSize: number }> {
         // GDAL optimizes tiles by storing the size of the tile in
         // the few bytes leading up to the tile
-        if (this.tif.options.tileLeaderByteSize) {
-            const offset = await this.getTileOffset(index, l);
+        const leaderBytes = this.tif.options.tileLeaderByteSize;
+        if (leaderBytes) {
+            const offset = await this.getTileOffset(index);
             // Sparse COG no data found
             if (offset === 0) return { offset: 0, imageSize: 0 };
 
-            const leaderBytes = this.tif.options.tileLeaderByteSize;
             // This fetch will generally load in the bytes needed for the image too
             // provided the image size is less than the size of a chunk
-            await this.tif.source.loadBytes(offset - leaderBytes, leaderBytes, l);
+            await this.tif.source.loadBytes(offset - leaderBytes, leaderBytes);
             return { offset, imageSize: this.tif.source.getUint(offset - leaderBytes, leaderBytes) };
         }
 
@@ -464,7 +486,7 @@ export class CogTiffImage {
         if (byteCounts == null) {
             throw new Error('No tile byte counts found');
         }
-        const [offset, imageSize] = await Promise.all([this.getTileOffset(index, l), byteCounts.getValueAt(index, l)]);
+        const [offset, imageSize] = await Promise.all([this.getTileOffset(index), byteCounts.getValueAt(index)]);
         return { offset, imageSize };
     }
 }

package/src/cog.tiff.ts

@@ -1,4 +1,4 @@
-import { ChunkSource, LogType } from '@chunkd/core';
+import { ChunkSource } from '@chunkd/core';
 import { CogTiffImage } from './cog.tiff.image.js';
 import { TiffEndian } from './const/tiff.endian.js';
 import { TiffTag } from './const/tiff.tag.id.js';
@@ -38,24 +38,24 @@ export class CogTiff {
      *
      * @param loadGeoKeys Whether to also initialize the GeoKeyDirectory
      */
-    init(loadGeoKeys = false, logger?: LogType): Promise<CogTiff> {
+    init(loadGeoKeys = false): Promise<CogTiff> {
         if (this._initPromise) return this._initPromise;
-        this._initPromise = this.doInit(loadGeoKeys, logger);
+        this._initPromise = this.doInit(loadGeoKeys);
         return this._initPromise;
     }
 
-    private async doInit(loadGeoKeys = false, logger?: LogType): Promise<CogTiff> {
+    private async doInit(loadGeoKeys = false): Promise<CogTiff> {
         if (this.isInitialized) return this;
         // Load the first few KB in, more loads will run as more data is required
-        await this.source.loadBytes(0, this.source.chunkSize, logger);
-        await this.fetchIfd(logger);
-        await Promise.all(this.images.map((c) => c.init(loadGeoKeys, logger)));
+        await this.source.loadBytes(0, this.source.chunkSize);
+        await this.fetchIfd();
+        await Promise.all(this.images.map((c) => c.init(loadGeoKeys)));
 
         this.isInitialized = true;
         return this;
     }
 
-    private async fetchIfd(logger?: LogType): Promise<void> {
+    private async fetchIfd(): Promise<void> {
         const view = this.cursor.seekTo(0);
         const endian = view.uint16();
         this.source.isLittleEndian = endian === TiffEndian.Little;
@@ -78,15 +78,9 @@ export class CogTiff {
 
         const ghostSize = nextOffsetIfd - this.cursor.currentOffset;
         // GDAL now stores metadata between the IFD inside a ghost storage area
-        if (ghostSize > 0 && ghostSize < 16 * 1024) {
-            logger?.debug(
-                { offset: toHexString(this.cursor.currentOffset), length: toHexString(ghostSize) },
-                'GhostOptions',
-            );
-            // this.options.process(this.source, view.currentOffset, ghostSize);
-        }
+        if (ghostSize > 0 && ghostSize < 16 * 1024) this.options.process(view.bytes(ghostSize));
 
-        return this.processIfd(nextOffsetIfd, logger);
+        return this.processIfd(nextOffsetIfd);
     }
 
     getImage(z: number): CogTiffImage {
@@ -135,38 +129,19 @@ export class CogTiff {
         return image.getTile(x, y);
     }
 
-    private async processIfd(offset: number, logger?: LogType): Promise<void> {
-        logger?.trace({ offset: toHexString(offset) }, 'NextImageOffset');
-
-        if (!this.source.hasBytes(offset, 4096)) {
-            await this.source.loadBytes(offset, 4096, logger);
-        }
-
-        const { image, nextOffset } = await this.readIfd(offset, logger);
+    private async processIfd(offset: number): Promise<void> {
+        const { image, nextOffset } = await this.readIfd(offset);
         this.images.push(image);
-        const size = image.size;
-        if (image.isTiled()) {
-            const tile = image.tileSize;
-            logger?.debug(
-                {
-                    ...size,
-                    tileWidth: tile.width,
-                    tileHeight: tile.height,
-                    tileCount: Math.ceil(size.width / tile.width),
-                },
-                'GotImage',
-            );
-        }
 
-        if (nextOffset) await this.processIfd(nextOffset, logger);
+        if (nextOffset) await this.processIfd(nextOffset);
     }
 
-    private async readIfd(offset: number, log?: LogType): Promise<{ nextOffset: number; image: CogTiffImage }> {
-        if (!this.source.hasBytes(offset, 1024)) await this.source.loadBytes(offset, this.source.chunkSize, log);
+    private async readIfd(offset: number): Promise<{ nextOffset: number; image: CogTiffImage }> {
+        if (!this.source.hasBytes(offset, 4096)) await this.source.loadBytes(offset, 4096);
+
         const view = this.cursor.seekTo(offset);
         const tagCount = view.offset();
         const byteStart = offset + this.ifdConfig.offset;
-        const logger = log?.child({ imageId: this.images.length });
         const tags: Map<TiffTag, CogTiffTagBase> = new Map();
 
         let pos = byteStart;
@@ -174,33 +149,7 @@ export class CogTiff {
             const tag = CogTiffTag.create(this, pos);
             pos += tag.size;
 
-            if (tag.name == null) {
-                logger?.error({ code: toHexString(tag.id) }, `IFDUnknown`);
-                continue;
-            }
-
-            if (!tag.isReady) {
-                logger?.trace(
-                    {
-                        offset: toHexString(pos - offset),
-                        code: toHexString(tag.id),
-                        tagName: tag.name,
-                        ptr: toHexString(tag.valuePointer),
-                    },
-                    'PartialReadIFD',
-                );
-            } else {
-                logger?.trace(
-                    {
-                        offset: toHexString(pos - offset),
-                        code: toHexString(tag.id),
-                        tagName: tag.name,
-                        value: Array.isArray(tag.value) ? `[${tag.value.length}]` : tag.value,
-                    },
-                    'ReadIFD',
-                );
-            }
-
+            if (tag.name == null) throw new Error('Unknown IFD Tag: ' + toHexString(tag.id));
             tags.set(tag.id, tag);
         }
 

package/src/const/tiff.mime.ts

@@ -5,9 +5,13 @@ export enum TiffMimeType {
     NONE = 'application/octet-stream',
     JPEG = 'image/jpeg',
     JP2 = 'image/jp2',
+    JPEGXL = 'image/jpegxl',
     WEBP = 'image/webp',
+    ZSTD = 'application/zstd',
     LZW = 'application/lzw',
     DEFLATE = 'application/deflate',
+    LZERC = 'application/lerc',
+    LZMA = 'application/x-lzma',
 }
 
 export const TiffCompression: { [key: number]: TiffMimeType } = {
@@ -16,6 +20,10 @@ export const TiffCompression: { [key: number]: TiffMimeType } = {
     6: TiffMimeType.JPEG,
     7: TiffMimeType.JPEG,
     8: TiffMimeType.DEFLATE,
+    34887: TiffMimeType.LZERC,
+    34925: TiffMimeType.LZMA,
     34712: TiffMimeType.JP2,
+    50000: TiffMimeType.ZSTD,
     50001: TiffMimeType.WEBP,
+    50002: TiffMimeType.JPEGXL,
 };

package/src/read/tag/__test__/tag.test.ts

@@ -10,7 +10,7 @@ o.spec('TiffTag', () => {
     const cogSourceFile = new TestFileChunkSource(path.join(dirName, '../../../../../data/rgba8_tiled.tiff'));
 
     o.beforeEach(() => {
-        cogSourceFile.chunks.clear();
+        (cogSourceFile.chunks as Map<unknown, unknown>).clear();
     });
 
     o('should load lazy tags', async () => {

package/src/read/tag/tiff.tag.base.ts

@@ -32,7 +32,6 @@ export abstract class CogTiffTagBase<T = unknown> {
 
         this.id = id;
         this.name = TiffTag[this.id];
-
         this.dataType = this.tiff.source.getUint16(offset + 2);
         this.dataCount = this.tiff.source.getUint(offset + 4, this.tiff.ifdConfig.pointer);
         this.dataTypeSize = getTiffTagSize(this.dataType);

package/src/read/tag/tiff.tag.lazy.ts

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiffTagBase } from './tiff.tag.base.js';
 
 export class CogTiffTagLazy<T> extends CogTiffTagBase<T> {
@@ -8,9 +7,9 @@ export class CogTiffTagLazy<T> extends CogTiffTagBase<T> {
         return this.value != null;
     }
 
-    async fetch(l?: LogType): Promise<T> {
+    async fetch(): Promise<T> {
         if (this.tiff.source.hasBytes(this.valuePointer, this.dataLength) === false) {
-            await this.tiff.source.loadBytes(this.valuePointer, this.dataLength, l);
+            await this.tiff.source.loadBytes(this.valuePointer, this.dataLength);
         }
         this.value = this.readValue();
         return this.value;

package/src/read/tag/tiff.tag.offset.ts

@@ -1,4 +1,3 @@
-import { LogType } from '@chunkd/core';
 import { CogTiff } from '../../cog.tiff.js';
 import { getTiffTagValueReader } from '../tiff.value.reader.js';
 import { CogTiffTagBase } from './tiff.tag.base.js';
@@ -27,8 +26,8 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
     }
 
     /** Load the entire index into memory */
-    async load(l: LogType): Promise<void> {
-        await this.tiff.source.loadBytes(this.valuePointer, this.dataLength, l);
+    async load(): Promise<void> {
+        await this.tiff.source.loadBytes(this.valuePointer, this.dataLength);
         this.readValue();
     }
 
@@ -47,7 +46,7 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
      * Read a specific value from the offset array
      * @param index index to read at
      */
-    async getValueAt(index: number, l?: LogType): Promise<number> {
+    async getValueAt(index: number): Promise<number> {
         if (this.loadedValues) return this.loadedValues[index];
 
         const dataSize = this.dataTypeSize;
@@ -55,7 +54,7 @@ export class CogTiffTagOffset extends CogTiffTagBase<number[]> {
         const convert = getTiffTagValueReader(this.dataType);
 
         if (!this.tiff.source.hasBytes(valueOffset, dataSize)) {
-            await this.tiff.source.loadBytes(valueOffset, dataSize, l);
+            await this.tiff.source.loadBytes(valueOffset, dataSize);
         }
         return convert(this.tiff.source, valueOffset) as number;
     }

package/src/read/tiff.gdal.ts

@@ -1,12 +1,5 @@
-import { ByteSize, ChunkSource } from '@chunkd/core';
-import { getReverseEnumValue } from '../util/util.enum.js';
-
-//   GDAL_STRUCTURAL_METADATA_SIZE: '000140 bytes',
-//   LAYOUT: 'IFDS_BEFORE_DATA',
-//   BLOCK_ORDER: 'ROW_MAJOR',
-//   BLOCK_LEADER: 'SIZE_AS_UINT4',
-//   BLOCK_TRAILER: 'LAST_4_BYTES_REPEATED',
-//   KNOWN_INCOMPATIBLE_EDITION: 'NO'
+import { ByteSize } from '@chunkd/core';
+import { CogTiff } from '../cog.tiff.js';
 
 export enum GhostOption {
     GDAL_STRUCTURAL_METADATA_SIZE = 'GDAL_STRUCTURAL_METADATA_SIZE',
@@ -25,16 +18,14 @@ export enum GhostOptionTileOrder {
 export enum GhostOptionTileLeader {
     uint32 = 'SIZE_AS_UINT4',
 }
-export const GhostOptionTileLeaderSize: { [key: string]: ByteSize } = {
-    uint32: ByteSize.UInt32,
-};
 
 /**
  * GDAL has made a ghost set of options for Tif files
  * this class represents the optimizations that can be used
  */
 export class CogTifGhostOptions {
-    options: Map<GhostOption, string> = new Map();
+    options: Map<string, string> = new Map();
+    source: CogTiff;
 
     /**
      * Has GDAL optimized this tif
@@ -51,61 +42,43 @@ export class CogTifGhostOptions {
         return this.options.get(GhostOption.KNOWN_INCOMPATIBLE_EDITION) === 'YES';
     }
 
-    private set(key: GhostOption, val: string): void {
-        this.options.set(key, val);
-    }
-
     /**
      * Load the ghost options from a source
-     * @param source Source to load from
-     * @param offset Byte offset to start reading
-     * @param length max number of bytes to read
+     * @param bytes the ghost header bytes
      */
-    process(source: ChunkSource, offset: number, length: number): void {
-        const chars: string[] = [];
-        for (let i = offset; i < offset + length; i++) {
-            const char = source.getUint8(i);
-            if (char === 0) continue;
-            chars.push(String.fromCharCode(char));
+    process(bytes: Uint8Array): void {
+        let key = '';
+        let value = '';
+        let setValue = false;
+        for (let i = 0; i < bytes.length; i++) {
+            const charCode = bytes[i];
+            if (charCode === 0) break;
+
+            const char = String.fromCharCode(charCode);
+            if (char === '\n') {
+                this.options.set(key.trim(), value.trim());
+                key = '';
+                value = '';
+                setValue = false;
+            } else if (char === '=') {
+                setValue = true;
+            } else {
+                if (setValue) value += char;
+                else key += char;
+            }
         }
-
-        const keyValPairs = chars
-            .join('')
-            .trim()
-            .split('\n')
-            .map((c) => c.split('='));
-
-        for (const [key, value] of keyValPairs) {
-            this.options.set(GhostOption[key as GhostOption], value);
-        }
-    }
-
-    private _getReverse<T>(e: Record<string, any>, key: GhostOption): T | null {
-        const opt = this.options.get(key);
-        if (opt == null) return null;
-        return getReverseEnumValue<T>(e, opt);
-    }
-
-    /**
-     * The ordering of tiles inside the tif
-     */
-    get tileOrder(): GhostOptionTileOrder | null {
-        return this._getReverse(GhostOptionTileOrder, GhostOption.BLOCK_ORDER);
-    }
-
-    /**
-     * Are tiles stored with the file size immediately before the tile
-     */
-    get tileLeader(): GhostOptionTileLeader | null {
-        return this._getReverse(GhostOptionTileLeader, GhostOption.BLOCK_LEADER);
     }
 
     /**
      * If the tile leader is set, how many bytes are allocated to the tile size
      */
     get tileLeaderByteSize(): ByteSize | null {
-        if (this.tileLeader == null) return null;
-        return GhostOptionTileLeaderSize[this.tileLeader];
+        switch (this.options.get(GhostOption.BLOCK_LEADER)) {
+            case GhostOptionTileLeader.uint32:
+                return ByteSize.UInt32;
+            default:
+                return null;
+        }
     }
 
     get isMaskInterleaved(): boolean {

package/build/util/util.enum.d.ts

@@ -1,6 +0,0 @@
-/**
- * Typescript enums do not allow for easy reverse lookup of keys
- * This hacks a reverse lookup key onto the enum
- */
-export declare function getReverseEnumValue<T>(e: Record<string, string>, value: string): T;
-//# sourceMappingURL=util.enum.d.ts.map

package/build/util/util.enum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.enum.d.ts","sourceRoot":"","sources":["../../src/util/util.enum.ts"],"names":[],"mappings":"AACA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAUlF"}

package/build/util/util.enum.js

@@ -1,17 +0,0 @@
-const REVERSE_ENUM_KEY = '__reverse';
-/**
- * Typescript enums do not allow for easy reverse lookup of keys
- * This hacks a reverse lookup key onto the enum
- */
-export function getReverseEnumValue(e, value) {
-    if (e[REVERSE_ENUM_KEY] == null) {
-        const reverse = {};
-        for (const key of Object.keys(e)) {
-            const val = e[key];
-            reverse[val] = key;
-        }
-        Object.defineProperty(e, REVERSE_ENUM_KEY, { enumerable: false, value: reverse, writable: false });
-    }
-    return e[REVERSE_ENUM_KEY][value];
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWwvdXRpbC5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sZ0JBQWdCLEdBQUcsV0FBVyxDQUFDO0FBQ3JDOzs7R0FHRztBQUNILE1BQU0sVUFBVSxtQkFBbUIsQ0FBSSxDQUF5QixFQUFFLEtBQWE7SUFDM0UsSUFBSSxDQUFDLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxJQUFJLEVBQUU7UUFDN0IsTUFBTSxPQUFPLEdBQXdCLEVBQUUsQ0FBQztRQUN4QyxLQUFLLE1BQU0sR0FBRyxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDOUIsTUFBTSxHQUFHLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ25CLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxHQUFHLENBQUM7U0FDdEI7UUFDRCxNQUFNLENBQUMsY0FBYyxDQUFDLENBQUMsRUFBRSxnQkFBZ0IsRUFBRSxFQUFFLFVBQVUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQztLQUN0RztJQUNELE9BQU8sQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsS0FBWSxDQUFRLENBQUM7QUFDcEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImNvbnN0IFJFVkVSU0VfRU5VTV9LRVkgPSAnX19yZXZlcnNlJztcbi8qKlxuICogVHlwZXNjcmlwdCBlbnVtcyBkbyBub3QgYWxsb3cgZm9yIGVhc3kgcmV2ZXJzZSBsb29rdXAgb2Yga2V5c1xuICogVGhpcyBoYWNrcyBhIHJldmVyc2UgbG9va3VwIGtleSBvbnRvIHRoZSBlbnVtXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRSZXZlcnNlRW51bVZhbHVlPFQ+KGU6IFJlY29yZDxzdHJpbmcsIHN0cmluZz4sIHZhbHVlOiBzdHJpbmcpOiBUIHtcbiAgICBpZiAoZVtSRVZFUlNFX0VOVU1fS0VZXSA9PSBudWxsKSB7XG4gICAgICAgIGNvbnN0IHJldmVyc2U6IFJlY29yZDxzdHJpbmcsIGFueT4gPSB7fTtcbiAgICAgICAgZm9yIChjb25zdCBrZXkgb2YgT2JqZWN0LmtleXMoZSkpIHtcbiAgICAgICAgICAgIGNvbnN0IHZhbCA9IGVba2V5XTtcbiAgICAgICAgICAgIHJldmVyc2VbdmFsXSA9IGtleTtcbiAgICAgICAgfVxuICAgICAgICBPYmplY3QuZGVmaW5lUHJvcGVydHkoZSwgUkVWRVJTRV9FTlVNX0tFWSwgeyBlbnVtZXJhYmxlOiBmYWxzZSwgdmFsdWU6IHJldmVyc2UsIHdyaXRhYmxlOiBmYWxzZSB9KTtcbiAgICB9XG4gICAgcmV0dXJuIGVbUkVWRVJTRV9FTlVNX0tFWV1bdmFsdWUgYXMgYW55XSBhcyBhbnk7XG59XG4iXX0=

package/src/util/util.enum.ts

@@ -1,16 +0,0 @@
-const REVERSE_ENUM_KEY = '__reverse';
-/**
- * Typescript enums do not allow for easy reverse lookup of keys
- * This hacks a reverse lookup key onto the enum
- */
-export function getReverseEnumValue<T>(e: Record<string, string>, value: string): T {
-    if (e[REVERSE_ENUM_KEY] == null) {
-        const reverse: Record<string, any> = {};
-        for (const key of Object.keys(e)) {
-            const val = e[key];
-            reverse[val] = key;
-        }
-        Object.defineProperty(e, REVERSE_ENUM_KEY, { enumerable: false, value: reverse, writable: false });
-    }
-    return e[REVERSE_ENUM_KEY][value as any] as any;
-}