@ethlete/query 5.16.0 → 5.16.1

package/esm2022/lib/request/request.util.mjs

@@ -0,0 +1,252 @@
+import { invalidBaseRouteError, invalidRouteError, pathParamsMissingInRouteFunctionError } from '../logger';
+import { isSymfonyPagerfantaOutOfRangeError } from '../symfony';
+export const isNaN = (value) => typeof value === 'number' && Number.isNaN(value);
+export const isEmptyString = (value) => typeof value === 'string' && value.trim() === '';
+export const isRequestError = (error) => error instanceof Object && 'status' in error && 'statusText' in error && 'url' in error;
+export const buildRoute = (options) => {
+    if (options.base.endsWith('/')) {
+        throw invalidBaseRouteError(options.base);
+    }
+    let route = null;
+    if (typeof options.route === 'function') {
+        if (!options.pathParams) {
+            throw pathParamsMissingInRouteFunctionError(options.route({}));
+        }
+        route = options.route(options.pathParams);
+    }
+    else {
+        route = options.route ?? null;
+    }
+    if (route && !route.startsWith('/')) {
+        throw invalidRouteError(route);
+    }
+    if (options.queryParams) {
+        const queryString = buildQueryString(options.queryParams, options.queryParamConfig);
+        if (queryString) {
+            route = route ? `${route}?${queryString}` : `/?${queryString}`;
+        }
+    }
+    return `${options.base}${route ?? ''}`;
+};
+export const buildQueryString = (params, config) => {
+    const objectNotation = config?.objectNotation ?? 'bracket';
+    const writeArrayIndexes = config?.writeArrayIndexes ?? false;
+    const ignoredValues = config?.ignoredValues ?? [undefined, null, Infinity, -Infinity];
+    const ignoredValuesFns = config?.ignoredValuesFns ?? [isNaN, isEmptyString];
+    const queryParams = [];
+    function processValue(key, value) {
+        if (Array.isArray(value)) {
+            let currentFilteredIndex = 0;
+            for (const arrayValue of value) {
+                const nestedKey = writeArrayIndexes ? `${key}[${currentFilteredIndex}]` : `${key}[]`;
+                const didAddValue = processValue(nestedKey, arrayValue);
+                if (didAddValue) {
+                    currentFilteredIndex++;
+                }
+            }
+            return null;
+        }
+        else if (typeof value === 'object' && value !== null) {
+            for (const [objKey, val] of Object.entries(value)) {
+                const nestedKey = objectNotation === 'dot' ? `${key}.${objKey}` : `${key}[${objKey}]`;
+                processValue(nestedKey, val);
+            }
+            return null;
+        }
+        else {
+            if (ignoredValues.includes(value)) {
+                return false;
+            }
+            if (ignoredValuesFns.some((fn) => fn(value))) {
+                return false;
+            }
+            const encodedKey = encodeURIComponent(key);
+            const encodedValue = encodeURIComponent(value);
+            queryParams.push(`${encodedKey}=${encodedValue}`);
+            return true;
+        }
+    }
+    for (const [key, val] of Object.entries(params)) {
+        processValue(key, val);
+    }
+    return queryParams.length ? queryParams.join('&') : null;
+};
+export const extractExpiresInSeconds = (headers) => {
+    const cacheControl = headers['cache-control'];
+    const age = headers['age'];
+    const expires = headers['expires'];
+    // In seconds
+    let expiresIn = null;
+    let maxAge = null;
+    if (cacheControl?.includes('no-cache')) {
+        return null;
+    }
+    if (cacheControl?.includes('max-age')) {
+        const m = cacheControl.split('max-age=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    else if (cacheControl?.includes('s-maxage')) {
+        const m = cacheControl.split('s-maxage=')[1];
+        if (m) {
+            maxAge = parseInt(m);
+        }
+    }
+    if (maxAge && age) {
+        const ageSeconds = parseInt(age);
+        expiresIn = maxAge - ageSeconds;
+    }
+    else if (maxAge) {
+        expiresIn = maxAge / 2; // We assume the response is half way to its expiration
+    }
+    else if (expires) {
+        // Used by some apis to tell the response will never expire
+        // In this case we let the response expire after 1 hour
+        if (expires === '-1') {
+            expiresIn = 3600;
+        }
+        else {
+            const expiresDate = new Date(expires);
+            // check if the date is valid
+            if (expiresDate.toString() !== 'Invalid Date') {
+                expiresIn = Math.floor((expiresDate.getTime() - Date.now()) / 1000);
+            }
+        }
+    }
+    return expiresIn;
+};
+export const buildTimestampFromSeconds = (seconds) => {
+    if (seconds === null) {
+        return null;
+    }
+    return new Date(Date.now() + seconds * 1000).getTime();
+};
+export const serializeBody = (body) => {
+    if (body === null || body === undefined) {
+        return null;
+    }
+    if (body instanceof ArrayBuffer ||
+        body instanceof Blob ||
+        body instanceof FormData ||
+        body instanceof URLSearchParams ||
+        typeof body === 'string') {
+        return body;
+    }
+    if (typeof body === 'object' || typeof body === 'boolean' || Array.isArray(body)) {
+        return JSON.stringify(body);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return body.toString();
+};
+export const transformMethod = (config) => {
+    if (config.method === 'GQL_QUERY' || config.method === 'GQL_MUTATE') {
+        if (!config.transferVia) {
+            return 'POST';
+        }
+        return config.transferVia;
+    }
+    return config.method;
+};
+export const detectContentTypeHeader = (body) => {
+    // An empty body has no content type.
+    if (body === null) {
+        return null;
+    }
+    // FormData bodies rely on the browser's content type assignment.
+    if (body instanceof FormData) {
+        return null;
+    }
+    // Blobs usually have their own content type. If it doesn't, then
+    // no type can be inferred.
+    if (body instanceof Blob) {
+        return body.type || null;
+    }
+    // Array buffers have unknown contents and thus no type can be inferred.
+    if (body instanceof ArrayBuffer) {
+        return null;
+    }
+    // Technically, strings could be a form of JSON data, but it's safe enough
+    // to assume they're plain strings.
+    if (typeof body === 'string') {
+        return 'text/plain';
+    }
+    // Arrays, objects, boolean and numbers will be encoded as JSON.
+    if (typeof body === 'object' || typeof body === 'number' || typeof body === 'boolean') {
+        return 'application/json';
+    }
+    // No type could be inferred.
+    return null;
+};
+export const hasHeader = (headers, header) => {
+    return Object.keys(headers).some((key) => key.toLowerCase() === header.toLowerCase());
+};
+export const forEachHeader = (headers, callback) => {
+    Object.entries(headers).forEach(([key, value]) => {
+        callback(key, value);
+    });
+};
+export const parseAllXhrResponseHeaders = (xhr) => {
+    const headers = xhr.getAllResponseHeaders();
+    const parsedHeaders = {};
+    for (const line of headers.split('\n')) {
+        const index = line.indexOf(':');
+        if (index > 0) {
+            const name = line.slice(0, index);
+            const key = name.toLowerCase();
+            const value = line.slice(index + 1).trim();
+            parsedHeaders[key] = value;
+        }
+    }
+    return parsedHeaders;
+};
+export const getResponseUrl = (xhr) => {
+    if ('responseURL' in xhr && xhr.responseURL) {
+        return xhr.responseURL;
+    }
+    if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
+        return xhr.getResponseHeader('X-Request-URL');
+    }
+    return null;
+};
+export const shouldRetryRequest = (config) => {
+    const defaultRetryDelay = 1000 + 1000 * config.currentRetryCount;
+    if (config.currentRetryCount > 3) {
+        return { retry: false };
+    }
+    if (!isRequestError(config.error)) {
+        return { retry: false };
+    }
+    const { status, detail } = config.error;
+    // Retry on 5xx errors
+    if (status >= 500) {
+        // Don't retry if a requested page is out of range
+        if (isSymfonyPagerfantaOutOfRangeError(detail)) {
+            return { retry: false };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 408 or 425 errors
+    if (status === 408 /* HttpStatusCode.RequestTimeout */ || status === 425 /* HttpStatusCode.TooEarly */) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Retry on 429 errors
+    if (status === 429 /* HttpStatusCode.TooManyRequests */) {
+        const retryAfter = config.headers['retry-after'] ||
+            config.headers['Retry-After'] ||
+            config.headers['x-retry-after'] ||
+            config.headers['X-Retry-After'];
+        if (retryAfter) {
+            const delay = parseInt(retryAfter) * 1000;
+            return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };
+        }
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    // Code 0 usually means the internet connection is down. We retry in this case.
+    // It could also be a CORS issue but that should not be the case in production.
+    if (status === 0) {
+        return { retry: true, delay: defaultRetryDelay };
+    }
+    return { retry: false };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.util.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/request/request.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { invalidBaseRouteError, invalidRouteError, pathParamsMissingInRouteFunctionError } from '../logger';\nimport { AnyRoute } from '../query';\nimport { isSymfonyPagerfantaOutOfRangeError } from '../symfony';\nimport {\n  BuildQueryStringConfig,\n  Method,\n  PathParams,\n  QueryParams,\n  RequestError,\n  RequestHeaders,\n  RequestRetryFn,\n} from './request.types';\n\nexport const isNaN = (value: unknown): boolean => typeof value === 'number' && Number.isNaN(value);\nexport const isEmptyString = (value: unknown): boolean => typeof value === 'string' && value.trim() === '';\n\nexport const isRequestError = <T = unknown>(error: unknown): error is RequestError<T> =>\n  error instanceof Object && 'status' in error && 'statusText' in error && 'url' in error;\n\nexport const buildRoute = (options: {\n  base: string;\n  route: AnyRoute | null | undefined;\n  pathParams?: PathParams;\n  queryParams?: QueryParams;\n  queryParamConfig?: BuildQueryStringConfig;\n}) => {\n  if (options.base.endsWith('/')) {\n    throw invalidBaseRouteError(options.base);\n  }\n\n  let route: string | null = null;\n\n  if (typeof options.route === 'function') {\n    if (!options.pathParams) {\n      throw pathParamsMissingInRouteFunctionError(options.route({}));\n    }\n\n    route = options.route(options.pathParams);\n  } else {\n    route = options.route ?? null;\n  }\n\n  if (route && !route.startsWith('/')) {\n    throw invalidRouteError(route);\n  }\n\n  if (options.queryParams) {\n    const queryString = buildQueryString(options.queryParams, options.queryParamConfig);\n\n    if (queryString) {\n      route = route ? `${route}?${queryString}` : `/?${queryString}`;\n    }\n  }\n\n  return `${options.base}${route ?? ''}`;\n};\n\nexport const buildQueryString = (params: QueryParams, config?: BuildQueryStringConfig): string | null => {\n  const objectNotation = config?.objectNotation ?? 'bracket';\n  const writeArrayIndexes = config?.writeArrayIndexes ?? false;\n  const ignoredValues = config?.ignoredValues ?? [undefined, null, Infinity, -Infinity];\n  const ignoredValuesFns = config?.ignoredValuesFns ?? [isNaN, isEmptyString];\n\n  const queryParams: string[] = [];\n\n  function processValue(key: string, value: unknown) {\n    if (Array.isArray(value)) {\n      let currentFilteredIndex = 0;\n      for (const arrayValue of value) {\n        const nestedKey = writeArrayIndexes ? `${key}[${currentFilteredIndex}]` : `${key}[]`;\n\n        const didAddValue = processValue(nestedKey, arrayValue);\n\n        if (didAddValue) {\n          currentFilteredIndex++;\n        }\n      }\n\n      return null;\n    } else if (typeof value === 'object' && value !== null) {\n      for (const [objKey, val] of Object.entries(value)) {\n        const nestedKey = objectNotation === 'dot' ? `${key}.${objKey}` : `${key}[${objKey}]`;\n        processValue(nestedKey, val);\n      }\n\n      return null;\n    } else {\n      if (ignoredValues.includes(value)) {\n        return false;\n      }\n\n      if (ignoredValuesFns.some((fn) => fn(value))) {\n        return false;\n      }\n\n      const encodedKey = encodeURIComponent(key);\n      const encodedValue = encodeURIComponent(value as string);\n\n      queryParams.push(`${encodedKey}=${encodedValue}`);\n\n      return true;\n    }\n  }\n\n  for (const [key, val] of Object.entries(params)) {\n    processValue(key, val);\n  }\n\n  return queryParams.length ? queryParams.join('&') : null;\n};\n\nexport const extractExpiresInSeconds = (headers: RequestHeaders) => {\n  const cacheControl = headers['cache-control'];\n  const age = headers['age'];\n  const expires = headers['expires'];\n\n  // In seconds\n  let expiresIn: number | null = null;\n  let maxAge: number | null = null;\n\n  if (cacheControl?.includes('no-cache')) {\n    return null;\n  }\n\n  if (cacheControl?.includes('max-age')) {\n    const m = cacheControl.split('max-age=')[1];\n\n    if (m) {\n      maxAge = parseInt(m);\n    }\n  } else if (cacheControl?.includes('s-maxage')) {\n    const m = cacheControl.split('s-maxage=')[1];\n\n    if (m) {\n      maxAge = parseInt(m);\n    }\n  }\n\n  if (maxAge && age) {\n    const ageSeconds = parseInt(age);\n\n    expiresIn = maxAge - ageSeconds;\n  } else if (maxAge) {\n    expiresIn = maxAge / 2; // We assume the response is half way to its expiration\n  } else if (expires) {\n    // Used by some apis to tell the response will never expire\n    // In this case we let the response expire after 1 hour\n    if (expires === '-1') {\n      expiresIn = 3600;\n    } else {\n      const expiresDate = new Date(expires);\n\n      // check if the date is valid\n      if (expiresDate.toString() !== 'Invalid Date') {\n        expiresIn = Math.floor((expiresDate.getTime() - Date.now()) / 1000);\n      }\n    }\n  }\n\n  return expiresIn;\n};\n\nexport const buildTimestampFromSeconds = (seconds: number | null) => {\n  if (seconds === null) {\n    return null;\n  }\n\n  return new Date(Date.now() + seconds * 1000).getTime();\n};\n\nexport const serializeBody = (body: unknown): ArrayBuffer | URLSearchParams | Blob | FormData | string | null => {\n  if (body === null || body === undefined) {\n    return null;\n  }\n\n  if (\n    body instanceof ArrayBuffer ||\n    body instanceof Blob ||\n    body instanceof FormData ||\n    body instanceof URLSearchParams ||\n    typeof body === 'string'\n  ) {\n    return body as ArrayBuffer | URLSearchParams | Blob | FormData | string;\n  }\n\n  if (typeof body === 'object' || typeof body === 'boolean' || Array.isArray(body)) {\n    return JSON.stringify(body);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (body as any).toString();\n};\n\nexport const transformMethod = (config: { method: Method; transferVia?: 'GET' | 'POST' }) => {\n  if (config.method === 'GQL_QUERY' || config.method === 'GQL_MUTATE') {\n    if (!config.transferVia) {\n      return 'POST';\n    }\n\n    return config.transferVia;\n  }\n\n  return config.method;\n};\n\nexport const detectContentTypeHeader = (body: unknown) => {\n  // An empty body has no content type.\n  if (body === null) {\n    return null;\n  }\n  // FormData bodies rely on the browser's content type assignment.\n  if (body instanceof FormData) {\n    return null;\n  }\n  // Blobs usually have their own content type. If it doesn't, then\n  // no type can be inferred.\n  if (body instanceof Blob) {\n    return body.type || null;\n  }\n  // Array buffers have unknown contents and thus no type can be inferred.\n  if (body instanceof ArrayBuffer) {\n    return null;\n  }\n  // Technically, strings could be a form of JSON data, but it's safe enough\n  // to assume they're plain strings.\n  if (typeof body === 'string') {\n    return 'text/plain';\n  }\n\n  // Arrays, objects, boolean and numbers will be encoded as JSON.\n  if (typeof body === 'object' || typeof body === 'number' || typeof body === 'boolean') {\n    return 'application/json';\n  }\n  // No type could be inferred.\n  return null;\n};\n\nexport const hasHeader = (headers: RequestHeaders, header: string) => {\n  return Object.keys(headers).some((key) => key.toLowerCase() === header.toLowerCase());\n};\n\nexport const forEachHeader = (headers: RequestHeaders, callback: (value: string, key: string) => void) => {\n  Object.entries(headers).forEach(([key, value]) => {\n    callback(key, value);\n  });\n};\n\nexport const parseAllXhrResponseHeaders = (xhr: XMLHttpRequest) => {\n  const headers = xhr.getAllResponseHeaders();\n  const parsedHeaders: RequestHeaders = {};\n\n  for (const line of headers.split('\\n')) {\n    const index = line.indexOf(':');\n    if (index > 0) {\n      const name = line.slice(0, index);\n      const key = name.toLowerCase();\n      const value = line.slice(index + 1).trim();\n\n      parsedHeaders[key] = value;\n    }\n  }\n\n  return parsedHeaders;\n};\n\nexport const getResponseUrl = (xhr: XMLHttpRequest): string | null => {\n  if ('responseURL' in xhr && xhr.responseURL) {\n    return xhr.responseURL;\n  }\n  if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n    return xhr.getResponseHeader('X-Request-URL');\n  }\n  return null;\n};\n\nexport const shouldRetryRequest: RequestRetryFn = (config) => {\n  const defaultRetryDelay = 1000 + 1000 * config.currentRetryCount;\n\n  if (config.currentRetryCount > 3) {\n    return { retry: false };\n  }\n\n  if (!isRequestError(config.error)) {\n    return { retry: false };\n  }\n\n  const { status, detail } = config.error;\n\n  // Retry on 5xx errors\n  if (status >= 500) {\n    // Don't retry if a requested page is out of range\n    if (isSymfonyPagerfantaOutOfRangeError(detail)) {\n      return { retry: false };\n    }\n\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Retry on 408 or 425 errors\n  if (status === HttpStatusCode.RequestTimeout || status === HttpStatusCode.TooEarly) {\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Retry on 429 errors\n  if (status === HttpStatusCode.TooManyRequests) {\n    const retryAfter =\n      config.headers['retry-after'] ||\n      config.headers['Retry-After'] ||\n      config.headers['x-retry-after'] ||\n      config.headers['X-Retry-After'];\n\n    if (retryAfter) {\n      const delay = parseInt(retryAfter) * 1000;\n      return { retry: true, delay: Number.isNaN(delay) ? defaultRetryDelay : delay };\n    }\n\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  // Code 0 usually means the internet connection is down. We retry in this case.\n  // It could also be a CORS issue but that should not be the case in production.\n  if (status === 0) {\n    return { retry: true, delay: defaultRetryDelay };\n  }\n\n  return { retry: false };\n};\n\nexport const enum HttpStatusCode {\n  Unknown = 0,\n\n  Continue = 100,\n  SwitchingProtocols = 101,\n  Processing = 102,\n  EarlyHints = 103,\n\n  Ok = 200,\n  Created = 201,\n  Accepted = 202,\n  NonAuthoritativeInformation = 203,\n  NoContent = 204,\n  ResetContent = 205,\n  PartialContent = 206,\n  MultiStatus = 207,\n  AlreadyReported = 208,\n  ImUsed = 226,\n\n  MultipleChoices = 300,\n  MovedPermanently = 301,\n  Found = 302,\n  SeeOther = 303,\n  NotModified = 304,\n  UseProxy = 305,\n  Unused = 306,\n  TemporaryRedirect = 307,\n  PermanentRedirect = 308,\n\n  BadRequest = 400,\n  Unauthorized = 401,\n  PaymentRequired = 402,\n  Forbidden = 403,\n  NotFound = 404,\n  MethodNotAllowed = 405,\n  NotAcceptable = 406,\n  ProxyAuthenticationRequired = 407,\n  RequestTimeout = 408,\n  Conflict = 409,\n  Gone = 410,\n  LengthRequired = 411,\n  PreconditionFailed = 412,\n  PayloadTooLarge = 413,\n  UriTooLong = 414,\n  UnsupportedMediaType = 415,\n  RangeNotSatisfiable = 416,\n  ExpectationFailed = 417,\n  ImATeapot = 418,\n  MisdirectedRequest = 421,\n  UnprocessableEntity = 422,\n  Locked = 423,\n  FailedDependency = 424,\n  TooEarly = 425,\n  UpgradeRequired = 426,\n  PreconditionRequired = 428,\n  TooManyRequests = 429,\n  RequestHeaderFieldsTooLarge = 431,\n  UnavailableForLegalReasons = 451,\n\n  InternalServerError = 500,\n  NotImplemented = 501,\n  BadGateway = 502,\n  ServiceUnavailable = 503,\n  GatewayTimeout = 504,\n  HttpVersionNotSupported = 505,\n  VariantAlsoNegotiates = 506,\n  InsufficientStorage = 507,\n  LoopDetected = 508,\n  NotExtended = 510,\n  NetworkAuthenticationRequired = 511,\n}\n"]}

package/esm2022/lib/symfony/index.mjs

@@ -0,0 +1,3 @@
+export * from './symfony.types';
+export * from './symfony.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvc3ltZm9ueS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N5bWZvbnkudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9zeW1mb255LnV0aWxzJztcbiJdfQ==

package/esm2022/lib/symfony/symfony.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ltZm9ueS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2xpYi9zeW1mb255L3N5bWZvbnkudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBTdGF0dXNDb2RlIH0gZnJvbSAnLi4vcmVxdWVzdCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3ltZm9ueUVycm9yVHJhY2Uge1xuICBhcmdzOiBzdHJpbmdbXTtcbiAgY2xhc3M6IHN0cmluZztcbiAgZmlsZTogc3RyaW5nO1xuICBmdW5jdGlvbjogc3RyaW5nO1xuICBsaW5lOiBudW1iZXI7XG4gIG5hbWVzcGFjZTogc3RyaW5nO1xuICBzaG9ydF9jbGFzczogc3RyaW5nO1xuICB0eXBlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3ltZm9ueUVycm9yIHtcbiAgY2xhc3M6IHN0cmluZztcbiAgZGV0YWlsOiBzdHJpbmc7XG4gIHN0YXR1czogSHR0cFN0YXR1c0NvZGU7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIHRyYWNlOiBTeW1mb255RXJyb3JUcmFjZVtdO1xuICB0eXBlOiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/symfony/symfony.utils.mjs

@@ -0,0 +1,31 @@
+export const isSymfonyError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const symfonyError = error;
+    return (symfonyError.class !== undefined &&
+        symfonyError.detail !== undefined &&
+        symfonyError.status !== undefined &&
+        symfonyError.title !== undefined &&
+        symfonyError.trace !== undefined &&
+        symfonyError.type !== undefined);
+};
+export const isSymfonyPagerfantaOutOfRangeError = (error) => {
+    if (!isSymfonyError(error)) {
+        return false;
+    }
+    return error.class.startsWith('Pagerfanta') && error.class.endsWith('OutOfRangeCurrentPageException');
+};
+export const isSymfonyFormViolationListError = (error) => {
+    return typeof error === 'object' && error !== null && 'violations' in error;
+};
+export const isSymfonyListError = (error) => {
+    return (!!error &&
+        typeof error === 'object' &&
+        Array.isArray(error) &&
+        !!error.length &&
+        'message' in error[0] &&
+        'propertyPath' in error[0] &&
+        'invalidValue' in error[0]);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/data.utils.mjs

@@ -0,0 +1,138 @@
+import { Injector, assertInInjectionContext, computed, inject } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { computedTillTruthy, createDestroy } from '@ethlete/core';
+import { of, pairwise, startWith, switchMap, takeUntil, tap } from 'rxjs';
+import { extractQuery, filterQueryStates, isQuery, isQueryStateFailure, isQueryStateLoading, isQueryStateSuccess, } from '../query';
+export const addQueryContainerHandling = (obs, valueFn, config) => {
+    assertInInjectionContext(addQueryContainerHandling);
+    const { abortPrevious, abortOnDestroy, stopPreviousPolling } = config ?? {};
+    const injector = inject(Injector);
+    const destroy$ = createDestroy();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tNode = injector._tNode;
+    const componentId = tNode?.index ?? -1;
+    obs
+        .pipe(takeUntil(destroy$), startWith(null), pairwise(), tap(([prevQuery, currQuery]) => {
+        const cleanQuery = (q) => {
+            if (!q?._hasDependents() && ((abortPrevious === undefined && q?.canBeCached) || abortPrevious)) {
+                q?.abort();
+            }
+            if (!q?._hasDependents() &&
+                ((stopPreviousPolling === undefined && q?.canBeCached) || stopPreviousPolling) &&
+                q?.isPolling) {
+                q?.stopPolling();
+            }
+        };
+        if ((isQuery(prevQuery) || prevQuery === null) && (isQuery(currQuery) || currQuery === null)) {
+            prevQuery?._removeDependent(componentId);
+            currQuery?._addDependent(componentId);
+            cleanQuery(prevQuery);
+        }
+        else if ((Array.isArray(prevQuery) || prevQuery === null) &&
+            (Array.isArray(currQuery) || currQuery === null)) {
+            if (prevQuery) {
+                for (let i = 0; i < prevQuery.length; i++) {
+                    prevQuery[i]?._removeDependent(componentId);
+                }
+            }
+            if (currQuery) {
+                for (let i = 0; i < currQuery.length; i++) {
+                    currQuery[i]?._addDependent(componentId);
+                }
+            }
+            if (prevQuery) {
+                for (let i = 0; i < prevQuery.length; i++) {
+                    cleanQuery(prevQuery[i]);
+                }
+            }
+        }
+        else if ((isQuery(prevQuery) && Array.isArray(currQuery)) ||
+            (Array.isArray(prevQuery) && isQuery(currQuery))) {
+            throw new Error('Cannot mix queries and arrays of queries in the same query container.');
+        }
+    }))
+        .subscribe();
+    destroy$.subscribe(() => {
+        const query = valueFn();
+        const handleQuery = (q) => {
+            q?._removeDependent(componentId);
+            if (!q?._hasDependents() && ((q?.canBeCached && abortOnDestroy === undefined) || abortOnDestroy)) {
+                q?.abort();
+            }
+        };
+        if (isQuery(query)) {
+            handleQuery(query);
+        }
+        else if (Array.isArray(query)) {
+            for (const q of query) {
+                handleQuery(q);
+            }
+        }
+    });
+};
+export function toQuerySignal(source, options) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const s = toSignal(source, options);
+    addQueryContainerHandling(source, () => s(), options);
+    return s;
+}
+export function queryComputed(computation, options) {
+    const c = computed(computation, options);
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+/**
+ * Creates a signal that will only be reactive until the first query is created.
+ * All subsequent changes inside the computation will be ignored.
+ */
+export function queryComputedTillTruthy(computation, options) {
+    const c = computedTillTruthy(computed(computation, options));
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+export function queryArrayComputed(computation, options) {
+    const c = computed(computation, options);
+    const obs = toObservable(c, options);
+    addQueryContainerHandling(obs, () => c(), options);
+    return c;
+}
+export function toQuerySubject(source, options) {
+    const obs = toObservable(source, options);
+    addQueryContainerHandling(obs, () => source(), options);
+    return obs;
+}
+export function queryStateSignal(source, options) {
+    const { cacheResponse } = options ?? {};
+    return toSignal(toObservable(source).pipe(switchMap((q) => extractQuery(q)?.state$ ?? of(null)), switchMap((state) => {
+        if (cacheResponse) {
+            return of(state).pipe(filterQueryStates(["SUCCESS" /* QueryStateType.Success */, "FAILURE" /* QueryStateType.Failure */, "CANCELLED" /* QueryStateType.Cancelled */]));
+        }
+        return of(state);
+    })), {
+        initialValue: null,
+    });
+}
+export function queryStateResponseSignal(source, options) {
+    const s = queryStateSignal(source, options);
+    return computed(() => {
+        const state = s();
+        return isQueryStateSuccess(state) ? state.response : null;
+    });
+}
+export function queryStateErrorSignal(source) {
+    const s = queryStateSignal(source);
+    return computed(() => {
+        const state = s();
+        return isQueryStateFailure(state) ? state.error : null;
+    });
+}
+export function queryStateLoadingSignal(source) {
+    const s = queryStateSignal(source);
+    return computed(() => {
+        const state = s();
+        return isQueryStateLoading(state) ? state : null;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.utils.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/utils/data.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { CreateComputedOptions, Injector, Signal, assertInInjectionContext, computed, inject } from '@angular/core';\nimport { ToObservableOptions, ToSignalOptions, toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { computedTillTruthy, createDestroy } from '@ethlete/core';\nimport { Observable, Subscribable, of, pairwise, startWith, switchMap, takeUntil, tap } from 'rxjs';\nimport {\n  AnyQuery,\n  AnyQueryCollection,\n  QueryOf,\n  QueryState,\n  QueryStateType,\n  extractQuery,\n  filterQueryStates,\n  isQuery,\n  isQueryStateFailure,\n  isQueryStateLoading,\n  isQueryStateSuccess,\n} from '../query';\nimport { QueryDataOf } from '../query-creator';\n\nexport interface QueryContainerConfig {\n  /**\n   * If `true`, the previous query will be aborted when a new query is pushed into the container.\n   * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.\n   */\n  abortPrevious?: boolean;\n\n  /**\n   * If `true`, the query will be aborted when the container is destroyed.\n   * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.\n   */\n  abortOnDestroy?: boolean;\n\n  /**\n   * If `true`, the previous polling will be stopped when a new query is pushed into the container.\n   * @default true // Only if the query has no other dependents and the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.\n   */\n  stopPreviousPolling?: boolean;\n}\n\nexport interface QueryFilterConfig {\n  /**\n   * If `true`, the response will be cached until the next response is received or the query fails.\n   * @default false\n   */\n  cacheResponse?: boolean;\n}\n\nexport const addQueryContainerHandling = (\n  obs: Observable<AnyQuery | AnyQuery[] | null>,\n  valueFn: () => AnyQuery | AnyQuery[] | null | undefined,\n  config?: QueryContainerConfig,\n) => {\n  assertInInjectionContext(addQueryContainerHandling);\n\n  const { abortPrevious, abortOnDestroy, stopPreviousPolling } = config ?? {};\n\n  const injector = inject(Injector);\n  const destroy$ = createDestroy();\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const tNode = (injector as any)._tNode;\n  const componentId = tNode?.index ?? -1;\n\n  obs\n    .pipe(\n      takeUntil(destroy$),\n      startWith(null),\n      pairwise(),\n      tap(([prevQuery, currQuery]) => {\n        const cleanQuery = (q: AnyQuery | null | undefined) => {\n          if (!q?._hasDependents() && ((abortPrevious === undefined && q?.canBeCached) || abortPrevious)) {\n            q?.abort();\n          }\n\n          if (\n            !q?._hasDependents() &&\n            ((stopPreviousPolling === undefined && q?.canBeCached) || stopPreviousPolling) &&\n            q?.isPolling\n          ) {\n            q?.stopPolling();\n          }\n        };\n\n        if ((isQuery(prevQuery) || prevQuery === null) && (isQuery(currQuery) || currQuery === null)) {\n          prevQuery?._removeDependent(componentId);\n          currQuery?._addDependent(componentId);\n\n          cleanQuery(prevQuery);\n        } else if (\n          (Array.isArray(prevQuery) || prevQuery === null) &&\n          (Array.isArray(currQuery) || currQuery === null)\n        ) {\n          if (prevQuery) {\n            for (let i = 0; i < prevQuery.length; i++) {\n              prevQuery[i]?._removeDependent(componentId);\n            }\n          }\n\n          if (currQuery) {\n            for (let i = 0; i < currQuery.length; i++) {\n              currQuery[i]?._addDependent(componentId);\n            }\n          }\n\n          if (prevQuery) {\n            for (let i = 0; i < prevQuery.length; i++) {\n              cleanQuery(prevQuery[i]);\n            }\n          }\n        } else if (\n          (isQuery(prevQuery) && Array.isArray(currQuery)) ||\n          (Array.isArray(prevQuery) && isQuery(currQuery))\n        ) {\n          throw new Error('Cannot mix queries and arrays of queries in the same query container.');\n        }\n      }),\n    )\n    .subscribe();\n\n  destroy$.subscribe(() => {\n    const query = valueFn();\n\n    const handleQuery = (q: AnyQuery | null | undefined) => {\n      q?._removeDependent(componentId);\n\n      if (!q?._hasDependents() && ((q?.canBeCached && abortOnDestroy === undefined) || abortOnDestroy)) {\n        q?.abort();\n      }\n    };\n\n    if (isQuery(query)) {\n      handleQuery(query);\n    } else if (Array.isArray(query)) {\n      for (const q of query) {\n        handleQuery(q);\n      }\n    }\n  });\n};\n\nexport function toQuerySignal<T extends AnyQuery | null>(\n  source: Observable<T> | Subscribable<T>,\n): Signal<T | undefined>;\nexport function toQuerySignal<T extends AnyQuery | null>(\n  source: Observable<T> | Subscribable<T>,\n  options: ToSignalOptions & { initialValue?: undefined; requireSync?: false } & QueryContainerConfig,\n): Signal<T | undefined>;\nexport function toQuerySignal<T extends AnyQuery | null>(\n  source: Observable<T> | Subscribable<T>,\n  options: ToSignalOptions & { initialValue?: null; requireSync?: false } & QueryContainerConfig,\n): Signal<T | null>;\nexport function toQuerySignal<T extends AnyQuery | null>(\n  source: Observable<T> | Subscribable<T>,\n  options: ToSignalOptions & { initialValue?: undefined; requireSync: true } & QueryContainerConfig,\n): Signal<T>;\nexport function toQuerySignal<T extends AnyQuery | null, const U extends T>(\n  source: Observable<T> | Subscribable<T>,\n  options: ToSignalOptions & { initialValue: U; requireSync?: false } & QueryContainerConfig,\n): Signal<T | U>;\n\nexport function toQuerySignal<T extends AnyQuery | null, U = undefined>(\n  source: Observable<T> | Subscribable<T>,\n  options?: ToSignalOptions & { initialValue?: U } & QueryContainerConfig,\n): Signal<T | U> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const s = toSignal(source, options as any);\n\n  addQueryContainerHandling(source as Observable<T>, () => s() as T, options);\n\n  return s as Signal<T | U>;\n}\n\nexport function queryComputed<T extends AnyQuery | null>(\n  computation: () => T,\n  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,\n): Signal<T> {\n  const c = computed(computation, options);\n  const obs = toObservable(c, options);\n\n  addQueryContainerHandling(obs, () => c(), options);\n\n  return c;\n}\n\n/**\n * Creates a signal that will only be reactive until the first query is created.\n * All subsequent changes inside the computation will be ignored.\n */\nexport function queryComputedTillTruthy<T extends AnyQuery | null>(\n  computation: () => T,\n  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,\n): Signal<T | null> {\n  const c = computedTillTruthy(computed(computation, options));\n  const obs = toObservable(c, options);\n\n  addQueryContainerHandling(obs, () => c(), options);\n\n  return c;\n}\n\nexport function queryArrayComputed<T extends AnyQuery[] | null>(\n  computation: () => T,\n  options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions,\n): Signal<T> {\n  const c = computed(computation, options);\n  const obs = toObservable(c, options);\n\n  addQueryContainerHandling(obs, () => c(), options);\n\n  return c;\n}\n\nexport function toQuerySubject<T extends AnyQuery | null>(\n  source: Signal<T>,\n  options?: ToObservableOptions & QueryContainerConfig,\n): Observable<T> {\n  const obs = toObservable(source, options);\n\n  addQueryContainerHandling(obs, () => source(), options);\n\n  return obs;\n}\n\nexport function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(\n  source: T,\n  options?: QueryFilterConfig,\n) {\n  const { cacheResponse } = options ?? {};\n\n  return toSignal(\n    toObservable(source).pipe(\n      switchMap((q) => extractQuery(q)?.state$ ?? of(null)),\n      switchMap((state) => {\n        if (cacheResponse) {\n          return of(state).pipe(\n            filterQueryStates([QueryStateType.Success, QueryStateType.Failure, QueryStateType.Cancelled]),\n          );\n        }\n\n        return of(state);\n      }),\n    ),\n    {\n      initialValue: null,\n    },\n  ) as Signal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;\n}\n\nexport function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(\n  source: T,\n  options?: QueryFilterConfig,\n) {\n  const s = queryStateSignal(source, options);\n\n  return computed(() => {\n    const state = s();\n\n    return isQueryStateSuccess(state) ? state.response : null;\n  });\n}\n\nexport function queryStateErrorSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T) {\n  const s = queryStateSignal(source);\n\n  return computed(() => {\n    const state = s();\n\n    return isQueryStateFailure(state) ? state.error : null;\n  });\n}\n\nexport function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T) {\n  const s = queryStateSignal(source);\n\n  return computed(() => {\n    const state = s();\n\n    return isQueryStateLoading(state) ? state : null;\n  });\n}\n"]}

package/esm2022/lib/utils/deep-freeze.util.mjs

@@ -0,0 +1,17 @@
+export const deepFreeze = (object) => {
+    // check if object is actually an object or frozen
+    if (!object || typeof object !== 'object' || Object.isFrozen(object)) {
+        return object;
+    }
+    // Retrieve the property names defined on object
+    const propNames = Object.getOwnPropertyNames(object);
+    // Freeze properties before freezing self
+    for (const name of propNames) {
+        const value = object[name];
+        if (value && typeof value === 'object') {
+            deepFreeze(value);
+        }
+    }
+    return Object.freeze(object);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVlcC1mcmVlemUudXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2xpYi91dGlscy9kZWVwLWZyZWV6ZS51dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxDQUFvQyxNQUFTLEVBQUUsRUFBRTtJQUN6RSxrREFBa0Q7SUFDbEQsSUFBSSxDQUFDLE1BQU0sSUFBSSxPQUFPLE1BQU0sS0FBSyxRQUFRLElBQUksTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQ3JFLE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxnREFBZ0Q7SUFDaEQsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRXJELHlDQUF5QztJQUV6QyxLQUFLLE1BQU0sSUFBSSxJQUFJLFNBQVMsRUFBRSxDQUFDO1FBQzdCLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUUzQixJQUFJLEtBQUssSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUN2QyxVQUFVLENBQUMsS0FBVSxDQUFDLENBQUM7UUFDekIsQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDL0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IGRlZXBGcmVlemUgPSA8VCBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+PihvYmplY3Q6IFQpID0+IHtcbiAgLy8gY2hlY2sgaWYgb2JqZWN0IGlzIGFjdHVhbGx5IGFuIG9iamVjdCBvciBmcm96ZW5cbiAgaWYgKCFvYmplY3QgfHwgdHlwZW9mIG9iamVjdCAhPT0gJ29iamVjdCcgfHwgT2JqZWN0LmlzRnJvemVuKG9iamVjdCkpIHtcbiAgICByZXR1cm4gb2JqZWN0O1xuICB9XG5cbiAgLy8gUmV0cmlldmUgdGhlIHByb3BlcnR5IG5hbWVzIGRlZmluZWQgb24gb2JqZWN0XG4gIGNvbnN0IHByb3BOYW1lcyA9IE9iamVjdC5nZXRPd25Qcm9wZXJ0eU5hbWVzKG9iamVjdCk7XG5cbiAgLy8gRnJlZXplIHByb3BlcnRpZXMgYmVmb3JlIGZyZWV6aW5nIHNlbGZcblxuICBmb3IgKGNvbnN0IG5hbWUgb2YgcHJvcE5hbWVzKSB7XG4gICAgY29uc3QgdmFsdWUgPSBvYmplY3RbbmFtZV07XG5cbiAgICBpZiAodmFsdWUgJiYgdHlwZW9mIHZhbHVlID09PSAnb2JqZWN0Jykge1xuICAgICAgZGVlcEZyZWV6ZSh2YWx1ZSBhcyBUKTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gT2JqZWN0LmZyZWV6ZShvYmplY3QpO1xufTtcbiJdfQ==

package/esm2022/lib/utils/def.util.mjs

@@ -0,0 +1,8 @@
+/**
+ * Dummy function for providing types while not breaking inference.
+ * **This function always returns null.**
+ * @see https://github.com/microsoft/TypeScript/issues/26242
+ * @returns null
+ */
+export const def = () => null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmLnV0aWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvdXRpbHMvZGVmLnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsR0FBUyxFQUFFLENBQUMsSUFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRHVtbXkgZnVuY3Rpb24gZm9yIHByb3ZpZGluZyB0eXBlcyB3aGlsZSBub3QgYnJlYWtpbmcgaW5mZXJlbmNlLlxuICogKipUaGlzIGZ1bmN0aW9uIGFsd2F5cyByZXR1cm5zIG51bGwuKipcbiAqIEBzZWUgaHR0cHM6Ly9naXRodWIuY29tL21pY3Jvc29mdC9UeXBlU2NyaXB0L2lzc3Vlcy8yNjI0MlxuICogQHJldHVybnMgbnVsbFxuICovXG5leHBvcnQgY29uc3QgZGVmID0gPERhdGE+KCkgPT4gbnVsbCBhcyB1bmtub3duIGFzIERhdGE7XG4iXX0=

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,4 @@
+export * from './data.utils';
+export * from './deep-freeze.util';
+export * from './def.util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0YS51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL2RlZXAtZnJlZXplLnV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9kZWYudXRpbCc7XG4iXX0=