@tryfinch/finch-api 6.31.0 → 8.0.0

package/src/internal/detect-platform.ts

@@ -0,0 +1,196 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { VERSION } from '../version';
+
+export const isRunningInBrowser = () => {
+  return (
+    // @ts-ignore
+    typeof window !== 'undefined' &&
+    // @ts-ignore
+    typeof window.document !== 'undefined' &&
+    // @ts-ignore
+    typeof navigator !== 'undefined'
+  );
+};
+
+type DetectedPlatform = 'deno' | 'node' | 'edge' | 'unknown';
+
+/**
+ * Note this does not detect 'browser'; for that, use getBrowserInfo().
+ */
+function getDetectedPlatform(): DetectedPlatform {
+  if (typeof Deno !== 'undefined' && Deno.build != null) {
+    return 'deno';
+  }
+  if (typeof EdgeRuntime !== 'undefined') {
+    return 'edge';
+  }
+  if (
+    Object.prototype.toString.call(
+      typeof (globalThis as any).process !== 'undefined' ? (globalThis as any).process : 0,
+    ) === '[object process]'
+  ) {
+    return 'node';
+  }
+  return 'unknown';
+}
+
+declare const Deno: any;
+declare const EdgeRuntime: any;
+type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | `other:${string}` | 'unknown';
+type PlatformName =
+  | 'MacOS'
+  | 'Linux'
+  | 'Windows'
+  | 'FreeBSD'
+  | 'OpenBSD'
+  | 'iOS'
+  | 'Android'
+  | `Other:${string}`
+  | 'Unknown';
+type Browser = 'ie' | 'edge' | 'chrome' | 'firefox' | 'safari';
+type PlatformProperties = {
+  'X-Stainless-Lang': 'js';
+  'X-Stainless-Package-Version': string;
+  'X-Stainless-OS': PlatformName;
+  'X-Stainless-Arch': Arch;
+  'X-Stainless-Runtime': 'node' | 'deno' | 'edge' | `browser:${Browser}` | 'unknown';
+  'X-Stainless-Runtime-Version': string;
+};
+const getPlatformProperties = (): PlatformProperties => {
+  const detectedPlatform = getDetectedPlatform();
+  if (detectedPlatform === 'deno') {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': VERSION,
+      'X-Stainless-OS': normalizePlatform(Deno.build.os),
+      'X-Stainless-Arch': normalizeArch(Deno.build.arch),
+      'X-Stainless-Runtime': 'deno',
+      'X-Stainless-Runtime-Version':
+        typeof Deno.version === 'string' ? Deno.version : Deno.version?.deno ?? 'unknown',
+    };
+  }
+  if (typeof EdgeRuntime !== 'undefined') {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': VERSION,
+      'X-Stainless-OS': 'Unknown',
+      'X-Stainless-Arch': `other:${EdgeRuntime}`,
+      'X-Stainless-Runtime': 'edge',
+      'X-Stainless-Runtime-Version': (globalThis as any).process.version,
+    };
+  }
+  // Check if Node.js
+  if (detectedPlatform === 'node') {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': VERSION,
+      'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform ?? 'unknown'),
+      'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch ?? 'unknown'),
+      'X-Stainless-Runtime': 'node',
+      'X-Stainless-Runtime-Version': (globalThis as any).process.version ?? 'unknown',
+    };
+  }
+
+  const browserInfo = getBrowserInfo();
+  if (browserInfo) {
+    return {
+      'X-Stainless-Lang': 'js',
+      'X-Stainless-Package-Version': VERSION,
+      'X-Stainless-OS': 'Unknown',
+      'X-Stainless-Arch': 'unknown',
+      'X-Stainless-Runtime': `browser:${browserInfo.browser}`,
+      'X-Stainless-Runtime-Version': browserInfo.version,
+    };
+  }
+
+  // TODO add support for Cloudflare workers, etc.
+  return {
+    'X-Stainless-Lang': 'js',
+    'X-Stainless-Package-Version': VERSION,
+    'X-Stainless-OS': 'Unknown',
+    'X-Stainless-Arch': 'unknown',
+    'X-Stainless-Runtime': 'unknown',
+    'X-Stainless-Runtime-Version': 'unknown',
+  };
+};
+
+type BrowserInfo = {
+  browser: Browser;
+  version: string;
+};
+
+declare const navigator: { userAgent: string } | undefined;
+
+// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts
+function getBrowserInfo(): BrowserInfo | null {
+  if (typeof navigator === 'undefined' || !navigator) {
+    return null;
+  }
+
+  // NOTE: The order matters here!
+  const browserPatterns = [
+    { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'ie' as const, pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'ie' as const, pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'chrome' as const, pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'firefox' as const, pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: 'safari' as const, pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ },
+  ];
+
+  // Find the FIRST matching browser
+  for (const { key, pattern } of browserPatterns) {
+    const match = pattern.exec(navigator.userAgent);
+    if (match) {
+      const major = match[1] || 0;
+      const minor = match[2] || 0;
+      const patch = match[3] || 0;
+
+      return { browser: key, version: `${major}.${minor}.${patch}` };
+    }
+  }
+
+  return null;
+}
+
+const normalizeArch = (arch: string): Arch => {
+  // Node docs:
+  // - https://nodejs.org/api/process.html#processarch
+  // Deno docs:
+  // - https://doc.deno.land/deno/stable/~/Deno.build
+  if (arch === 'x32') return 'x32';
+  if (arch === 'x86_64' || arch === 'x64') return 'x64';
+  if (arch === 'arm') return 'arm';
+  if (arch === 'aarch64' || arch === 'arm64') return 'arm64';
+  if (arch) return `other:${arch}`;
+  return 'unknown';
+};
+
+const normalizePlatform = (platform: string): PlatformName => {
+  // Node platforms:
+  // - https://nodejs.org/api/process.html#processplatform
+  // Deno platforms:
+  // - https://doc.deno.land/deno/stable/~/Deno.build
+  // - https://github.com/denoland/deno/issues/14799
+
+  platform = platform.toLowerCase();
+
+  // NOTE: this iOS check is untested and may not work
+  // Node does not work natively on IOS, there is a fork at
+  // https://github.com/nodejs-mobile/nodejs-mobile
+  // however it is unknown at the time of writing how to detect if it is running
+  if (platform.includes('ios')) return 'iOS';
+  if (platform === 'android') return 'Android';
+  if (platform === 'darwin') return 'MacOS';
+  if (platform === 'win32') return 'Windows';
+  if (platform === 'freebsd') return 'FreeBSD';
+  if (platform === 'openbsd') return 'OpenBSD';
+  if (platform === 'linux') return 'Linux';
+  if (platform) return `Other:${platform}`;
+  return 'Unknown';
+};
+
+let _platformHeaders: PlatformProperties;
+export const getPlatformHeaders = () => {
+  return (_platformHeaders ??= getPlatformProperties());
+};

