@openclaw/firecrawl-plugin 2026.9.7 → 2026.10.1-beta.1

package/node_modules/zod/src/v4/classic/checks.ts

@@ -1,33 +0,0 @@
-export {
-  _lt as lt,
-  _lte as lte,
-  _gt as gt,
-  _gte as gte,
-  _positive as positive,
-  _negative as negative,
-  _nonpositive as nonpositive,
-  _nonnegative as nonnegative,
-  _multipleOf as multipleOf,
-  _maxSize as maxSize,
-  _minSize as minSize,
-  _size as size,
-  _maxLength as maxLength,
-  _minLength as minLength,
-  _length as length,
-  _regex as regex,
-  _lowercase as lowercase,
-  _uppercase as uppercase,
-  _includes as includes,
-  _startsWith as startsWith,
-  _endsWith as endsWith,
-  _property as property,
-  _properties as properties,
-  _mime as mime,
-  _overwrite as overwrite,
-  _normalize as normalize,
-  _trim as trim,
-  _toLowerCase as toLowerCase,
-  _toUpperCase as toUpperCase,
-  _slugify as slugify,
-  type $RefinementCtx as RefinementCtx,
-} from "../core/index.js";

package/node_modules/zod/src/v4/classic/coerce.ts

@@ -1,27 +0,0 @@
-import * as core from "../core/index.js";
-import * as schemas from "./schemas.js";
-
-export interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {}
-export function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T> {
-  return core._coercedString(schemas.ZodString, params) as any;
-}
-
-export interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {}
-export function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T> {
-  return core._coercedNumber(schemas.ZodNumber, params) as ZodCoercedNumber<T>;
-}
-
-export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {}
-export function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T> {
-  return core._coercedBoolean(schemas.ZodBoolean, params) as ZodCoercedBoolean<T>;
-}
-
-export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {}
-export function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T> {
-  return core._coercedBigint(schemas.ZodBigInt, params) as ZodCoercedBigInt<T>;
-}
-
-export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {}
-export function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T> {
-  return core._coercedDate(schemas.ZodDate, params) as ZodCoercedDate<T>;
-}

package/node_modules/zod/src/v4/classic/compat.ts

@@ -1,78 +0,0 @@
-// Zod 3 compat layer
-
-import * as core from "../core/index.js";
-import type { ZodType } from "./schemas.js";
-
-/** @deprecated Use `z.output<T>` instead. */
-export type TypeOf<T> = core.output<T>;
-/** @deprecated Use `z.output<T>` instead. */
-export type Infer<T> = core.output<T>;
-/** @deprecated Use `z.core.$ZodTypes` instead */
-export type ZodFirstPartySchemaTypes = core.$ZodTypes;
-
-/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
-export const ZodIssueCode = {
-  invalid_type: "invalid_type",
-  too_big: "too_big",
-  too_small: "too_small",
-  invalid_format: "invalid_format",
-  not_multiple_of: "not_multiple_of",
-  unrecognized_keys: "unrecognized_keys",
-  invalid_union: "invalid_union",
-  invalid_key: "invalid_key",
-  invalid_element: "invalid_element",
-  invalid_value: "invalid_value",
-  custom: "custom",
-} as const;
-
-/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
-export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
-
-/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
-export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<
-  core.output<T>,
-  U
->;
-
-/** Use `z.$brand` instead */
-export type BRAND<T extends string | number | symbol = string | number | symbol> = {
-  [core.$brand]: { [k in T]: true };
-};
-export { $brand, config } from "../core/index.js";
-
-/** @deprecated Use `z.config(params)` instead. */
-export function setErrorMap(map: core.$ZodErrorMap): void {
-  core.config({
-    customError: map,
-  });
-}
-
-/** @deprecated Use `z.config()` instead. */
-export function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined {
-  return core.config().customError;
-}
-
-/** @deprecated Use z.ZodType (without generics) instead. */
-export type ZodTypeAny<
-  Output = unknown,
-  Input = unknown,
-  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
-> = ZodType<Output, Input, Internals>;
-/** @deprecated Use `z.ZodType` */
-export type ZodSchema<
-  Output = unknown,
-  Input = unknown,
-  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
-> = ZodType<Output, Input, Internals>;
-/** @deprecated Use `z.ZodType` */
-export type Schema<
-  Output = unknown,
-  Input = unknown,
-  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
-> = ZodType<Output, Input, Internals>;
-
-/** Included for Zod 3 compatibility */
-export type ZodRawShape = core.$ZodShape;
-
-/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
-export enum ZodFirstPartyTypeKind {}

package/node_modules/zod/src/v4/classic/deep-partial.ts

