@gcmdev/faxios 0.1.0 → 0.2.1

package/src/lib/core/FaxiosHeaders.ts

@@ -0,0 +1,529 @@
+// @ts-self-types="./FaxiosHeaders.d.ts" — required for Deno: types.d.ts imports FaxiosHeadersInstance from here
+"use strict";
+
+import parseHeaders from "../helpers/parseHeaders.js";
+import { sanitizeHeaderValue } from "../helpers/sanitizeHeaderValue.js";
+import type { FaxiosHeaderValue } from "../types.js";
+import utils from "../utils.js";
+
+const $internals = Symbol("internals");
+
+type HeaderMatcher =
+  | string
+  | RegExp
+  | ((this: FaxiosHeaders, value: string, name: string) => boolean);
+
+type HeaderInput =
+  | Record<string, unknown>
+  | FaxiosHeaders
+  | string
+  | undefined
+  | null;
+
+/** Matches a `FaxiosHeaders` instance by its type-only brand. */
+export type FaxiosHeadersInstance = Pick<FaxiosHeaders, typeof faxiosHeadersBrand>;
+
+function normalizeHeader(header: string): string {
+  return header && String(header).trim()
+    .toLowerCase();
+}
+
+// eslint-disable-next-line sonarjs/function-return-type
+function normalizeValue(
+  value: FaxiosHeaderValue | undefined
+): string | Array<string> | false | null | undefined {
+  if (value == null) {
+    return value;
+  }
+  if (value === false) {
+    return false;
+  }
+  if (utils.isArray(value)) {
+    return (value as Array<FaxiosHeaderValue>).map(normalizeValue) as Array<string>;
+  }
+  return sanitizeHeaderValue(String(value));
+}
+
+function parseTokens(str: string): Record<string, string> {
+  const tokens: Record<string, string> = Object.create(null);
+  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let match;
+
+  while ((match = tokensRE.exec(str))) {
+    tokens[match[1]!] = match[2]!;
+  }
+
+  return tokens;
+}
+
+const isValidHeaderName = (str: string): boolean =>
+  /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+
+function matchHeaderValue(
+  context: FaxiosHeaders,
+  value: unknown,
+  header: string,
+  filter:
+    | string
+    | RegExp
+    | ((this: FaxiosHeaders, value: string, name: string) => boolean)
+    | undefined,
+  isHeaderNameFilter?: boolean
+): boolean | undefined {
+  if (utils.isFunction(filter)) {
+    return (
+      filter as (this: FaxiosHeaders, value: string, name: string) => boolean
+    ).call(context, value as string, header);
+  }
+
+  if (isHeaderNameFilter) {
+    value = header;
+  }
+
+  if (!utils.isString(value)) return undefined;
+
+  if (utils.isString(filter)) {
+    return (value as string).indexOf(filter as string) !== -1;
+  }
+
+  if (utils.isRegExp(filter)) {
+    return (filter as RegExp).test(value as string);
+  }
+  return undefined;
+}
+
+function formatHeader(header: string): string {
+  return header
+    .trim()
+    .toLowerCase()
+    .replace(/([a-z\d])(\w*)/g, (_w, char, str) => char.toUpperCase() + str);
+}
+
+function iterableToHeaders(header: Iterable<unknown>): Record<string, unknown> {
+  const obj: Record<string, unknown> = Object.create(null);
+  for (const entry of header) {
+    if (!utils.isArray(entry)) {
+      throw new TypeError("Object iterator must return a key-value pair");
+    }
+    const key = (entry as Array<unknown>)[0] as string;
+    const val = (entry as Array<unknown>)[1];
+    if (utils.hasOwnProp(obj, key)) {
+      const dest = obj[key];
+      obj[key] = utils.isArray(dest) ? [ ...(dest as Array<unknown>), val ] : [ dest, val ];
+    }
+    else {
+      obj[key] = val;
+    }
+  }
+  return obj;
+}
+
+function buildAccessors(obj: object, header: string): void {
+  const accessorName = utils.toCamelCase(" " + header);
+
+  [ "get", "set", "has" ].forEach(methodName => {
+    Object.defineProperty(
+      obj,
+      methodName + accessorName,
+      Object.assign(Object.create(null) as PropertyDescriptor, {
+        value: function (
+          this: FaxiosHeaders,
+          arg1: unknown,
+          arg2: unknown,
+          arg3: unknown
+        ) {
+          return (
+            this as unknown as Record<
+              string,
+              ((...args: Array<unknown>) => unknown) | undefined
+            >
+          )[methodName]!.call(this, header, arg1, arg2, arg3);
+        },
+        configurable: true,
+      })
+    );
+  });
+}
+
+declare const faxiosHeadersBrand: unique symbol;
+
+class FaxiosHeaders {
+  [key: string]: unknown;
+
+  // Type-only brand (nothing at runtime): lets config types accept an instance
+  // without its index signature or method names leaking into header-name completions.
+  declare readonly [faxiosHeadersBrand]: true;
+
+  // Accessors generated at runtime by FaxiosHeaders.accessor([...]) below.
+  // Declared here so consumers get real types instead of the index signature.
+  declare getContentType: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setContentType: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasContentType: (matcher?: HeaderMatcher) => boolean;
+  declare getContentLength: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setContentLength: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasContentLength: (matcher?: HeaderMatcher) => boolean;
+  declare getAccept: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setAccept: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasAccept: (matcher?: HeaderMatcher) => boolean;
+  declare getAcceptEncoding: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setAcceptEncoding: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasAcceptEncoding: (matcher?: HeaderMatcher) => boolean;
+  declare getUserAgent: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setUserAgent: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasUserAgent: (matcher?: HeaderMatcher) => boolean;
+  declare getAuthorization: (matcher?: HeaderMatcher) => FaxiosHeaderValue | undefined;
+  declare setAuthorization: (value: FaxiosHeaderValue, rewrite?: boolean) => this;
+  declare hasAuthorization: (matcher?: HeaderMatcher) => boolean;
+
+  constructor(
+    headers?: Record<string, unknown> | FaxiosHeaders | string | null
+  ) {
+    headers && this.set(headers);
+  }
+
+  set(
+    header: HeaderInput,
+    valueOrRewrite?: unknown,
+    rewrite?: boolean
+  ): this {
+    const self = this;
+
+    function setHeader(
+      _value: unknown,
+      _header: string,
+      _rewrite: unknown
+    ): void {
+      const lHeader = normalizeHeader(_header);
+
+      if (!lHeader) {
+        return;
+      }
+
+      const key = utils.findKey(self, lHeader) as string | undefined;
+
+      if (
+        !key ||
+        (self as Record<string, unknown>)[key] === undefined ||
+        _rewrite === true ||
+        (_rewrite === undefined &&
+          (self as Record<string, unknown>)[key] !== false &&
+          (self as Record<string, unknown>)[key] !== null)
+      ) {
+        (self as Record<string, unknown>)[key || _header] = normalizeValue(
+          _value as FaxiosHeaderValue
+        );
+      }
+    }
+
+    const setHeaders = (headers: object, _rewrite: unknown): void =>
+      utils.forEach(headers, (_value: unknown, _header: unknown) =>
+        setHeader(_value, _header as string, _rewrite)
+      );
+
+    if (utils.isPlainObject(header) || header instanceof this.constructor) {
+      setHeaders(header as object, valueOrRewrite);
+    }
+    else if (utils.isString(header)) {
+      header = (header as string).trim();
+      if (!isValidHeaderName(header)) {
+        setHeaders(parseHeaders(header), valueOrRewrite);
+      }
+      else {
+        setHeader(valueOrRewrite, header, rewrite);
+      }
+    }
+    else if (utils.isObject(header) && utils.isSafeIterable(header)) {
+      setHeaders(iterableToHeaders(header as Iterable<unknown>), valueOrRewrite);
+    }
+    else {
+      header != null && setHeader(valueOrRewrite, header as string, rewrite);
+    }
+
+    return this;
+  }
+
+  get(header: string): FaxiosHeaderValue | undefined;
+  get(header: string, parser: true): Record<string, string> | undefined;
+  get(header: string, parser: RegExp): RegExpExecArray | null | undefined;
+  get<R>(header: string, parser: (this: FaxiosHeaders, value: FaxiosHeaderValue, header: string) => R): R | undefined;
+  get(
+    header: string,
+    parser?:
+      | RegExp
+      | ((
+        this: FaxiosHeaders,
+        value: FaxiosHeaderValue,
+        header: string
+      ) => unknown)
+      | true
+  ): unknown {
+    header = normalizeHeader(header);
+
+    if (header) {
+      const key = utils.findKey(this, header) as string | undefined;
+
+      if (key) {
+        const value = (this as Record<string, unknown>)[
+          key
+        ] as FaxiosHeaderValue;
+
+        if (!parser) {
+          return value;
+        }
+
+        if (parser === true) {
+          return parseTokens(value as string);
+        }
+
+        if (utils.isFunction(parser)) {
+          return (
+            parser as (
+              this: FaxiosHeaders,
+              value: FaxiosHeaderValue,
+              header: string
+            ) => unknown
+          ).call(this, value, key);
+        }
+
+        if (utils.isRegExp(parser)) {
+          return (parser as RegExp).exec(value as string);
+        }
+
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+    return undefined;
+  }
+
+  has(header: string, matcher?: HeaderMatcher): boolean {
+    header = normalizeHeader(header);
+
+    if (header) {
+      const key = utils.findKey(this, header) as string | undefined;
+
+      return !!(
+        key &&
+        (this as Record<string, unknown>)[key] !== undefined &&
+        (!matcher ||
+          matchHeaderValue(
+            this,
+            (this as Record<string, unknown>)[key],
+            key,
+            matcher
+          ))
+      );
+    }
+
+    return false;
+  }
+
+  delete(header: string | Array<string>, matcher?: HeaderMatcher): boolean {
+    const self = this;
+    let deleted = false;
+
+    function deleteHeader(_header: string): void {
+      _header = normalizeHeader(_header);
+
+      if (_header) {
+        const key = utils.findKey(self, _header) as string | undefined;
+
+        if (
+          key &&
+          (!matcher ||
+            matchHeaderValue(
+              self,
+              (self as Record<string, unknown>)[key],
+              key,
+              matcher
+            ))
+        ) {
+          delete (self as Record<string, unknown>)[key];
+
+          deleted = true;
+        }
+      }
+    }
+
+    if (utils.isArray(header)) {
+      header.forEach(deleteHeader);
+    }
+    else {
+      deleteHeader(header);
+    }
+
+    return deleted;
+  }
+
+  clear(matcher?: HeaderMatcher): boolean {
+    const keys = Object.keys(this);
+    let i = keys.length;
+    let deleted = false;
+
+    while (i--) {
+      const key = keys[i]!;
+      if (
+        !matcher ||
+        matchHeaderValue(
+          this,
+          (this as Record<string, unknown>)[key],
+          key,
+          matcher,
+          true
+        )
+      ) {
+        delete (this as Record<string, unknown>)[key];
+        deleted = true;
+      }
+    }
+
+    return deleted;
+  }
+
+  normalize(format: boolean = false): this {
+    const self = this;
+    const headers: Record<string, unknown> = {};
+
+    utils.forEach(this, (value: unknown, _header: unknown) => {
+      const header = _header as string;
+      const key = utils.findKey(headers, header) as string | undefined;
+
+      if (key) {
+        (self as Record<string, unknown>)[key] = normalizeValue(
+          value as FaxiosHeaderValue
+        );
+        delete (self as Record<string, unknown>)[header];
+        return;
+      }
+
+      const normalized = format ? formatHeader(header) : String(header).trim();
+
+      if (normalized !== header) {
+        delete (self as Record<string, unknown>)[header];
+      }
+
+      (self as Record<string, unknown>)[normalized] = normalizeValue(
+        value as FaxiosHeaderValue
+      );
+
+      headers[normalized] = true;
+    });
+
+    return this;
+  }
+
+  concat(...targets: Array<HeaderInput>): FaxiosHeaders {
+    return (this.constructor as typeof FaxiosHeaders).concat(this, ...targets);
+  }
+
+  toJSON(asStrings?: boolean): Record<string, unknown> {
+    const obj: Record<string, unknown> = Object.create(null);
+
+    utils.forEach(this, (value: unknown, _header: unknown) => {
+      const header = _header as string;
+      value != null &&
+        value !== false &&
+        (obj[header] =
+          asStrings && utils.isArray(value)
+            ? (value as Array<string>).join(", ")
+            : value);
+    });
+
+    return obj;
+  }
+
+  [Symbol.iterator](): IterableIterator<[string, unknown]> {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+
+  toString(): string {
+    return Object.entries(this.toJSON())
+      .map(([ header, value ]) => header + ": " + value)
+      .join("\n");
+  }
+
+  getSetCookie(): Array<string> {
+    return (this.get("set-cookie") as Array<string> | null) ?? [];
+  }
+
+  get [Symbol.toStringTag](): string {
+    return "FaxiosHeaders";
+  }
+
+  static from(
+    thing?: Record<string, unknown> | FaxiosHeaders | string | null
+  ): FaxiosHeaders {
+    return thing instanceof this ? thing : new this(thing);
+  }
+
+  static concat(
+    first: Record<string, unknown> | FaxiosHeaders | string | undefined | null,
+    ...targets: Array<
+      Record<string, unknown> | FaxiosHeaders | string | undefined | null
+    >
+  ): FaxiosHeaders {
+    const computed = new this(first);
+
+    targets.forEach(target => computed.set(target));
+
+    return computed;
+  }
+
+  static accessor(header: string | Array<string>): typeof FaxiosHeaders {
+    const self = this as unknown as Record<
+      symbol,
+      { accessors: Record<string, boolean>; }
+    >;
+    const internals =
+      (self[$internals] =
+        self[$internals] =
+          {
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+            accessors: {} as Record<string, boolean>,
+          });
+
+    const accessors = internals.accessors;
+    const prototype = this.prototype;
+
+    function defineAccessor(_header: string): void {
+      const lHeader = normalizeHeader(_header);
+
+      if (!accessors[lHeader]) {
+        buildAccessors(prototype, _header);
+        accessors[lHeader] = true;
+      }
+    }
+
+    utils.isArray(header)
+      ? header.forEach(defineAccessor)
+      : defineAccessor(header);
+
+    return this;
+  }
+}
+
+FaxiosHeaders.accessor([
+  "Content-Type",
+  "Content-Length",
+  "Accept",
+  "Accept-Encoding",
+  "User-Agent",
+  "Authorization",
+]);
+
+// reserved names hotfix
+utils.reduceDescriptors(
+  FaxiosHeaders.prototype,
+  ({ value }: PropertyDescriptor, key: string) => {
+    let mapped = key[0]!.toUpperCase() + key.slice(1); // map `set` => `Set`
+    return {
+      get: () => value,
+      set(this: Record<string, unknown>, headerValue: unknown) {
+        this[mapped] = headerValue;
+      },
+    };
+  }
+);
+
+utils.freezeMethods(FaxiosHeaders);
+
+export default FaxiosHeaders;

package/src/lib/core/buildFullPath.ts

@@ -0,0 +1,51 @@
+"use strict";
+
+import combineURLs from "../helpers/combineURLs.js";
+import isAbsoluteURL from "../helpers/isAbsoluteURL.js";
+import type { InternalFaxiosRequestConfig } from "../types.js";
+import FaxiosError from "./FaxiosError.js";
+
+const malformedHttpProtocol = /^https?:(?!\/\/)/i;
+const httpProtocolControlCharacters = /[\t\n\r]/g;
+
+function stripLeadingC0ControlOrSpace(url: string): string {
+  let i = 0;
+  while (i < url.length && url.charCodeAt(i) <= 0x20) {
+    i++;
+  }
+  return url.slice(i);
+}
+
+function normalizeURLForProtocolCheck(url: string): string {
+  return stripLeadingC0ControlOrSpace(url).replace(httpProtocolControlCharacters, "");
+}
+
+function assertValidHttpProtocolURL(url: unknown, config: unknown): void {
+  if (typeof url === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url))) {
+    throw new FaxiosError(
+      "Invalid URL: missing \"//\" after protocol",
+      FaxiosError.ERR_INVALID_URL,
+      config as InternalFaxiosRequestConfig
+    );
+  }
+}
+
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ *
+ * @returns {string} The combined full path
+ */
+export default function buildFullPath(baseURL: unknown, requestedURL: unknown, allowAbsoluteUrls?: unknown, config?: unknown): string {
+  assertValidHttpProtocolURL(requestedURL, config);
+  let isRelativeUrl = !isAbsoluteURL(requestedURL);
+  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
+    assertValidHttpProtocolURL(baseURL, config);
+    return combineURLs(baseURL as string, requestedURL as string);
+  }
+  return requestedURL as string;
+}