package/src/internal/errors.ts

@@ -0,0 +1,33 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export function isAbortError(err: unknown) {
+  return (
+    typeof err === 'object' &&
+    err !== null &&
+    // Spec-compliant fetch implementations
+    (('name' in err && (err as any).name === 'AbortError') ||
+      // Expo fetch
+      ('message' in err && String((err as any).message).includes('FetchRequestCanceledException')))
+  );
+}
+
+export const castToError = (err: any): Error => {
+  if (err instanceof Error) return err;
+  if (typeof err === 'object' && err !== null) {
+    try {
+      if (Object.prototype.toString.call(err) === '[object Error]') {
+        // @ts-ignore - not all envs have native support for cause yet
+        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        if (err.stack) error.stack = err.stack;
+        // @ts-ignore - not all envs have native support for cause yet
+        if (err.cause && !error.cause) error.cause = err.cause;
+        if (err.name) error.name = err.name;
+        return error;
+      }
+    } catch {}
+    try {
+      return new Error(JSON.stringify(err));
+    } catch {}
+  }
+  return new Error(err);
+};

package/src/internal/headers.ts

@@ -0,0 +1,144 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { isReadonlyArray } from './utils/values';
+
+type HeaderValue = string | undefined | null;
+export type HeadersLike =
+  | Headers
+  | readonly HeaderValue[][]
+  | Record<string, HeaderValue | readonly HeaderValue[]>
+  | undefined
+  | null
+  | NullableHeaders;
+
+const brand_privateNullableHeaders = /* @__PURE__ */ Symbol('brand.privateNullableHeaders');
+
+/**
+ * @internal
+ * Users can pass explicit nulls to unset default headers. When we parse them
+ * into a standard headers type we need to preserve that information.
+ */
+export type NullableHeaders = {
+  /** Brand check, prevent users from creating a NullableHeaders. */
+  [brand_privateNullableHeaders]: true;
+  /** Parsed headers. */
+  values: Headers;
+  /** Set of lowercase header names explicitly set to null. */
+  nulls: Set<string>;
+};
+
+function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [string, string | null]> {
+  if (!headers) return;
+
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+
+  let shouldClear = false;
+  let iter: Iterable<readonly (HeaderValue | readonly HeaderValue[])[]>;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isReadonlyArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    if (typeof name !== 'string') throw new TypeError('expected header name to be a string');
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined) continue;
+
+      // Objects keys always overwrite older headers, they never append.
+      // Yield a null to clear the header before adding the new values.
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+
+export const buildHeaders = (newHeaders: HeadersLike[]): NullableHeaders => {
+  const targetHeaders = new Headers();
+  const nullHeaders = new Set<string>();
+  for (const headers of newHeaders) {
+    const seenHeaders = new Set<string>();
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+
+export const isEmptyHeaders = (headers: HeadersLike) => {
+  for (const _ of iterateHeaders(headers)) return false;
+  return true;
+};
+
+export const getRequiredHeader = (headers: HeadersLike | Headers, header: string): string => {
+  const foundHeader = getHeader(headers, header);
+  if (foundHeader === undefined) {
+    throw new Error(`Could not find ${header} header`);
+  }
+  return foundHeader;
+};
+
+export const isHeadersProtocol = (headers: any): headers is HeadersProtocol => {
+  return typeof headers?.get === 'function';
+};
+
+export interface HeadersProtocol {
+  get: (header: string) => string | null | undefined;
+}
+
+export const getHeader = (headers: HeadersLike | Headers, header: string): string | undefined => {
+  if (!headers) return undefined;
+
+  const lowerCasedHeader = header.toLowerCase();
+  if (isHeadersProtocol(headers)) {
+    // to deal with the case where the header looks like Stainless-Event-Id
+    const intercapsHeader =
+      header[0]?.toUpperCase() +
+      header.substring(1).replace(/([^\w])(\w)/g, (_m, g1, g2) => g1 + g2.toUpperCase());
+    for (const key of [header, lowerCasedHeader, header.toUpperCase(), intercapsHeader]) {
+      const value = headers.get(key);
+      if (value) {
+        return value;
+      }
+    }
+  }
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerCasedHeader) {
+      if (Array.isArray(value)) {
+        if (value.length <= 1) return value[0];
+        console.warn(`Received ${value.length} entries for the ${header} header, using the first entry.`);
+        return value[0];
+      }
+      return value;
+    }
+  }
+
+  return undefined;
+};