@@ -1,76 +0,0 @@
-import type * as core from "../core/index.js";
-import { visit } from "../core/visit.js";
-import * as schemas from "./schemas.js";
-
-/** Distributes `.partial()` through every object in a schema type, preserving the wrappers around them. */
-// biome-ignore format: preserve vertical layout for readability.
-export type DeepPartial<T extends core.SomeType> =
-  T extends schemas.ZodObject<infer Shape, infer Config>
-    ? schemas.ZodObject<
-        { -readonly [K in keyof Shape]: schemas.ZodOptional<DeepPartial<Shape[K]>> },
-        Config
-      >
-  // Must precede ZodUnion; degrades to it, matching the runtime.
-  : T extends schemas.ZodDiscriminatedUnion<infer Options, any>
-    ? schemas.ZodUnion<
-        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
-      >
-  : T extends schemas.ZodUnion<infer Options>
-    ? schemas.ZodUnion<
-        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
-      >
-  : T extends schemas.ZodArray<infer El>
-    ? schemas.ZodArray<DeepPartial<El>>
-  : T extends schemas.ZodTuple<infer Items, infer Rest>
-    ? schemas.ZodTuple<
-        { -readonly [K in keyof Items]: Items[K] extends core.SomeType ? DeepPartial<Items[K]> : Items[K] },
-        Rest extends core.SomeType ? DeepPartial<Rest> : Rest
-      >
-  : T extends schemas.ZodIntersection<infer A, infer B>
-    ? schemas.ZodIntersection<DeepPartial<A>, DeepPartial<B>>
-  : T extends schemas.ZodRecord<infer K, infer V>
-    ? schemas.ZodRecord<K, DeepPartial<V>>
-  : T extends schemas.ZodMap<infer K, infer V>
-    ? schemas.ZodMap<K, DeepPartial<V>>
-  : T extends schemas.ZodSet<infer El>
-    ? schemas.ZodSet<DeepPartial<El>>
-  : T extends schemas.ZodOptional<infer Inner>
-    ? schemas.ZodOptional<DeepPartial<Inner>>
-  : T extends schemas.ZodNullable<infer Inner>
-    ? schemas.ZodNullable<DeepPartial<Inner>>
-  : T extends schemas.ZodDefault<infer Inner>
-    ? schemas.ZodDefault<DeepPartial<Inner>>
-  : T extends schemas.ZodPrefault<infer Inner>
-    ? schemas.ZodPrefault<DeepPartial<Inner>>
-  : T extends schemas.ZodNonOptional<infer Inner>
-    ? schemas.ZodNonOptional<DeepPartial<Inner>>
-  : T extends schemas.ZodCatch<infer Inner>
-    ? schemas.ZodCatch<DeepPartial<Inner>>
-  : T extends schemas.ZodReadonly<infer Inner>
-    ? schemas.ZodReadonly<DeepPartial<Inner>>
-  : T extends schemas.ZodSuccess<infer Inner>
-    ? schemas.ZodSuccess<DeepPartial<Inner>>
-  : T extends schemas.ZodPromise<infer Inner>
-    ? schemas.ZodPromise<DeepPartial<Inner>>
-  // Must precede ZodPipe, which both extend structurally, or the subtype is lost.
-  : T extends schemas.ZodCodec<infer A, infer B>
-    ? schemas.ZodCodec<DeepPartial<A>, DeepPartial<B>>
-  : T extends schemas.ZodPreprocess<infer B>
-    ? schemas.ZodPreprocess<DeepPartial<B>>
-  : T extends schemas.ZodPipe<infer A, infer B>
-    ? schemas.ZodPipe<DeepPartial<A>, DeepPartial<B>>
-  : T extends schemas.ZodLazy<infer Inner>
-    ? schemas.ZodLazy<DeepPartial<Inner>>
-  : T;
-
-/** Returns a copy of the schema with every nested object's properties made optional. */
-export function deepPartial<T extends core.SomeType>(schema: T): DeepPartial<T> {
-  return visit(schema, {
-    object: (s) => (s as schemas.ZodObject).partial(),
-    // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
-    union: (s) => {
-      const def = s._zod.def as core.$ZodDiscriminatedUnionDef;
-      return def.discriminator === undefined ? s : schemas.union(def.options as schemas.ZodType[]);
-    },
-  }) as unknown as DeepPartial<T>;
-}

package/node_modules/zod/src/v4/classic/errors.ts