package/src/lib/core/define.ts

@@ -0,0 +1,127 @@
+// @ts-self-types="./define.d.ts" — required for Deno: maps built .js to adjacent .d.ts in dist/
+
+import type { StandardSchemaV1 } from "../types/standard-schema.js";
+import type { FaxiosRequestConfig, FaxiosResponse, StringLiteralsOrString, Method } from "../types.js";
+import mergeConfig from "./mergeConfig.js";
+
+type StrippedFields =
+  | "url"
+  | "method"
+  | "pathParams"
+  | "params"
+  | "data"
+  | "pathParamsSchema"
+  | "paramsSchema"
+  | "requestSchema"
+  | "responseSchema";
+
+/** Request config accepted by a defined endpoint call: everything except `url`, `method`, `pathParams`, `params`, `data` and the schemas. */
+export type BasePerCallConfig = Omit<FaxiosRequestConfig, StrippedFields>;
+
+/** Config for one call of a defined endpoint; `pathParams`, `params` and `data` are required when their schema is set. */
+export type PerCallConfig<
+  PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined,
+  P extends StandardSchemaV1 | undefined,
+  D extends StandardSchemaV1 | undefined,
+  TOpts = unknown
+> =
+  BasePerCallConfig
+  & TOpts
+  & (PP extends StandardSchemaV1 ? {
+    /**
+     * Values for `{key}` placeholders in the endpoint URL (braces, not `:key`), validated by the
+     * endpoint's `pathParamsSchema` first. Each value goes through `String()` then
+     * `encodeURIComponent`; a missing, `null` or `undefined` value rejects with
+     * `ERR_BAD_OPTION_VALUE`, and a schema failure with `ERR_BAD_PATH_PARAMS_SCHEMA`.
+     * Keys with no matching placeholder are ignored.
+     */
+    pathParams: StandardSchemaV1.InferInput<PP>;
+  } : unknown)
+  & (P extends StandardSchemaV1 ? { params: StandardSchemaV1.InferInput<P>; } : unknown)
+  & (D extends StandardSchemaV1 ? { data: StandardSchemaV1.InferInput<D>; } : unknown);
+
+/** Config for `define()`: request defaults plus the schemas, which are locked at define time. */
+export type DefineConfig<
+  PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined = undefined,
+  P extends StandardSchemaV1 | undefined = undefined,
+  D extends StandardSchemaV1 | undefined = undefined,
+  R extends StandardSchemaV1 | undefined = undefined
+> = BasePerCallConfig & {
+  /**
+   * Standard Schema that validates `pathParams` on every call; its output fills the `{key}`
+   * placeholders. Makes `pathParams` required per call. A failure rejects with `ERR_BAD_PATH_PARAMS_SCHEMA`.
+   */
+  pathParamsSchema?: PP;
+  paramsSchema?: P;
+  requestSchema?: D;
+  responseSchema?: R;
+};
+
+type HasInputSchema<PP, P, D> =
+  [PP, P, D] extends [undefined, undefined, undefined] ? false : true;
+
+/** The function `define()` returns: call it with per-call config to send the request. */
+export type DefinedEndpoint<
+  PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined,
+  P extends StandardSchemaV1 | undefined,
+  D extends StandardSchemaV1 | undefined,
+  R extends StandardSchemaV1 | undefined,
+  TOpts = unknown
+> =
+  HasInputSchema<PP, P, D> extends true
+    ? (callConfig: PerCallConfig<PP, P, D, TOpts>) => Promise<FaxiosResponse<R extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<R> : unknown>>
+    : (callConfig?: PerCallConfig<PP, P, D, TOpts>) => Promise<FaxiosResponse<R extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<R> : unknown>>;
+
+/** The minimal instance shape `define()` and `route()` need: a `request` method. */
+export interface FaxiosLike {
+  request: (config: FaxiosRequestConfig) => Promise<FaxiosResponse<unknown>>;
+}
+
+type SchemaFields = Extract<StrippedFields, `${string}Schema`>;
+const schemaKeys = [ "pathParamsSchema", "paramsSchema", "requestSchema", "responseSchema" ] as const;
+// compile-time assertion: schemaKeys and SchemaFields must stay in sync
+void (schemaKeys satisfies ReadonlyArray<SchemaFields>);
+// strippedKeys strips url/method/schemas from per-call config; StrippedFields also omits pathParams/params/data
+// at the type level (those are still allowed at runtime — they're the validated data, not the schema definitions)
+const strippedKeys = [ "url", "method", ...schemaKeys ] as const;
+
+export function createDefinedEndpoint<
+  PP extends StandardSchemaV1<unknown, Record<string, unknown>> | undefined,
+  P extends StandardSchemaV1 | undefined,
+  D extends StandardSchemaV1 | undefined,
+  R extends StandardSchemaV1 | undefined
+>(
+  instance: FaxiosLike,
+  method: StringLiteralsOrString<Method>,
+  url: string,
+  defineConfig?: DefineConfig<PP, P, D, R>
+): DefinedEndpoint<PP, P, D, R> {
+  const bakedConfig: FaxiosRequestConfig = { ...(defineConfig ?? {}), method, url };
+
+  const fn = (callConfig?: PerCallConfig<PP, P, D>) => {
+    const safeCall: FaxiosRequestConfig = { ...(callConfig ?? {}) };
+    // ponytail: runtime guard — strip identity + schemas so JS callers can't override
+    for (const k of strippedKeys) {
+      delete (safeCall as Record<string, unknown>)[k];
+    }
+
+    // mergeConfig(baked, perCall): perCall wins for most fields (signal, headers, timeout, env)
+    const merged = mergeConfig(bakedConfig, safeCall);
+    // Lock url/method and re-lock schemas — perCall cannot override define-time identity
+    (merged as Record<string, unknown>)["url"] = url;
+    (merged as Record<string, unknown>)["method"] = method;
+    // ponytail: defense-in-depth — mergeConfig would fall through, but this makes the invariant explicit
+    for (const k of schemaKeys) {
+      if (Object.prototype.hasOwnProperty.call(bakedConfig, k)) {
+        (merged as Record<string, unknown>)[k] = bakedConfig[k];
+      }
+      else {
+        delete (merged as Record<string, unknown>)[k];
+      }
+    }
+
+    return instance.request(merged);
+  };
+
+  return fn as DefinedEndpoint<PP, P, D, R>;
+}