package/src/internal/parse.ts

@@ -0,0 +1,50 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { FinalRequestOptions } from './request-options';
+import { type Finch } from '../client';
+import { formatRequestDetails, loggerFor } from './utils/log';
+
+export type APIResponseProps = {
+  response: Response;
+  options: FinalRequestOptions;
+  controller: AbortController;
+  requestLogID: string;
+  retryOfRequestLogID: string | undefined;
+  startTime: number;
+};
+
+export async function defaultParseResponse<T>(client: Finch, props: APIResponseProps): Promise<T> {
+  const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+  const body = await (async () => {
+    // fetch refuses to read the body when the status code is 204.
+    if (response.status === 204) {
+      return null as T;
+    }
+
+    if (props.options.__binaryResponse) {
+      return response as unknown as T;
+    }
+
+    const contentType = response.headers.get('content-type');
+    const mediaType = contentType?.split(';')[0]?.trim();
+    const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json');
+    if (isJSON) {
+      const json = await response.json();
+      return json as T;
+    }
+
+    const text = await response.text();
+    return text as unknown as T;
+  })();
+  loggerFor(client).debug(
+    `[${requestLogID}] response parsed`,
+    formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      body,
+      durationMs: Date.now() - startTime,
+    }),
+  );
+  return body;
+}