@@ -1,97 +0,0 @@
-import * as core from "../core/index.js";
-import { $ZodError } from "../core/index.js";
-import * as util from "../core/util.js";
-
-/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
-export type ZodIssue = core.$ZodIssue;
-
-/** An Error-like class used to store Zod validation issues.  */
-export interface ZodError<T = unknown> extends $ZodError<T> {
-  /** @deprecated Use the `z.treeifyError(err)` function instead. */
-  format(): core.$ZodFormattedError<T>;
-  format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
-  /** @deprecated Use the `z.treeifyError(err)` function instead. */
-  flatten(): core.$ZodFlattenedError<T>;
-  flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
-  /** @deprecated Push directly to `.issues` instead. */
-  addIssue(issue: core.$ZodIssue): void;
-  /** @deprecated Push directly to `.issues` instead. */
-  addIssues(issues: core.$ZodIssue[]): void;
-
-  /** @deprecated Check `err.issues.length === 0` instead. */
-  isEmpty: boolean;
-}
-
-/* Prototypes that already carry the lazy helper methods. Seeded with the
- * intrinsics so that `init` on a foreign object — it accepts any object —
- * can never install an accessor onto a prototype we do not own. */
-const _installedErrorProtos = /* @__PURE__ */ new WeakSet<object>([Object.prototype, Error.prototype]);
-
-/* Helper methods live as non-enumerable lazy getters on the shared
- * prototype instead of own properties on every instance. On first
- * access the getter allocates the per-instance closure and caches it
- * as a non-enumerable own property, so detached usage still works and
- * the allocation only happens for methods actually touched. */
-function _lazyMethod(proto: object, key: string, make: (self: ZodError) => unknown): void {
-  Object.defineProperty(proto, key, {
-    configurable: true,
-    enumerable: false,
-    get(this: ZodError) {
-      const value = make(this);
-      Object.defineProperty(this, key, { value, configurable: true, writable: true });
-      return value;
-    },
-    set(this: ZodError, value: unknown) {
-      Object.defineProperty(this, key, { value, configurable: true, writable: true });
-    },
-  });
-}
-
-const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
-  $ZodError.init(inst, issues);
-  inst.name = "ZodError";
-
-  const proto = Object.getPrototypeOf(inst);
-  if (_installedErrorProtos.has(proto)) return;
-  _installedErrorProtos.add(proto);
-
-  _lazyMethod(proto, "format", (self) => (mapper: any) => core.formatError(self, mapper));
-  _lazyMethod(proto, "flatten", (self) => (mapper: any) => core.flattenError(self, mapper));
-  _lazyMethod(proto, "addIssue", (self) => (issue: any) => {
-    self.issues.push(issue);
-    self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);
-  });
-  _lazyMethod(proto, "addIssues", (self) => (issues: any) => {
-    self.issues.push(...issues);
-    self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);
-  });
-  Object.defineProperty(proto, "isEmpty", {
-    configurable: true,
-    enumerable: false,
-    get(this: ZodError) {
-      return this.issues.length === 0;
-    },
-  });
-};
-export const ZodError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor("ZodError", initializer);
-export const ZodRealError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor(
-  "ZodError",
-  initializer,
-  undefined,
-  {
-    Parent: Error,
-  }
-);
-
-/** @deprecated Use `z.core.$ZodFlattenedError` instead. */
-export type ZodFlattenedError<T, U = string> = core.$ZodFlattenedError<T, U>;
-/** @deprecated Use `z.core.$ZodFormattedError` instead. */
-export type ZodFormattedError<T, U = string> = core.$ZodFormattedError<T, U>;
-/** @deprecated Use `z.core.$ZodErrorMap` instead. */
-export type ZodErrorMap<T extends core.$ZodIssueBase = core.$ZodIssue> = core.$ZodErrorMap<T>;
-
-/** @deprecated Use `z.core.$ZodRawIssue` instead. */
-export type IssueData = core.$ZodRawIssue;
-
-// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */
-// export type ErrorMapCtx = core.$ZodErrorMapCtx;

package/node_modules/zod/src/v4/classic/external.ts

@@ -1,57 +0,0 @@
-export * as core from "../core/index.js";
-export * from "./schemas.js";
-export * from "./checks.js";
-export * from "./errors.js";
-export * from "./parse.js";
-export * from "./compat.js";
-
-export type { infer } from "../core/index.js";
-export type { JSONType } from "../core/util.js";
-export type { CompileOptions } from "../core/index.js";
-export {
-  globalRegistry,
-  type GlobalMeta,
-  registry,
-  config,
-  memoizer,
-  $output,
-  $input,
-  $brand,
-  clone,
-  regexes,
-  treeifyError,
-  prettifyError,
-  formatError,
-  flattenError,
-  TimePrecision,
-  util,
-  NEVER,
-  INVALID,
-  toZod,
-  compile,
-  withParser,
-  ZodCompileAsyncError,
-  ZodCompileUnsupportedError,
-  getDiscriminatedOption,
-} from "../core/index.js";
-export { toJSONSchema } from "../core/json-schema-processors.js";
-export { fromJSONSchema } from "./from-json-schema.js";
-export { deepPartial } from "./deep-partial.js";
-// Types and values both, from one module — re-exporting the types from core would collide.
-export { input, output } from "./in-out.js";
-
-export * as locales from "../locales/index.js";
-
-// iso must be exported from top-level https://github.com/colinhacks/zod/issues/4491
-export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
-export * as iso from "./iso.js";
-
-// coerce
-export type {
-  ZodCoercedString,
-  ZodCoercedNumber,
-  ZodCoercedBigInt,
-  ZodCoercedBoolean,
-  ZodCoercedDate,
-} from "./coerce.js";
-export * as coerce from "./coerce.js";