@extra-memoize/memory-cache 0.2.8 → 0.2.10

package/README.md

@@ -7,11 +7,19 @@ yarn add @extra-memoize/memory-cache
 ```
 
 ## API
+### Cache
+```ts
+class Cache<T> implements ICache<T> {
+  clear(): void
+}
+```
+
 ### LRUCache
 ```ts
 class LRUCache<T> implements ICache<T> {
   constructor(limit: number)
 
+  delete(key: string): void
   clear(): void
 }
 ```

package/lib/es2015/caches/cache.d.ts

@@ -0,0 +1,8 @@
+import { ICache, State } from 'extra-memoize';
+export declare class Cache<T> implements ICache<T> {
+    private map;
+    set(key: string, value: T): void;
+    get(key: string): [State.Miss] | [State.Hit, T];
+    delete(key: string): void;
+    clear(): void;
+}

package/lib/es2015/caches/cache.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const extra_memoize_1 = require("extra-memoize");
+class Cache {
+    constructor() {
+        this.map = new Map();
+    }
+    set(key, value) {
+        this.map.set(key, value);
+    }
+    get(key) {
+        if (this.map.has(key)) {
+            return [extra_memoize_1.State.Hit, this.map.get(key)];
+        }
+        else {
+            return [extra_memoize_1.State.Miss];
+        }
+    }
+    delete(key) {
+        this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+exports.Cache = Cache;
+//# sourceMappingURL=cache.js.map

package/lib/es2015/caches/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/caches/cache.ts"],"names":[],"mappings":";;;AAAA,iDAA6C;AAE7C,MAAa,KAAK;IAAlB;QACU,QAAG,GAAG,IAAI,GAAG,EAAE,CAAA;IAqBzB,CAAC;IAnBC,GAAG,CAAC,GAAW,EAAE,KAAQ;QACvB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC1B,CAAC;IAED,GAAG,CAAC,GAAW;QACb,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACrB,OAAO,CAAC,qBAAK,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;SACtC;aAAM;YACL,OAAO,CAAC,qBAAK,CAAC,IAAI,CAAC,CAAA;SACpB;IACH,CAAC;IAED,MAAM,CAAC,GAAW;QAChB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAA;IAClB,CAAC;CACF;AAtBD,sBAsBC"}

package/lib/es2015/caches/index.d.ts

@@ -1,3 +1,4 @@
+export * from './cache';
 export * from './lru-cache';
 export * from './expirable-cache';
 export * from './expirable-cache-with-stale-while-revalidate';

package/lib/es2015/caches/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache"), exports);
 __exportStar(require("./lru-cache"), exports);
 __exportStar(require("./expirable-cache"), exports);
 __exportStar(require("./expirable-cache-with-stale-while-revalidate"), exports);

package/lib/es2015/caches/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/caches/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA2B;AAE3B,oDAAiC;AACjC,gFAA6D;AAC7D,wEAAqD;AACrD,mGAAgF;AAEhF,+CAA4B;AAC5B,2EAAwD;AACxD,mEAAgD;AAChD,8FAA2E"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/caches/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB;AAEvB,8CAA2B;AAE3B,oDAAiC;AACjC,gFAA6D;AAC7D,wEAAqD;AACrD,mGAAgF;AAEhF,+CAA4B;AAC5B,2EAAwD;AACxD,mEAAgD;AAChD,8FAA2E"}

package/lib/es2018/caches/cache.d.ts

@@ -0,0 +1,8 @@
+import { ICache, State } from 'extra-memoize';
+export declare class Cache<T> implements ICache<T> {
+    private map;
+    set(key: string, value: T): void;
+    get(key: string): [State.Miss] | [State.Hit, T];
+    delete(key: string): void;
+    clear(): void;
+}

package/lib/es2018/caches/cache.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const extra_memoize_1 = require("extra-memoize");
+class Cache {
+    constructor() {
+        this.map = new Map();
+    }
+    set(key, value) {
+        this.map.set(key, value);
+    }
+    get(key) {
+        if (this.map.has(key)) {
+            return [extra_memoize_1.State.Hit, this.map.get(key)];
+        }
+        else {
+            return [extra_memoize_1.State.Miss];
+        }
+    }
+    delete(key) {
+        this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+exports.Cache = Cache;
+//# sourceMappingURL=cache.js.map

package/lib/es2018/caches/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/caches/cache.ts"],"names":[],"mappings":";;;AAAA,iDAA6C;AAE7C,MAAa,KAAK;IAAlB;QACU,QAAG,GAAG,IAAI,GAAG,EAAE,CAAA;IAqBzB,CAAC;IAnBC,GAAG,CAAC,GAAW,EAAE,KAAQ;QACvB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IAC1B,CAAC;IAED,GAAG,CAAC,GAAW;QACb,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACrB,OAAO,CAAC,qBAAK,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;SACtC;aAAM;YACL,OAAO,CAAC,qBAAK,CAAC,IAAI,CAAC,CAAA;SACpB;IACH,CAAC;IAED,MAAM,CAAC,GAAW;QAChB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IACtB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAA;IAClB,CAAC;CACF;AAtBD,sBAsBC"}

package/lib/es2018/caches/index.d.ts

@@ -1,3 +1,4 @@
+export * from './cache';
 export * from './lru-cache';
 export * from './expirable-cache';
 export * from './expirable-cache-with-stale-while-revalidate';

package/lib/es2018/caches/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache"), exports);
 __exportStar(require("./lru-cache"), exports);
 __exportStar(require("./expirable-cache"), exports);
 __exportStar(require("./expirable-cache-with-stale-while-revalidate"), exports);

package/lib/es2018/caches/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/caches/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA2B;AAE3B,oDAAiC;AACjC,gFAA6D;AAC7D,wEAAqD;AACrD,mGAAgF;AAEhF,+CAA4B;AAC5B,2EAAwD;AACxD,mEAAgD;AAChD,8FAA2E"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/caches/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB;AAEvB,8CAA2B;AAE3B,oDAAiC;AACjC,gFAA6D;AAC7D,wEAAqD;AACrD,mGAAgF;AAEhF,+CAA4B;AAC5B,2EAAwD;AACxD,mEAAgD;AAChD,8FAA2E"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@extra-memoize/memory-cache",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "",
   "keywords": [],
   "files": [
     "lib",
-    "dist"
+    "src"
   ],
   "main": "lib/es2018/index.js",
   "types": "lib/es2018/index.d.ts",

package/src/caches/cache.ts

@@ -0,0 +1,25 @@
+import { ICache, State } from 'extra-memoize'
+
+export class Cache<T> implements ICache<T> {
+  private map = new Map()
+
+  set(key: string, value: T): void {
+    this.map.set(key, value)
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  delete(key: string): void {
+    this.map.delete(key)
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/caches/expirable-cache-with-stale-if-error.ts

@@ -0,0 +1,39 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleIfError<T> implements IStaleIfErrorCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(private timeToLive: number, private staleIfError: number) {
+    this.cache = new ExpirableCache(timeToLive + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleIfError, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/expirable-cache-with-stale-while-revalidate-and-stale-if-error.ts

@@ -0,0 +1,51 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleWhileRevalidateAndStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleWhileRevalidateAndStaleIfError<T> implements IStaleWhileRevalidateAndStaleIfErrorCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(
+    private timeToLive: number
+  , private staleWhileRevalidate: number
+  , private staleIfError: number
+  ) {
+    this.cache = new ExpirableCache(timeToLive + staleWhileRevalidate + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss]
+                  | [
+                    | State.Hit
+                    | State.StaleWhileRevalidate
+                    | State.StaleIfError
+                    , T
+                    ] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/expirable-cache-with-stale-while-revalidate.ts

@@ -0,0 +1,40 @@
+import { ExpirableCache } from './expirable-cache'
+import { IStaleWhileRevalidateCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class ExpirableCacheWithStaleWhileRevalidate<T> implements IStaleWhileRevalidateCache<T> {
+  private cache: ExpirableCache<IRecord<T>>
+
+  constructor(private timeToLive: number, private staleWhileRevalidate: number) {
+    this.cache = new ExpirableCache(timeToLive + staleWhileRevalidate)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleWhileRevalidate, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      if (this.isStaleWhileRevalidate(record)) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else {
+        return [State.Hit, record.value]
+      }
+    }
+  }
+
+  private isStaleWhileRevalidate(record: IRecord<T>): boolean {
+    return Date.now() - record.updatedAt > this.timeToLive
+        && Date.now() - record.updatedAt <= this.timeToLive + this.staleWhileRevalidate
+  }
+}

package/src/caches/expirable-cache.ts

@@ -0,0 +1,26 @@
+import { ExpirableMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class ExpirableCache<T> implements ICache<T> {
+  private map: ExpirableMap<string, T>
+
+  constructor(private timeToLive: number) {
+    this.map = new ExpirableMap()
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value, this.timeToLive)
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/caches/index.ts

@@ -0,0 +1,13 @@
+export * from './cache'
+
+export * from './lru-cache'
+
+export * from './expirable-cache'
+export * from './expirable-cache-with-stale-while-revalidate'
+export * from './expirable-cache-with-stale-if-error'
+export * from './expirable-cache-with-stale-while-revalidate-and-stale-if-error'
+
+export * from './tlru-cache'
+export * from './tlru-cache-with-stale-while-revalidate'
+export * from './tlru-cache-with-stale-if-error'
+export * from './tlru-cache-with-stale-while-revalidate-and-stale-if-error'

package/src/caches/lru-cache.ts

@@ -0,0 +1,26 @@
+import { LRUMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class LRUCache<T> implements ICache<T> {
+  private map: LRUMap<string, T> 
+
+  constructor(limit: number) {
+    this.map = new LRUMap(limit)
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value)
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/caches/tlru-cache-with-stale-if-error.ts

@@ -0,0 +1,43 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleIfError<T> implements IStaleIfErrorCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleIfError: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleIfError, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/tlru-cache-with-stale-while-revalidate-and-stale-if-error.ts

@@ -0,0 +1,52 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleWhileRevalidateAndStaleIfErrorCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleWhileRevalidateAndStaleIfError<T> implements IStaleWhileRevalidateAndStaleIfErrorCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleWhileRevalidate: number
+  , private staleIfError: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleWhileRevalidate + staleIfError)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss]
+                  | [
+                    | State.Hit
+                    | State.StaleWhileRevalidate
+                    | State.StaleIfError
+                    , T
+                    ] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      const elapsed = Date.now() - record.updatedAt
+      if (elapsed <= this.timeToLive) {
+        return [State.Hit, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else if (elapsed <= this.timeToLive + this.staleWhileRevalidate + this.staleIfError) {
+        return [State.StaleIfError, record.value]
+      } else {
+        // just in case
+        return [State.Miss]
+      }
+    }
+  }
+}

package/src/caches/tlru-cache-with-stale-while-revalidate.ts

@@ -0,0 +1,44 @@
+import { TLRUCache } from './tlru-cache'
+import { IStaleWhileRevalidateCache, State } from 'extra-memoize'
+
+interface IRecord<T> {
+  updatedAt: number
+  value: T
+}
+
+export class TLRUCacheWithStaleWhileRevalidate<T> implements IStaleWhileRevalidateCache<T> {
+  private cache: TLRUCache<IRecord<T>>
+
+  constructor(
+    limit: number
+  , private timeToLive: number
+  , private staleWhileRevalidate: number
+  ) {
+    this.cache = new TLRUCache(limit, timeToLive + staleWhileRevalidate)
+  }
+
+  set(key: string, value: T): void {
+    this.cache.set(key, {
+      value
+    , updatedAt: Date.now()
+    })
+  }
+
+  get(key: string): [State.Miss] | [State.Hit | State.StaleWhileRevalidate, T] {
+    const [state, record] = this.cache.get(key)
+    if (state === State.Miss) {
+      return [State.Miss]
+    } else {
+      if (this.isStaleWhileRevalidate(record)) {
+        return [State.StaleWhileRevalidate, record.value]
+      } else {
+        return [State.Hit, record.value]
+      }
+    }
+  }
+
+  isStaleWhileRevalidate(record: IRecord<T>): boolean {
+    return Date.now() - record.updatedAt > this.timeToLive
+        && Date.now() - record.updatedAt <= this.timeToLive + this.staleWhileRevalidate
+  }
+}

package/src/caches/tlru-cache.ts

@@ -0,0 +1,26 @@
+import { TLRUMap } from '@blackglory/structures'
+import { ICache, State } from 'extra-memoize'
+
+export class TLRUCache<T> implements ICache<T> {
+  private map: TLRUMap<string, T> 
+
+  constructor(limit: number, private timeToLive: number) {
+    this.map = new TLRUMap(limit)
+  }
+
+  set(key: string, value: T): void {
+    this.map.set(key, value, this.timeToLive)
+  }
+
+  get(key: string): [State.Miss] | [State.Hit, T] {
+    if (this.map.has(key)) {
+      return [State.Hit, this.map.get(key)!]
+    } else {
+      return [State.Miss]
+    }
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from '@caches'

package/CHANGELOG.md

@@ -1,42 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
-
-### [0.2.8](https://github.com/extra-memoize/memory-cache/compare/v0.2.7...v0.2.8) (2023-01-28)
-
-
-### Bug Fixes
-
-* dependencies ([814b9df](https://github.com/extra-memoize/memory-cache/commit/814b9df8512f4b4dc6470b1fa1ec1ed31dbd3f83))
-
-### [0.2.7](https://github.com/extra-memoize/memory-cache/compare/v0.2.6...v0.2.7) (2023-01-28)
-
-### [0.2.6](https://github.com/extra-memoize/memory-cache/compare/v0.2.5...v0.2.6) (2023-01-21)
-
-### [0.2.5](https://github.com/extra-memoize/memory-cache/compare/v0.2.4...v0.2.5) (2022-11-03)
-
-### [0.2.4](https://github.com/extra-memoize/memory-cache/compare/v0.2.3...v0.2.4) (2022-09-09)
-
-### [0.2.3](https://github.com/extra-memoize/memory-cache/compare/v0.2.2...v0.2.3) (2022-08-06)
-
-### [0.2.2](https://github.com/extra-memoize/memory-cache/compare/v0.2.1...v0.2.2) (2022-08-04)
-
-### [0.2.1](https://github.com/extra-memoize/memory-cache/compare/v0.2.0...v0.2.1) (2022-06-26)
-
-## [0.2.0](https://github.com/extra-memoize/memory-cache/compare/v0.1.0...v0.2.0) (2022-05-10)
-
-
-### ⚠ BREAKING CHANGES
-
-* use extra-memoize@0.6
-
-### Features
-
-* use extra-memoize@0.6 ([9e72236](https://github.com/extra-memoize/memory-cache/commit/9e72236114a1764166d479afe384193081c727b3))
-
-## 0.1.0 (2022-04-08)
-
-
-### Features
-
-* init ([5c4d170](https://github.com/extra-memoize/memory-cache/commit/5c4d170569bb5aec61987ebac77f770d45a6cff7))