package/src/internal/qs/formats.ts

@@ -1,9 +1,10 @@
-import type { Format } from "./types.js";
+import type { Format } from './types';
 
 export const default_format: Format = 'RFC3986';
+export const default_formatter = (v: PropertyKey) => String(v);
 export const formatters: Record<Format, (str: PropertyKey) => string> = {
   RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
-  RFC3986: (v: PropertyKey) => String(v),
+  RFC3986: default_formatter,
 };
 export const RFC1738 = 'RFC1738';
 export const RFC3986 = 'RFC3986';

package/src/internal/qs/index.ts

@@ -1,4 +1,4 @@
-import { default_format, formatters, RFC1738, RFC3986 } from "./formats.js";
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
 
 const formats = {
   formatters,
@@ -7,7 +7,7 @@ const formats = {
   default: default_format,
 };
 
-export { stringify } from "./stringify.js";
+export { stringify } from './stringify';
 export { formats };
 
-export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from "./types.js";
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';

package/src/internal/qs/stringify.ts

@@ -1,8 +1,7 @@
-import { encode, is_buffer, maybe_map } from "./utils.js";
-import { default_format, formatters } from "./formats.js";
-import type { NonNullableProperties, StringifyOptions } from "./types.js";
-
-const has = Object.prototype.hasOwnProperty;
+import { encode, is_buffer, maybe_map, has } from './utils';
+import { default_format, default_formatter, formatters } from './formats';
+import type { NonNullableProperties, StringifyOptions } from './types';
+import { isArray } from '../utils/values';
 
 const array_prefix_generators = {
   brackets(prefix: PropertyKey) {
@@ -17,13 +16,11 @@ const array_prefix_generators = {
   },
 };
 
-const is_array = Array.isArray;
-const push = Array.prototype.push;
 const push_to_array = function (arr: any[], value_or_array: any) {
-  push.apply(arr, is_array(value_or_array) ? value_or_array : [value_or_array]);
+  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
 };
 
-const to_ISO = Date.prototype.toISOString;
+let toISOString;
 
 const defaults = {
   addQueryPrefix: false,
@@ -38,11 +35,11 @@ const defaults = {
   encoder: encode,
   encodeValuesOnly: false,
   format: default_format,
-  formatter: formatters[default_format],
+  formatter: default_formatter,
   /** @deprecated */
   indices: false,
   serializeDate(date) {
-    return to_ISO.call(date);
+    return (toISOString ??= Function.prototype.call.bind(Date.prototype.toISOString))(date);
   },
   skipNulls: false,
   strictNullHandling: false,
@@ -105,7 +102,7 @@ function inner_stringify(
     obj = filter(prefix, obj);
   } else if (obj instanceof Date) {
     obj = serializeDate?.(obj);
-  } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
+  } else if (generateArrayPrefix === 'comma' && isArray(obj)) {
     obj = maybe_map(obj, function (value) {
       if (value instanceof Date) {
         return serializeDate?.(value);
@@ -148,14 +145,14 @@ function inner_stringify(
   }
 
   let obj_keys;
-  if (generateArrayPrefix === 'comma' && is_array(obj)) {
+  if (generateArrayPrefix === 'comma' && isArray(obj)) {
     // we need to join elements in
     if (encodeValuesOnly && encoder) {
       // @ts-expect-error values only
       obj = maybe_map(obj, encoder);
     }
     obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
-  } else if (is_array(filter)) {
+  } else if (isArray(filter)) {
     obj_keys = filter;
   } else {
     const keys = Object.keys(obj);
@@ -165,9 +162,9 @@ function inner_stringify(
   const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
 
   const adjusted_prefix =
-    commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+    commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
 
-  if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
     return adjusted_prefix + '[]';
   }
 
@@ -184,7 +181,7 @@ function inner_stringify(
     // @ts-ignore
     const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
     const key_prefix =
-      is_array(obj) ?
+      isArray(obj) ?
         typeof generateArrayPrefix === 'function' ?
           generateArrayPrefix(adjusted_prefix, encoded_key)
         : adjusted_prefix
@@ -205,7 +202,7 @@ function inner_stringify(
         skipNulls,
         encodeDotInKeys,
         // @ts-ignore
-        generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
+        generateArrayPrefix === 'comma' && encodeValuesOnly && isArray(obj) ? null : encoder,
         filter,
         sort,
         allowDots,
@@ -244,7 +241,7 @@ function normalize_stringify_options(
 
   let format = default_format;
   if (typeof opts.format !== 'undefined') {
-    if (!has.call(formatters, opts.format)) {
+    if (!has(formatters, opts.format)) {
       throw new TypeError('Unknown format option provided.');
     }
     format = opts.format;
@@ -252,7 +249,7 @@ function normalize_stringify_options(
   const formatter = formatters[format];
 
   let filter = defaults.filter;
-  if (typeof opts.filter === 'function' || is_array(opts.filter)) {
+  if (typeof opts.filter === 'function' || isArray(opts.filter)) {
     filter = opts.filter;
   }
 
@@ -316,7 +313,7 @@ export function stringify(object: any, opts: StringifyOptions = {}) {
   if (typeof options.filter === 'function') {
     filter = options.filter;
     obj = filter('', obj);
-  } else if (is_array(options.filter)) {
+  } else if (isArray(options.filter)) {
     filter = options.filter;
     obj_keys = filter;
   }

package/src/internal/qs/utils.ts

@@ -1,10 +1,13 @@
-import { RFC1738 } from "./formats.js";
-import type { DefaultEncoder, Format } from "./types.js";
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
 
-const has = Object.prototype.hasOwnProperty;
-const is_array = Array.isArray;
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
 
-const hex_table = (() => {
+const hex_table = /* @__PURE__ */ (() => {
   const array = [];
   for (let i = 0; i < 256; ++i) {
     array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
@@ -20,7 +23,7 @@ function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; pro
 
     const obj = item.obj[item.prop];
 
-    if (is_array(obj)) {
+    if (isArray(obj)) {
       const compacted: unknown[] = [];
 
       for (let j = 0; j < obj.length; ++j) {
@@ -56,13 +59,10 @@ export function merge(
   }
 
   if (typeof source !== 'object') {
-    if (is_array(target)) {
+    if (isArray(target)) {
       target.push(source);
     } else if (target && typeof target === 'object') {
-      if (
-        (options && (options.plainObjects || options.allowPrototypes)) ||
-        !has.call(Object.prototype, source)
-      ) {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
         target[source] = true;
       }
     } else {
@@ -77,14 +77,14 @@ export function merge(
   }
 
   let mergeTarget = target;
-  if (is_array(target) && !is_array(source)) {
+  if (isArray(target) && !isArray(source)) {
     // @ts-ignore
     mergeTarget = array_to_object(target, options);
   }
 
-  if (is_array(target) && is_array(source)) {
+  if (isArray(target) && isArray(source)) {
     source.forEach(function (item, i) {
-      if (has.call(target, i)) {
+      if (has(target, i)) {
         const targetItem = target[i];
         if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
           target[i] = merge(targetItem, item, options);
@@ -101,7 +101,7 @@ export function merge(
   return Object.keys(source).reduce(function (acc, key) {
     const value = source[key];
 
-    if (has.call(acc, key)) {
+    if (has(acc, key)) {
       acc[key] = merge(acc[key], value, options);
     } else {
       acc[key] = value;
@@ -254,7 +254,7 @@ export function combine(a: any, b: any) {
 }
 
 export function maybe_map<T>(val: T[], fn: (v: T) => T) {
-  if (is_array(val)) {
+  if (isArray(val)) {
     const mapped = [];
     for (let i = 0; i < val.length; i += 1) {
       mapped.push(fn(val[i]!));