initial commit of actions

github/codeql-action-v1/node_modules/mem/dist/index.d.ts

@@ -0,0 +1,116 @@
+declare type AnyFunction = (...arguments_: any) => any;
+interface CacheStorageContent<ValueType> {
+    data: ValueType;
+    maxAge: number;
+}
+interface CacheStorage<KeyType, ValueType> {
+    has: (key: KeyType) => boolean;
+    get: (key: KeyType) => CacheStorageContent<ValueType> | undefined;
+    set: (key: KeyType, value: CacheStorageContent<ValueType>) => void;
+    delete: (key: KeyType) => void;
+    clear?: () => void;
+}
+export interface Options<FunctionToMemoize extends AnyFunction, CacheKeyType> {
+    /**
+    Milliseconds until the cache expires.
+
+    @default Infinity
+    */
+    readonly maxAge?: number;
+    /**
+    Determines the cache key for storing the result based on the function arguments. By default, __only the first argument is considered__ and it only works with [primitives](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+    A `cacheKey` function can return any type supported by `Map` (or whatever structure you use in the `cache` option).
+
+    You can have it cache **all** the arguments by value with `JSON.stringify`, if they are compatible:
+
+    ```
+    import mem from 'mem';
+
+    mem(function_, {cacheKey: JSON.stringify});
+    ```
+
+    Or you can use a more full-featured serializer like [serialize-javascript](https://github.com/yahoo/serialize-javascript) to add support for `RegExp`, `Date` and so on.
+
+    ```
+    import mem from 'mem';
+    import serializeJavascript from 'serialize-javascript';
+
+    mem(function_, {cacheKey: serializeJavascript});
+    ```
+
+    @default arguments_ => arguments_[0]
+    @example arguments_ => JSON.stringify(arguments_)
+    */
+    readonly cacheKey?: (arguments_: Parameters<FunctionToMemoize>) => CacheKeyType;
+    /**
+    Use a different cache storage. Must implement the following methods: `.has(key)`, `.get(key)`, `.set(key, value)`, `.delete(key)`, and optionally `.clear()`. You could for example use a `WeakMap` instead or [`quick-lru`](https://github.com/sindresorhus/quick-lru) for a LRU cache.
+
+    @default new Map()
+    @example new WeakMap()
+    */
+    readonly cache?: CacheStorage<CacheKeyType, ReturnType<FunctionToMemoize>>;
+}
+/**
+[Memoize](https://en.wikipedia.org/wiki/Memoization) functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input.
+
+@param fn - Function to be memoized.
+
+@example
+```
+import mem from 'mem';
+
+let index = 0;
+const counter = () => ++index;
+const memoized = mem(counter);
+
+memoized('foo');
+//=> 1
+
+// Cached as it's the same argument
+memoized('foo');
+//=> 1
+
+// Not cached anymore as the arguments changed
+memoized('bar');
+//=> 2
+
+memoized('bar');
+//=> 2
+```
+*/
+export default function mem<FunctionToMemoize extends AnyFunction, CacheKeyType>(fn: FunctionToMemoize, { cacheKey, cache, maxAge, }?: Options<FunctionToMemoize, CacheKeyType>): FunctionToMemoize;
+/**
+@returns A [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.
+
+@example
+```
+import {memDecorator} from 'mem';
+
+class Example {
+    index = 0
+
+    @memDecorator()
+    counter() {
+        return ++this.index;
+    }
+}
+
+class ExampleWithOptions {
+    index = 0
+
+    @memDecorator({maxAge: 1000})
+    counter() {
+        return ++this.index;
+    }
+}
+```
+*/
+export declare function memDecorator<FunctionToMemoize extends AnyFunction, CacheKeyType>(options?: Options<FunctionToMemoize, CacheKeyType>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+Clear all cached data of a memoized function.
+
+@param fn - Memoized function.
+*/
+export declare function memClear(fn: AnyFunction): void;
+export {};

github/codeql-action-v1/node_modules/mem/dist/index.js

@@ -0,0 +1,114 @@
+import mimicFn from 'mimic-fn';
+import mapAgeCleaner from 'map-age-cleaner';
+const cacheStore = new WeakMap();
+/**
+[Memoize](https://en.wikipedia.org/wiki/Memoization) functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input.
+
+@param fn - Function to be memoized.
+
+@example
+```
+import mem from 'mem';
+
+let index = 0;
+const counter = () => ++index;
+const memoized = mem(counter);
+
+memoized('foo');
+//=> 1
+
+// Cached as it's the same argument
+memoized('foo');
+//=> 1
+
+// Not cached anymore as the arguments changed
+memoized('bar');
+//=> 2
+
+memoized('bar');
+//=> 2
+```
+*/
+export default function mem(fn, { cacheKey, cache = new Map(), maxAge, } = {}) {
+    if (typeof maxAge === 'number') {
+        mapAgeCleaner(cache);
+    }
+    const memoized = function (...arguments_) {
+        const key = cacheKey ? cacheKey(arguments_) : arguments_[0];
+        const cacheItem = cache.get(key);
+        if (cacheItem) {
+            return cacheItem.data; // eslint-disable-line @typescript-eslint/no-unsafe-return
+        }
+        const result = fn.apply(this, arguments_);
+        cache.set(key, {
+            data: result,
+            maxAge: maxAge ? Date.now() + maxAge : Number.POSITIVE_INFINITY,
+        });
+        return result; // eslint-disable-line @typescript-eslint/no-unsafe-return
+    };
+    mimicFn(memoized, fn, {
+        ignoreNonConfigurable: true,
+    });
+    cacheStore.set(memoized, cache);
+    return memoized;
+}
+/**
+@returns A [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods.
+
+@example
+```
+import {memDecorator} from 'mem';
+
+class Example {
+    index = 0
+
+    @memDecorator()
+    counter() {
+        return ++this.index;
+    }
+}
+
+class ExampleWithOptions {
+    index = 0
+
+    @memDecorator({maxAge: 1000})
+    counter() {
+        return ++this.index;
+    }
+}
+```
+*/
+export function memDecorator(options = {}) {
+    const instanceMap = new WeakMap();
+    return (target, propertyKey, descriptor) => {
+        const input = target[propertyKey]; // eslint-disable-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        if (typeof input !== 'function') {
+            throw new TypeError('The decorated value must be a function');
+        }
+        delete descriptor.value;
+        delete descriptor.writable;
+        descriptor.get = function () {
+            if (!instanceMap.has(this)) {
+                const value = mem(input, options);
+                instanceMap.set(this, value);
+                return value;
+            }
+            return instanceMap.get(this);
+        };
+    };
+}
+/**
+Clear all cached data of a memoized function.
+
+@param fn - Memoized function.
+*/
+export function memClear(fn) {
+    const cache = cacheStore.get(fn);
+    if (!cache) {
+        throw new TypeError('Can\'t clear a function that was not memoized!');
+    }
+    if (typeof cache.clear !== 'function') {
+        throw new TypeError('The cache Map can\'t be cleared!');
+    }
+    cache.clear();
+}