npm - @performant-software/geospatial - Versions diffs - 3.1.25-beta.1 → 3.1.25 - Mend

@performant-software/geospatial 3.1.25-beta.1 → 3.1.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2038) hide show

package/dist/index.es416.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.es416.js","sources":["../../../node_modules/zod/v4/classic/schemas.js"],"sourcesContent":["import * as core from \"../core/index.js\";\nimport { util } from \"../core/index.js\";\nimport * as processors from \"../core/json-schema-processors.js\";\nimport { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from \"../core/to-json-schema.js\";\nimport * as checks from \"./checks.js\";\nimport * as iso from \"./iso.js\";\nimport * as parse from \"./parse.js\";\n// Lazy-bind builder methods.\n//\n// Builder methods (`.optional`, `.array`, `.refine`, ...) live as\n// non-enumerable getters on each concrete schema constructor's\n// prototype. On first access from an instance the getter allocates\n// `fn.bind(this)` and caches it as an own property on that instance,\n// so detached usage (`const m = schema.optional; m()`) still works\n// and the per-instance allocation only happens for methods actually\n// touched.\n//\n// One install per (prototype, group), memoized by `_installedGroups`.\nconst _installedGroups = /* @__PURE__ */ new WeakMap();\nfunction _installLazyMethods(inst, group, methods) {\n const proto = Object.getPrototypeOf(inst);\n let installed = _installedGroups.get(proto);\n if (!installed) {\n installed = new Set();\n _installedGroups.set(proto, installed);\n }\n if (installed.has(group))\n return;\n installed.add(group);\n for (const key in methods) {\n const fn = methods[key];\n Object.defineProperty(proto, key, {\n configurable: true,\n enumerable: false,\n get() {\n const bound = fn.bind(this);\n Object.defineProperty(this, key, {\n configurable: true,\n writable: true,\n enumerable: true,\n value: bound,\n });\n return bound;\n },\n set(v) {\n Object.defineProperty(this, key, {\n configurable: true,\n writable: true,\n enumerable: true,\n value: v,\n });\n },\n });\n }\n}\nexport const ZodType = /*@__PURE__*/ core.$constructor(\"ZodType\", (inst, def) => {\n core.$ZodType.init(inst, def);\n Object.assign(inst[\"~standard\"], {\n jsonSchema: {\n input: createStandardJSONSchemaMethod(inst, \"input\"),\n output: createStandardJSONSchemaMethod(inst, \"output\"),\n },\n });\n inst.toJSONSchema = createToJSONSchemaMethod(inst, {});\n inst.def = def;\n inst.type = def.type;\n Object.defineProperty(inst, \"_def\", { value: def });\n // Parse-family is intentionally kept as per-instance closures: these are\n // the hot path AND the most-detached methods (`arr.map(schema.parse)`,\n // `const { parse } = schema`, etc.). Eager closures here mean callers pay\n // ~12 closure allocations per schema but get monomorphic call sites and\n // detached usage that \"just works\".\n inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });\n inst.safeParse = (data, params) => parse.safeParse(inst, data, params);\n inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });\n inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);\n inst.spa = inst.safeParseAsync;\n inst.encode = (data, params) => parse.encode(inst, data, params);\n inst.decode = (data, params) => parse.decode(inst, data, params);\n inst.encodeAsync = async (data, params) => parse.encodeAsync(inst, data, params);\n inst.decodeAsync = async (data, params) => parse.decodeAsync(inst, data, params);\n inst.safeEncode = (data, params) => parse.safeEncode(inst, data, params);\n inst.safeDecode = (data, params) => parse.safeDecode(inst, data, params);\n inst.safeEncodeAsync = async (data, params) => parse.safeEncodeAsync(inst, data, params);\n inst.safeDecodeAsync = async (data, params) => parse.safeDecodeAsync(inst, data, params);\n // All builder methods are placed on the internal prototype as lazy-bind\n // getters. On first access per-instance, a bound thunk is allocated and\n // cached as an own property; subsequent accesses skip the getter. This\n // means: no per-instance allocation for unused methods, full\n // detachability preserved (`const m = schema.optional; m()` works), and\n // shared underlying function references across all instances.\n _installLazyMethods(inst, \"ZodType\", {\n check(...chks) {\n const def = this.def;\n return this.clone(util.mergeDefs(def, {\n checks: [\n ...(def.checks ?? []),\n ...chks.map((ch) => typeof ch === \"function\" ? { _zod: { check: ch, def: { check: \"custom\" }, onattach: [] } } : ch),\n ],\n }), { parent: true });\n },\n with(...chks) {\n return this.check(...chks);\n },\n clone(def, params) {\n return core.clone(this, def, params);\n },\n brand() {\n return this;\n },\n register(reg, meta) {\n reg.add(this, meta);\n return this;\n },\n refine(check, params) {\n return this.check(refine(check, params));\n },\n superRefine(refinement, params) {\n return this.check(superRefine(refinement, params));\n },\n overwrite(fn) {\n return this.check(checks.overwrite(fn));\n },\n optional() {\n return optional(this);\n },\n exactOptional() {\n return exactOptional(this);\n },\n nullable() {\n return nullable(this);\n },\n nullish() {\n return optional(nullable(this));\n },\n nonoptional(params) {\n return nonoptional(this, params);\n },\n array() {\n return array(this);\n },\n or(arg) {\n return union([this, arg]);\n },\n and(arg) {\n return intersection(this, arg);\n },\n transform(tx) {\n return pipe(this, transform(tx));\n },\n default(d) {\n return _default(this, d);\n },\n prefault(d) {\n return prefault(this, d);\n },\n catch(params) {\n return _catch(this, params);\n },\n pipe(target) {\n return pipe(this, target);\n },\n readonly() {\n return readonly(this);\n },\n describe(description) {\n const cl = this.clone();\n core.globalRegistry.add(cl, { description });\n return cl;\n },\n meta(...args) {\n // overloaded: meta() returns the registered metadata, meta(data)\n // returns a clone with `data` registered. The mapped type picks\n // up the second overload, so we accept variadic any-args and\n // return `any` to satisfy both at runtime.\n if (args.length === 0)\n return core.globalRegistry.get(this);\n const cl = this.clone();\n core.globalRegistry.add(cl, args[0]);\n return cl;\n },\n isOptional() {\n return this.safeParse(undefined).success;\n },\n isNullable() {\n return this.safeParse(null).success;\n },\n apply(fn) {\n return fn(this);\n },\n });\n Object.defineProperty(inst, \"description\", {\n get() {\n return core.globalRegistry.get(inst)?.description;\n },\n configurable: true,\n });\n return inst;\n});\n/** @internal */\nexport const _ZodString = /*@__PURE__*/ core.$constructor(\"_ZodString\", (inst, def) => {\n core.$ZodString.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);\n const bag = inst._zod.bag;\n inst.format = bag.format ?? null;\n inst.minLength = bag.minimum ?? null;\n inst.maxLength = bag.maximum ?? null;\n _installLazyMethods(inst, \"_ZodString\", {\n regex(...args) {\n return this.check(checks.regex(...args));\n },\n includes(...args) {\n return this.check(checks.includes(...args));\n },\n startsWith(...args) {\n return this.check(checks.startsWith(...args));\n },\n endsWith(...args) {\n return this.check(checks.endsWith(...args));\n },\n min(...args) {\n return this.check(checks.minLength(...args));\n },\n max(...args) {\n return this.check(checks.maxLength(...args));\n },\n length(...args) {\n return this.check(checks.length(...args));\n },\n nonempty(...args) {\n return this.check(checks.minLength(1, ...args));\n },\n lowercase(params) {\n return this.check(checks.lowercase(params));\n },\n uppercase(params) {\n return this.check(checks.uppercase(params));\n },\n trim() {\n return this.check(checks.trim());\n },\n normalize(...args) {\n return this.check(checks.normalize(...args));\n },\n toLowerCase() {\n return this.check(checks.toLowerCase());\n },\n toUpperCase() {\n return this.check(checks.toUpperCase());\n },\n slugify() {\n return this.check(checks.slugify());\n },\n });\n});\nexport const ZodString = /*@__PURE__*/ core.$constructor(\"ZodString\", (inst, def) => {\n core.$ZodString.init(inst, def);\n _ZodString.init(inst, def);\n inst.email = (params) => inst.check(core._email(ZodEmail, params));\n inst.url = (params) => inst.check(core._url(ZodURL, params));\n inst.jwt = (params) => inst.check(core._jwt(ZodJWT, params));\n inst.emoji = (params) => inst.check(core._emoji(ZodEmoji, params));\n inst.guid = (params) => inst.check(core._guid(ZodGUID, params));\n inst.uuid = (params) => inst.check(core._uuid(ZodUUID, params));\n inst.uuidv4 = (params) => inst.check(core._uuidv4(ZodUUID, params));\n inst.uuidv6 = (params) => inst.check(core._uuidv6(ZodUUID, params));\n inst.uuidv7 = (params) => inst.check(core._uuidv7(ZodUUID, params));\n inst.nanoid = (params) => inst.check(core._nanoid(ZodNanoID, params));\n inst.guid = (params) => inst.check(core._guid(ZodGUID, params));\n inst.cuid = (params) => inst.check(core._cuid(ZodCUID, params));\n inst.cuid2 = (params) => inst.check(core._cuid2(ZodCUID2, params));\n inst.ulid = (params) => inst.check(core._ulid(ZodULID, params));\n inst.base64 = (params) => inst.check(core._base64(ZodBase64, params));\n inst.base64url = (params) => inst.check(core._base64url(ZodBase64URL, params));\n inst.xid = (params) => inst.check(core._xid(ZodXID, params));\n inst.ksuid = (params) => inst.check(core._ksuid(ZodKSUID, params));\n inst.ipv4 = (params) => inst.check(core._ipv4(ZodIPv4, params));\n inst.ipv6 = (params) => inst.check(core._ipv6(ZodIPv6, params));\n inst.cidrv4 = (params) => inst.check(core._cidrv4(ZodCIDRv4, params));\n inst.cidrv6 = (params) => inst.check(core._cidrv6(ZodCIDRv6, params));\n inst.e164 = (params) => inst.check(core._e164(ZodE164, params));\n // iso\n inst.datetime = (params) => inst.check(iso.datetime(params));\n inst.date = (params) => inst.check(iso.date(params));\n inst.time = (params) => inst.check(iso.time(params));\n inst.duration = (params) => inst.check(iso.duration(params));\n});\nexport function string(params) {\n return core._string(ZodString, params);\n}\nexport const ZodStringFormat = /*@__PURE__*/ core.$constructor(\"ZodStringFormat\", (inst, def) => {\n core.$ZodStringFormat.init(inst, def);\n _ZodString.init(inst, def);\n});\nexport const ZodEmail = /*@__PURE__*/ core.$constructor(\"ZodEmail\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodEmail.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function email(params) {\n return core._email(ZodEmail, params);\n}\nexport const ZodGUID = /*@__PURE__*/ core.$constructor(\"ZodGUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodGUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function guid(params) {\n return core._guid(ZodGUID, params);\n}\nexport const ZodUUID = /*@__PURE__*/ core.$constructor(\"ZodUUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodUUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function uuid(params) {\n return core._uuid(ZodUUID, params);\n}\nexport function uuidv4(params) {\n return core._uuidv4(ZodUUID, params);\n}\n// ZodUUIDv6\nexport function uuidv6(params) {\n return core._uuidv6(ZodUUID, params);\n}\n// ZodUUIDv7\nexport function uuidv7(params) {\n return core._uuidv7(ZodUUID, params);\n}\nexport const ZodURL = /*@__PURE__*/ core.$constructor(\"ZodURL\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodURL.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function url(params) {\n return core._url(ZodURL, params);\n}\nexport function httpUrl(params) {\n return core._url(ZodURL, {\n protocol: core.regexes.httpProtocol,\n hostname: core.regexes.domain,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodEmoji = /*@__PURE__*/ core.$constructor(\"ZodEmoji\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodEmoji.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function emoji(params) {\n return core._emoji(ZodEmoji, params);\n}\nexport const ZodNanoID = /*@__PURE__*/ core.$constructor(\"ZodNanoID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodNanoID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function nanoid(params) {\n return core._nanoid(ZodNanoID, params);\n}\n/**\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link ZodCUID2} instead.\n * See https://github.com/paralleldrive/cuid.\n */\nexport const ZodCUID = /*@__PURE__*/ core.$constructor(\"ZodCUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\n/**\n * Validates a CUID v1 string.\n *\n * @deprecated CUID v1 is deprecated by its authors due to information leakage\n * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.\n * See https://github.com/paralleldrive/cuid.\n */\nexport function cuid(params) {\n return core._cuid(ZodCUID, params);\n}\nexport const ZodCUID2 = /*@__PURE__*/ core.$constructor(\"ZodCUID2\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCUID2.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cuid2(params) {\n return core._cuid2(ZodCUID2, params);\n}\nexport const ZodULID = /*@__PURE__*/ core.$constructor(\"ZodULID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodULID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ulid(params) {\n return core._ulid(ZodULID, params);\n}\nexport const ZodXID = /*@__PURE__*/ core.$constructor(\"ZodXID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodXID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function xid(params) {\n return core._xid(ZodXID, params);\n}\nexport const ZodKSUID = /*@__PURE__*/ core.$constructor(\"ZodKSUID\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodKSUID.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ksuid(params) {\n return core._ksuid(ZodKSUID, params);\n}\nexport const ZodIPv4 = /*@__PURE__*/ core.$constructor(\"ZodIPv4\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodIPv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ipv4(params) {\n return core._ipv4(ZodIPv4, params);\n}\nexport const ZodMAC = /*@__PURE__*/ core.$constructor(\"ZodMAC\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodMAC.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function mac(params) {\n return core._mac(ZodMAC, params);\n}\nexport const ZodIPv6 = /*@__PURE__*/ core.$constructor(\"ZodIPv6\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodIPv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function ipv6(params) {\n return core._ipv6(ZodIPv6, params);\n}\nexport const ZodCIDRv4 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv4\", (inst, def) => {\n core.$ZodCIDRv4.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cidrv4(params) {\n return core._cidrv4(ZodCIDRv4, params);\n}\nexport const ZodCIDRv6 = /*@__PURE__*/ core.$constructor(\"ZodCIDRv6\", (inst, def) => {\n core.$ZodCIDRv6.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function cidrv6(params) {\n return core._cidrv6(ZodCIDRv6, params);\n}\nexport const ZodBase64 = /*@__PURE__*/ core.$constructor(\"ZodBase64\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodBase64.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function base64(params) {\n return core._base64(ZodBase64, params);\n}\nexport const ZodBase64URL = /*@__PURE__*/ core.$constructor(\"ZodBase64URL\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodBase64URL.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function base64url(params) {\n return core._base64url(ZodBase64URL, params);\n}\nexport const ZodE164 = /*@__PURE__*/ core.$constructor(\"ZodE164\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodE164.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function e164(params) {\n return core._e164(ZodE164, params);\n}\nexport const ZodJWT = /*@__PURE__*/ core.$constructor(\"ZodJWT\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodJWT.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function jwt(params) {\n return core._jwt(ZodJWT, params);\n}\nexport const ZodCustomStringFormat = /*@__PURE__*/ core.$constructor(\"ZodCustomStringFormat\", (inst, def) => {\n // ZodStringFormat.init(inst, def);\n core.$ZodCustomStringFormat.init(inst, def);\n ZodStringFormat.init(inst, def);\n});\nexport function stringFormat(format, fnOrRegex, _params = {}) {\n return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);\n}\nexport function hostname(_params) {\n return core._stringFormat(ZodCustomStringFormat, \"hostname\", core.regexes.hostname, _params);\n}\nexport function hex(_params) {\n return core._stringFormat(ZodCustomStringFormat, \"hex\", core.regexes.hex, _params);\n}\nexport function hash(alg, params) {\n const enc = params?.enc ?? \"hex\";\n const format = `${alg}_${enc}`;\n const regex = core.regexes[format];\n if (!regex)\n throw new Error(`Unrecognized hash format: ${format}`);\n return core._stringFormat(ZodCustomStringFormat, format, regex, params);\n}\nexport const ZodNumber = /*@__PURE__*/ core.$constructor(\"ZodNumber\", (inst, def) => {\n core.$ZodNumber.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);\n _installLazyMethods(inst, \"ZodNumber\", {\n gt(value, params) {\n return this.check(checks.gt(value, params));\n },\n gte(value, params) {\n return this.check(checks.gte(value, params));\n },\n min(value, params) {\n return this.check(checks.gte(value, params));\n },\n lt(value, params) {\n return this.check(checks.lt(value, params));\n },\n lte(value, params) {\n return this.check(checks.lte(value, params));\n },\n max(value, params) {\n return this.check(checks.lte(value, params));\n },\n int(params) {\n return this.check(int(params));\n },\n safe(params) {\n return this.check(int(params));\n },\n positive(params) {\n return this.check(checks.gt(0, params));\n },\n nonnegative(params) {\n return this.check(checks.gte(0, params));\n },\n negative(params) {\n return this.check(checks.lt(0, params));\n },\n nonpositive(params) {\n return this.check(checks.lte(0, params));\n },\n multipleOf(value, params) {\n return this.check(checks.multipleOf(value, params));\n },\n step(value, params) {\n return this.check(checks.multipleOf(value, params));\n },\n finite() {\n return this;\n },\n });\n const bag = inst._zod.bag;\n inst.minValue =\n Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;\n inst.maxValue =\n Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;\n inst.isInt = (bag.format ?? \"\").includes(\"int\") || Number.isSafeInteger(bag.multipleOf ?? 0.5);\n inst.isFinite = true;\n inst.format = bag.format ?? null;\n});\nexport function number(params) {\n return core._number(ZodNumber, params);\n}\nexport const ZodNumberFormat = /*@__PURE__*/ core.$constructor(\"ZodNumberFormat\", (inst, def) => {\n core.$ZodNumberFormat.init(inst, def);\n ZodNumber.init(inst, def);\n});\nexport function int(params) {\n return core._int(ZodNumberFormat, params);\n}\nexport function float32(params) {\n return core._float32(ZodNumberFormat, params);\n}\nexport function float64(params) {\n return core._float64(ZodNumberFormat, params);\n}\nexport function int32(params) {\n return core._int32(ZodNumberFormat, params);\n}\nexport function uint32(params) {\n return core._uint32(ZodNumberFormat, params);\n}\nexport const ZodBoolean = /*@__PURE__*/ core.$constructor(\"ZodBoolean\", (inst, def) => {\n core.$ZodBoolean.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.booleanProcessor(inst, ctx, json, params);\n});\nexport function boolean(params) {\n return core._boolean(ZodBoolean, params);\n}\nexport const ZodBigInt = /*@__PURE__*/ core.$constructor(\"ZodBigInt\", (inst, def) => {\n core.$ZodBigInt.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);\n inst.gte = (value, params) => inst.check(checks.gte(value, params));\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.gt = (value, params) => inst.check(checks.gt(value, params));\n inst.gte = (value, params) => inst.check(checks.gte(value, params));\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.lt = (value, params) => inst.check(checks.lt(value, params));\n inst.lte = (value, params) => inst.check(checks.lte(value, params));\n inst.max = (value, params) => inst.check(checks.lte(value, params));\n inst.positive = (params) => inst.check(checks.gt(BigInt(0), params));\n inst.negative = (params) => inst.check(checks.lt(BigInt(0), params));\n inst.nonpositive = (params) => inst.check(checks.lte(BigInt(0), params));\n inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params));\n inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));\n const bag = inst._zod.bag;\n inst.minValue = bag.minimum ?? null;\n inst.maxValue = bag.maximum ?? null;\n inst.format = bag.format ?? null;\n});\nexport function bigint(params) {\n return core._bigint(ZodBigInt, params);\n}\nexport const ZodBigIntFormat = /*@__PURE__*/ core.$constructor(\"ZodBigIntFormat\", (inst, def) => {\n core.$ZodBigIntFormat.init(inst, def);\n ZodBigInt.init(inst, def);\n});\n// int64\nexport function int64(params) {\n return core._int64(ZodBigIntFormat, params);\n}\n// uint64\nexport function uint64(params) {\n return core._uint64(ZodBigIntFormat, params);\n}\nexport const ZodSymbol = /*@__PURE__*/ core.$constructor(\"ZodSymbol\", (inst, def) => {\n core.$ZodSymbol.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.symbolProcessor(inst, ctx, json, params);\n});\nexport function symbol(params) {\n return core._symbol(ZodSymbol, params);\n}\nexport const ZodUndefined = /*@__PURE__*/ core.$constructor(\"ZodUndefined\", (inst, def) => {\n core.$ZodUndefined.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.undefinedProcessor(inst, ctx, json, params);\n});\nfunction _undefined(params) {\n return core._undefined(ZodUndefined, params);\n}\nexport { _undefined as undefined };\nexport const ZodNull = /*@__PURE__*/ core.$constructor(\"ZodNull\", (inst, def) => {\n core.$ZodNull.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nullProcessor(inst, ctx, json, params);\n});\nfunction _null(params) {\n return core._null(ZodNull, params);\n}\nexport { _null as null };\nexport const ZodAny = /*@__PURE__*/ core.$constructor(\"ZodAny\", (inst, def) => {\n core.$ZodAny.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.anyProcessor(inst, ctx, json, params);\n});\nexport function any() {\n return core._any(ZodAny);\n}\nexport const ZodUnknown = /*@__PURE__*/ core.$constructor(\"ZodUnknown\", (inst, def) => {\n core.$ZodUnknown.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unknownProcessor(inst, ctx, json, params);\n});\nexport function unknown() {\n return core._unknown(ZodUnknown);\n}\nexport const ZodNever = /*@__PURE__*/ core.$constructor(\"ZodNever\", (inst, def) => {\n core.$ZodNever.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.neverProcessor(inst, ctx, json, params);\n});\nexport function never(params) {\n return core._never(ZodNever, params);\n}\nexport const ZodVoid = /*@__PURE__*/ core.$constructor(\"ZodVoid\", (inst, def) => {\n core.$ZodVoid.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.voidProcessor(inst, ctx, json, params);\n});\nfunction _void(params) {\n return core._void(ZodVoid, params);\n}\nexport { _void as void };\nexport const ZodDate = /*@__PURE__*/ core.$constructor(\"ZodDate\", (inst, def) => {\n core.$ZodDate.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);\n inst.min = (value, params) => inst.check(checks.gte(value, params));\n inst.max = (value, params) => inst.check(checks.lte(value, params));\n const c = inst._zod.bag;\n inst.minDate = c.minimum ? new Date(c.minimum) : null;\n inst.maxDate = c.maximum ? new Date(c.maximum) : null;\n});\nexport function date(params) {\n return core._date(ZodDate, params);\n}\nexport const ZodArray = /*@__PURE__*/ core.$constructor(\"ZodArray\", (inst, def) => {\n core.$ZodArray.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.arrayProcessor(inst, ctx, json, params);\n inst.element = def.element;\n _installLazyMethods(inst, \"ZodArray\", {\n min(n, params) {\n return this.check(checks.minLength(n, params));\n },\n nonempty(params) {\n return this.check(checks.minLength(1, params));\n },\n max(n, params) {\n return this.check(checks.maxLength(n, params));\n },\n length(n, params) {\n return this.check(checks.length(n, params));\n },\n unwrap() {\n return this.element;\n },\n });\n});\nexport function array(element, params) {\n return core._array(ZodArray, element, params);\n}\n// .keyof\nexport function keyof(schema) {\n const shape = schema._zod.def.shape;\n return _enum(Object.keys(shape));\n}\nexport const ZodObject = /*@__PURE__*/ core.$constructor(\"ZodObject\", (inst, def) => {\n core.$ZodObjectJIT.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.objectProcessor(inst, ctx, json, params);\n util.defineLazy(inst, \"shape\", () => {\n return def.shape;\n });\n _installLazyMethods(inst, \"ZodObject\", {\n keyof() {\n return _enum(Object.keys(this._zod.def.shape));\n },\n catchall(catchall) {\n return this.clone({ ...this._zod.def, catchall: catchall });\n },\n passthrough() {\n return this.clone({ ...this._zod.def, catchall: unknown() });\n },\n loose() {\n return this.clone({ ...this._zod.def, catchall: unknown() });\n },\n strict() {\n return this.clone({ ...this._zod.def, catchall: never() });\n },\n strip() {\n return this.clone({ ...this._zod.def, catchall: undefined });\n },\n extend(incoming) {\n return util.extend(this, incoming);\n },\n safeExtend(incoming) {\n return util.safeExtend(this, incoming);\n },\n merge(other) {\n return util.merge(this, other);\n },\n pick(mask) {\n return util.pick(this, mask);\n },\n omit(mask) {\n return util.omit(this, mask);\n },\n partial(...args) {\n return util.partial(ZodOptional, this, args[0]);\n },\n required(...args) {\n return util.required(ZodNonOptional, this, args[0]);\n },\n });\n});\nexport function object(shape, params) {\n const def = {\n type: \"object\",\n shape: shape ?? {},\n ...util.normalizeParams(params),\n };\n return new ZodObject(def);\n}\n// strictObject\nexport function strictObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: never(),\n ...util.normalizeParams(params),\n });\n}\n// looseObject\nexport function looseObject(shape, params) {\n return new ZodObject({\n type: \"object\",\n shape,\n catchall: unknown(),\n ...util.normalizeParams(params),\n });\n}\nexport const ZodUnion = /*@__PURE__*/ core.$constructor(\"ZodUnion\", (inst, def) => {\n core.$ZodUnion.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n inst.options = def.options;\n});\nexport function union(options, params) {\n return new ZodUnion({\n type: \"union\",\n options: options,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodXor = /*@__PURE__*/ core.$constructor(\"ZodXor\", (inst, def) => {\n ZodUnion.init(inst, def);\n core.$ZodXor.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);\n inst.options = def.options;\n});\n/** Creates an exclusive union (XOR) where exactly one option must match.\n * Unlike regular unions that succeed when any option matches, xor fails if\n * zero or more than one option matches the input. */\nexport function xor(options, params) {\n return new ZodXor({\n type: \"union\",\n options: options,\n inclusive: false,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodDiscriminatedUnion = /*@__PURE__*/ core.$constructor(\"ZodDiscriminatedUnion\", (inst, def) => {\n ZodUnion.init(inst, def);\n core.$ZodDiscriminatedUnion.init(inst, def);\n});\nexport function discriminatedUnion(discriminator, options, params) {\n // const [options, params] = args;\n return new ZodDiscriminatedUnion({\n type: \"union\",\n options,\n discriminator,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodIntersection = /*@__PURE__*/ core.$constructor(\"ZodIntersection\", (inst, def) => {\n core.$ZodIntersection.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.intersectionProcessor(inst, ctx, json, params);\n});\nexport function intersection(left, right) {\n return new ZodIntersection({\n type: \"intersection\",\n left: left,\n right: right,\n });\n}\nexport const ZodTuple = /*@__PURE__*/ core.$constructor(\"ZodTuple\", (inst, def) => {\n core.$ZodTuple.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);\n inst.rest = (rest) => inst.clone({\n ...inst._zod.def,\n rest: rest,\n });\n});\nexport function tuple(items, _paramsOrRest, _params) {\n const hasRest = _paramsOrRest instanceof core.$ZodType;\n const params = hasRest ? _params : _paramsOrRest;\n const rest = hasRest ? _paramsOrRest : null;\n return new ZodTuple({\n type: \"tuple\",\n items: items,\n rest,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodRecord = /*@__PURE__*/ core.$constructor(\"ZodRecord\", (inst, def) => {\n core.$ZodRecord.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.recordProcessor(inst, ctx, json, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n});\nexport function record(keyType, valueType, params) {\n // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()\n if (!valueType || !valueType._zod) {\n return new ZodRecord({\n type: \"record\",\n keyType: string(),\n valueType: keyType,\n ...util.normalizeParams(valueType),\n });\n }\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\n// type alksjf = core.output<core.$ZodRecordKey>;\nexport function partialRecord(keyType, valueType, params) {\n const k = core.clone(keyType);\n k._zod.values = undefined;\n return new ZodRecord({\n type: \"record\",\n keyType: k,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport function looseRecord(keyType, valueType, params) {\n return new ZodRecord({\n type: \"record\",\n keyType,\n valueType: valueType,\n mode: \"loose\",\n ...util.normalizeParams(params),\n });\n}\nexport const ZodMap = /*@__PURE__*/ core.$constructor(\"ZodMap\", (inst, def) => {\n core.$ZodMap.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);\n inst.keyType = def.keyType;\n inst.valueType = def.valueType;\n inst.min = (...args) => inst.check(core._minSize(...args));\n inst.nonempty = (params) => inst.check(core._minSize(1, params));\n inst.max = (...args) => inst.check(core._maxSize(...args));\n inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function map(keyType, valueType, params) {\n return new ZodMap({\n type: \"map\",\n keyType: keyType,\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodSet = /*@__PURE__*/ core.$constructor(\"ZodSet\", (inst, def) => {\n core.$ZodSet.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.setProcessor(inst, ctx, json, params);\n inst.min = (...args) => inst.check(core._minSize(...args));\n inst.nonempty = (params) => inst.check(core._minSize(1, params));\n inst.max = (...args) => inst.check(core._maxSize(...args));\n inst.size = (...args) => inst.check(core._size(...args));\n});\nexport function set(valueType, params) {\n return new ZodSet({\n type: \"set\",\n valueType: valueType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodEnum = /*@__PURE__*/ core.$constructor(\"ZodEnum\", (inst, def) => {\n core.$ZodEnum.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);\n inst.enum = def.entries;\n inst.options = Object.values(def.entries);\n const keys = new Set(Object.keys(def.entries));\n inst.extract = (values, params) => {\n const newEntries = {};\n for (const value of values) {\n if (keys.has(value)) {\n newEntries[value] = def.entries[value];\n }\n else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util.normalizeParams(params),\n entries: newEntries,\n });\n };\n inst.exclude = (values, params) => {\n const newEntries = { ...def.entries };\n for (const value of values) {\n if (keys.has(value)) {\n delete newEntries[value];\n }\n else\n throw new Error(`Key ${value} not found in enum`);\n }\n return new ZodEnum({\n ...def,\n checks: [],\n ...util.normalizeParams(params),\n entries: newEntries,\n });\n };\n});\nfunction _enum(values, params) {\n const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\nexport { _enum as enum };\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport function nativeEnum(entries, params) {\n return new ZodEnum({\n type: \"enum\",\n entries,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodLiteral = /*@__PURE__*/ core.$constructor(\"ZodLiteral\", (inst, def) => {\n core.$ZodLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.literalProcessor(inst, ctx, json, params);\n inst.values = new Set(def.values);\n Object.defineProperty(inst, \"value\", {\n get() {\n if (def.values.length > 1) {\n throw new Error(\"This schema contains multiple valid literal values. Use `.values` instead.\");\n }\n return def.values[0];\n },\n });\n});\nexport function literal(value, params) {\n return new ZodLiteral({\n type: \"literal\",\n values: Array.isArray(value) ? value : [value],\n ...util.normalizeParams(params),\n });\n}\nexport const ZodFile = /*@__PURE__*/ core.$constructor(\"ZodFile\", (inst, def) => {\n core.$ZodFile.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.fileProcessor(inst, ctx, json, params);\n inst.min = (size, params) => inst.check(core._minSize(size, params));\n inst.max = (size, params) => inst.check(core._maxSize(size, params));\n inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));\n});\nexport function file(params) {\n return core._file(ZodFile, params);\n}\nexport const ZodTransform = /*@__PURE__*/ core.$constructor(\"ZodTransform\", (inst, def) => {\n core.$ZodTransform.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.transformProcessor(inst, ctx, json, params);\n inst._zod.parse = (payload, _ctx) => {\n if (_ctx.direction === \"backward\") {\n throw new core.$ZodEncodeError(inst.constructor.name);\n }\n payload.addIssue = (issue) => {\n if (typeof issue === \"string\") {\n payload.issues.push(util.issue(issue, payload.value, def));\n }\n else {\n // for Zod 3 backwards compatibility\n const _issue = issue;\n if (_issue.fatal)\n _issue.continue = false;\n _issue.code ?? (_issue.code = \"custom\");\n _issue.input ?? (_issue.input = payload.value);\n _issue.inst ?? (_issue.inst = inst);\n // _issue.continue ??= true;\n payload.issues.push(util.issue(_issue));\n }\n };\n const output = def.transform(payload.value, payload);\n if (output instanceof Promise) {\n return output.then((output) => {\n payload.value = output;\n payload.fallback = true;\n return payload;\n });\n }\n payload.value = output;\n payload.fallback = true;\n return payload;\n };\n});\nexport function transform(fn) {\n return new ZodTransform({\n type: \"transform\",\n transform: fn,\n });\n}\nexport const ZodOptional = /*@__PURE__*/ core.$constructor(\"ZodOptional\", (inst, def) => {\n core.$ZodOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function optional(innerType) {\n return new ZodOptional({\n type: \"optional\",\n innerType: innerType,\n });\n}\nexport const ZodExactOptional = /*@__PURE__*/ core.$constructor(\"ZodExactOptional\", (inst, def) => {\n core.$ZodExactOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function exactOptional(innerType) {\n return new ZodExactOptional({\n type: \"optional\",\n innerType: innerType,\n });\n}\nexport const ZodNullable = /*@__PURE__*/ core.$constructor(\"ZodNullable\", (inst, def) => {\n core.$ZodNullable.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nullableProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nullable(innerType) {\n return new ZodNullable({\n type: \"nullable\",\n innerType: innerType,\n });\n}\n// nullish\nexport function nullish(innerType) {\n return optional(nullable(innerType));\n}\nexport const ZodDefault = /*@__PURE__*/ core.$constructor(\"ZodDefault\", (inst, def) => {\n core.$ZodDefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.defaultProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeDefault = inst.unwrap;\n});\nexport function _default(innerType, defaultValue) {\n return new ZodDefault({\n type: \"default\",\n innerType: innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n },\n });\n}\nexport const ZodPrefault = /*@__PURE__*/ core.$constructor(\"ZodPrefault\", (inst, def) => {\n core.$ZodPrefault.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.prefaultProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function prefault(innerType, defaultValue) {\n return new ZodPrefault({\n type: \"prefault\",\n innerType: innerType,\n get defaultValue() {\n return typeof defaultValue === \"function\" ? defaultValue() : util.shallowClone(defaultValue);\n },\n });\n}\nexport const ZodNonOptional = /*@__PURE__*/ core.$constructor(\"ZodNonOptional\", (inst, def) => {\n core.$ZodNonOptional.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nonoptionalProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function nonoptional(innerType, params) {\n return new ZodNonOptional({\n type: \"nonoptional\",\n innerType: innerType,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodSuccess = /*@__PURE__*/ core.$constructor(\"ZodSuccess\", (inst, def) => {\n core.$ZodSuccess.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.successProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function success(innerType) {\n return new ZodSuccess({\n type: \"success\",\n innerType: innerType,\n });\n}\nexport const ZodCatch = /*@__PURE__*/ core.$constructor(\"ZodCatch\", (inst, def) => {\n core.$ZodCatch.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.catchProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n inst.removeCatch = inst.unwrap;\n});\nfunction _catch(innerType, catchValue) {\n return new ZodCatch({\n type: \"catch\",\n innerType: innerType,\n catchValue: (typeof catchValue === \"function\" ? catchValue : () => catchValue),\n });\n}\nexport { _catch as catch };\nexport const ZodNaN = /*@__PURE__*/ core.$constructor(\"ZodNaN\", (inst, def) => {\n core.$ZodNaN.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.nanProcessor(inst, ctx, json, params);\n});\nexport function nan(params) {\n return core._nan(ZodNaN, params);\n}\nexport const ZodPipe = /*@__PURE__*/ core.$constructor(\"ZodPipe\", (inst, def) => {\n core.$ZodPipe.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.pipeProcessor(inst, ctx, json, params);\n inst.in = def.in;\n inst.out = def.out;\n});\nexport function pipe(in_, out) {\n return new ZodPipe({\n type: \"pipe\",\n in: in_,\n out: out,\n // ...util.normalizeParams(params),\n });\n}\nexport const ZodCodec = /*@__PURE__*/ core.$constructor(\"ZodCodec\", (inst, def) => {\n ZodPipe.init(inst, def);\n core.$ZodCodec.init(inst, def);\n});\nexport function codec(in_, out, params) {\n return new ZodCodec({\n type: \"pipe\",\n in: in_,\n out: out,\n transform: params.decode,\n reverseTransform: params.encode,\n });\n}\nexport function invertCodec(codec) {\n const def = codec._zod.def;\n return new ZodCodec({\n type: \"pipe\",\n in: def.out,\n out: def.in,\n transform: def.reverseTransform,\n reverseTransform: def.transform,\n });\n}\nexport const ZodPreprocess = /*@__PURE__*/ core.$constructor(\"ZodPreprocess\", (inst, def) => {\n ZodPipe.init(inst, def);\n core.$ZodPreprocess.init(inst, def);\n});\nexport const ZodReadonly = /*@__PURE__*/ core.$constructor(\"ZodReadonly\", (inst, def) => {\n core.$ZodReadonly.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.readonlyProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function readonly(innerType) {\n return new ZodReadonly({\n type: \"readonly\",\n innerType: innerType,\n });\n}\nexport const ZodTemplateLiteral = /*@__PURE__*/ core.$constructor(\"ZodTemplateLiteral\", (inst, def) => {\n core.$ZodTemplateLiteral.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.templateLiteralProcessor(inst, ctx, json, params);\n});\nexport function templateLiteral(parts, params) {\n return new ZodTemplateLiteral({\n type: \"template_literal\",\n parts,\n ...util.normalizeParams(params),\n });\n}\nexport const ZodLazy = /*@__PURE__*/ core.$constructor(\"ZodLazy\", (inst, def) => {\n core.$ZodLazy.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.lazyProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.getter();\n});\nexport function lazy(getter) {\n return new ZodLazy({\n type: \"lazy\",\n getter: getter,\n });\n}\nexport const ZodPromise = /*@__PURE__*/ core.$constructor(\"ZodPromise\", (inst, def) => {\n core.$ZodPromise.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.promiseProcessor(inst, ctx, json, params);\n inst.unwrap = () => inst._zod.def.innerType;\n});\nexport function promise(innerType) {\n return new ZodPromise({\n type: \"promise\",\n innerType: innerType,\n });\n}\nexport const ZodFunction = /*@__PURE__*/ core.$constructor(\"ZodFunction\", (inst, def) => {\n core.$ZodFunction.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.functionProcessor(inst, ctx, json, params);\n});\nexport function _function(params) {\n return new ZodFunction({\n type: \"function\",\n input: Array.isArray(params?.input) ? tuple(params?.input) : (params?.input ?? array(unknown())),\n output: params?.output ?? unknown(),\n });\n}\nexport { _function as function };\nexport const ZodCustom = /*@__PURE__*/ core.$constructor(\"ZodCustom\", (inst, def) => {\n core.$ZodCustom.init(inst, def);\n ZodType.init(inst, def);\n inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);\n});\n// custom checks\nexport function check(fn) {\n const ch = new core.$ZodCheck({\n check: \"custom\",\n // ...util.normalizeParams(params),\n });\n ch._zod.check = fn;\n return ch;\n}\nexport function custom(fn, _params) {\n return core._custom(ZodCustom, fn ?? (() => true), _params);\n}\nexport function refine(fn, _params = {}) {\n return core._refine(ZodCustom, fn, _params);\n}\n// superRefine\nexport function superRefine(fn, params) {\n return core._superRefine(fn, params);\n}\n// Re-export describe and meta from core\nexport const describe = core.describe;\nexport const meta = core.meta;\nfunction _instanceof(cls, params = {}) {\n const inst = new ZodCustom({\n type: \"custom\",\n check: \"custom\",\n fn: (data) => data instanceof cls,\n abort: true,\n ...util.normalizeParams(params),\n });\n inst._zod.bag.Class = cls;\n // Override check to emit invalid_type instead of custom\n inst._zod.check = (payload) => {\n if (!(payload.value instanceof cls)) {\n payload.issues.push({\n code: \"invalid_type\",\n expected: cls.name,\n input: payload.value,\n inst,\n path: [...(inst._zod.def.path ?? [])],\n });\n }\n };\n return inst;\n}\nexport { _instanceof as instanceof };\n// stringbool\nexport const stringbool = (...args) => core._stringbool({\n Codec: ZodCodec,\n Boolean: ZodBoolean,\n String: ZodString,\n}, ...args);\nexport function json(params) {\n const jsonSchema = lazy(() => {\n return union([string(params), number(), boolean(), _null(), array(jsonSchema), record(string(), jsonSchema)]);\n });\n return jsonSchema;\n}\n// preprocess\nexport function preprocess(fn, schema) {\n return new ZodPreprocess({\n type: \"pipe\",\n in: transform(fn),\n out: schema,\n });\n}\n"],"names":["_installedGroups","_installLazyMethods","inst","group","methods","proto","installed","key","fn","bound","v","ZodType","core.$constructor","def","core.$ZodType","createStandardJSONSchemaMethod","createToJSONSchemaMethod","data","params","parse.parse","parse.safeParse","parse.parseAsync","parse.safeParseAsync","parse.encode","parse.decode","parse.encodeAsync","parse.decodeAsync","parse.safeEncode","parse.safeDecode","parse.safeEncodeAsync","parse.safeDecodeAsync","chks","util.mergeDefs","ch","core.clone","reg","meta","check","refine","refinement","superRefine","checks.overwrite","optional","exactOptional","nullable","nonoptional","array","arg","union","intersection","tx","pipe","transform","d","_default","prefault","_catch","target","readonly","description","cl","core.globalRegistry","args","_ZodString","core.$ZodString","ctx","json","processors.stringProcessor","bag","checks.regex","checks.includes","checks.startsWith","checks.endsWith","checks.minLength","checks.maxLength","checks.length","checks.lowercase","checks.uppercase","checks.trim","checks.normalize","checks.toLowerCase","checks.toUpperCase","checks.slugify","ZodString","core._email","ZodEmail","core._url","ZodURL","core._jwt","ZodJWT","core._emoji","ZodEmoji","core._guid","ZodGUID","core._uuid","ZodUUID","core._uuidv4","core._uuidv6","core._uuidv7","core._nanoid","ZodNanoID","core._cuid","ZodCUID","core._cuid2","ZodCUID2","core._ulid","ZodULID","core._base64","ZodBase64","core._base64url","ZodBase64URL","core._xid","ZodXID","core._ksuid","ZodKSUID","core._ipv4","ZodIPv4","core._ipv6","ZodIPv6","core._cidrv4","ZodCIDRv4","core._cidrv6","ZodCIDRv6","core._e164","ZodE164","iso.datetime","iso.date","iso.time","iso.duration","string","core._string","ZodStringFormat","core.$ZodStringFormat","core.$ZodEmail","core.$ZodGUID","core.$ZodUUID","core.$ZodURL","core.$ZodEmoji","core.$ZodNanoID","core.$ZodCUID","core.$ZodCUID2","core.$ZodULID","core.$ZodXID","core.$ZodKSUID","core.$ZodIPv4","core.$ZodIPv6","core.$ZodCIDRv4","core.$ZodCIDRv6","core.$ZodBase64","core.$ZodBase64URL","core.$ZodE164","core.$ZodJWT","ZodNumber","core.$ZodNumber","processors.numberProcessor","value","checks.gt","checks.gte","checks.lt","checks.lte","int","checks.multipleOf","number","core._number","ZodNumberFormat","core.$ZodNumberFormat","core._int","ZodBoolean","core.$ZodBoolean","processors.booleanProcessor","boolean","core._boolean","ZodUnknown","core.$ZodUnknown","processors.unknownProcessor","unknown","core._unknown","ZodNever","core.$ZodNever","processors.neverProcessor","never","core._never","ZodDate","core.$ZodDate","processors.dateProcessor","c","ZodArray","core.$ZodArray","processors.arrayProcessor","n","element","core._array","ZodObject","core.$ZodObjectJIT","processors.objectProcessor","util.defineLazy","_enum","catchall","incoming","util.extend","util.safeExtend","other","util.merge","mask","util.pick","util.omit","util.partial","ZodOptional","util.required","ZodNonOptional","object","shape","util.normalizeParams","looseObject","ZodUnion","core.$ZodUnion","processors.unionProcessor","options","ZodDiscriminatedUnion","core.$ZodDiscriminatedUnion","discriminatedUnion","discriminator","ZodIntersection","core.$ZodIntersection","processors.intersectionProcessor","left","right","ZodTuple","core.$ZodTuple","processors.tupleProcessor","rest","tuple","items","_paramsOrRest","_params","hasRest","ZodRecord","core.$ZodRecord","processors.recordProcessor","record","keyType","valueType","ZodEnum","core.$ZodEnum","processors.enumProcessor","keys","values","newEntries","entries","ZodLiteral","core.$ZodLiteral","processors.literalProcessor","literal","ZodTransform","core.$ZodTransform","processors.transformProcessor","payload","_ctx","core.$ZodEncodeError","issue","util.issue","_issue","output","core.$ZodOptional","processors.optionalProcessor","innerType","ZodExactOptional","core.$ZodExactOptional","ZodNullable","core.$ZodNullable","processors.nullableProcessor","ZodDefault","core.$ZodDefault","processors.defaultProcessor","defaultValue","util.shallowClone","ZodPrefault","core.$ZodPrefault","processors.prefaultProcessor","core.$ZodNonOptional","processors.nonoptionalProcessor","ZodCatch","core.$ZodCatch","processors.catchProcessor","catchValue","ZodPipe","core.$ZodPipe","processors.pipeProcessor","in_","out","ZodReadonly","core.$ZodReadonly","processors.readonlyProcessor","ZodCustom","core.$ZodCustom","processors.customProcessor","core._refine","core._superRefine"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es417.js ADDED Viewed

@@ -0,0 +1,206 @@
+import { computeBbox as w } from "./index.es196.js";
+import { flipY as m, isPoint as d, isLineString as u, isPolygon as I, isMultiPoint as F, isMultiLineString as c, isMultiPolygon as v } from "./index.es275.js";
+import { mergeOptions as l } from "./index.es198.js";
+import { computeDistortionsFromPartialDerivatives as k } from "./index.es309.js";
+import { Straight as R } from "./index.es430.js";
+import { Helmert as L } from "./index.es424.js";
+import { Polynomial1 as E } from "./index.es425.js";
+import { Polynomial2 as H } from "./index.es426.js";
+import { Polynomial3 as N } from "./index.es427.js";
+import { Projective as T } from "./index.es428.js";
+import { RBF as B } from "./index.es429.js";
+import { thinPlateKernel as Y, linearKernel as W } from "./index.es485.js";
+import { euclideanNorm as P } from "./index.es486.js";
+import { defaultGeneralGcpTransformerOptions as X, refinementOptionsFromForwardTransformOptions as p, refinementOptionsFromBackwardTransformOptions as h, nonWarpingTransformationTypes as b } from "./index.es205.js";
+import { refineLineString as g, refineRing as y, getSourceRefinementResolution as O } from "./index.es431.js";
+import { generalGcpToPointForForward as S, generalGcpToPointForBackward as M, invertGeneralGcp as D } from "./index.es418.js";
+class nr {
+  generalGcpsInternal;
+  sourcePointsInternal;
+  destinationPointsInternal;
+  type;
+  transformerOptions;
+  forwardTransformation;
+  backwardTransformation;
+  /**
+   * Create a BaseGcpTransformer
+   *
+   * @param generalGcps - An array of General Ground Control Points (GCPs)
+   * @param type - The transformation type
+   * @param partialGeneralGcpTransformerOptions - General GCP Transformer options
+   */
+  constructor(r, n = "polynomial", a) {
+    if (this.transformerOptions = l(X, a), r.length === 0)
+      throw new Error("No control points");
+    this.generalGcpsInternal = r, this.sourcePointsInternal = this.generalGcpsInternal.map((t) => {
+      const i = this.transformerOptions.differentHandedness ? m(t.source) : t.source;
+      return this.transformerOptions.preForward(i);
+    }), this.destinationPointsInternal = this.generalGcpsInternal.map((t) => this.transformerOptions.preBackward(t.destination)), this.type = n;
+  }
+  /**
+   * Get the forward transformation. Create if it doesn't exist yet.
+   */
+  getForwardTransformationInternal() {
+    return this.forwardTransformation || (this.forwardTransformation = this.createTransformation(this.sourcePointsInternal, this.destinationPointsInternal)), this.forwardTransformation;
+  }
+  /**
+   * Get the backward transformation. Create if it doesn't exist yet.
+   */
+  getBackwardTransformationInternal() {
+    return this.backwardTransformation || (this.backwardTransformation = this.createTransformation(this.destinationPointsInternal, this.sourcePointsInternal)), this.backwardTransformation;
+  }
+  /**
+   * Create the (forward or backward) transformation.
+   *
+   * Results in forward transformation if source and destination points are entered as such.
+   * Results in backward if source points are entered for destination points and vice versa.
+   *
+   * Results in a transformation of this instance's transformation type.
+   *
+   * @param sourcePoints - source points
+   * @param destinationPoints - destination points
+   * @returns Transformation
+   */
+  createTransformation(r, n) {
+    if (this.type === "straight")
+      return new R(r, n);
+    if (this.type === "helmert")
+      return new L(r, n);
+    if (this.type === "polynomial1" || this.type === "polynomial")
+      return new E(r, n);
+    if (this.type === "polynomial2")
+      return new H(r, n);
+    if (this.type === "polynomial3")
+      return new N(r, n);
+    if (this.type === "projective")
+      return new T(r, n);
+    if (this.type === "thinPlateSpline")
+      return new B(r, n, Y, P, "thinPlateSpline");
+    if (this.type === "linear")
+      return new B(r, n, W, P, "linear");
+    throw new Error(`Unsupported transformation type: ${this.type}`);
+  }
+  /**
+   * Transform a geometry forward from source space to destination space
+   *
+   * @param sourceGeometry - Geometry to transform
+   * @param partialGeneralGcpTransformOptions - General GCP Transform options
+   * @param generalGcpToP - Return type function
+   * @returns Forward transform of input geometry
+   */
+  transformForwardInternal(r, n, a = S) {
+    let t = l(this.transformerOptions, n);
+    if (this.isNonWarping() && (t = l(t, { maxDepth: 0 })), t.isMultiGeometry) {
+      if (t && (t = l(t, {
+        isMultiGeometry: !1
+      })), F(r))
+        return r.map((i) => this.transformPointForwardInternal(i, t, a));
+      if (c(r))
+        return r.map((i) => this.transformLineStringForwardInternal(i, t, a));
+      if (v(r))
+        return r.map((i) => this.transformPolygonForwardInternal(i, t, a));
+      throw new Error("Geometry type not supported");
+    } else {
+      if (d(r))
+        return this.transformPointForwardInternal(r, t, a);
+      if (u(r))
+        return this.transformLineStringForwardInternal(r, t, a);
+      if (I(r))
+        return this.transformPolygonForwardInternal(r, t, a);
+      throw new Error("Geometry type not supported");
+    }
+  }
+  /**
+   * Transform a geometry backward from destination space to source space
+   *
+   * @param destinationGeometry - Geometry to transform
+   * @param partialGeneralGcpTransformOptions - General GCP Transform options
+   * @param generalGcpToP - Return type function
+   * @returns Backward transform of input geometry
+   */
+  transformBackwardInternal(r, n, a = M) {
+    let t = l(this.transformerOptions, n);
+    if (this.isNonWarping() && (t = l(t, { maxDepth: 0 })), t.isMultiGeometry) {
+      if (t && (t = l(t, {
+        isMultiGeometry: !1
+      })), F(r))
+        return r.map((i) => this.transformPointBackwardInternal(i, t, a));
+      if (c(r))
+        return r.map((i) => this.transformLineStringBackwardInternal(i, t, a));
+      if (v(r))
+        return r.map((i) => this.transformPolygonBackwardInternal(i, t, a));
+      throw new Error("Geometry type not supported");
+    } else {
+      if (d(r))
+        return this.transformPointBackwardInternal(r, t, a);
+      if (u(r))
+        return this.transformLineStringBackwardInternal(r, t, a);
+      if (I(r))
+        return this.transformPolygonBackwardInternal(r, t, a);
+      throw new Error("Geometry type not supported");
+    }
+  }
+  // Handle specific geometries
+  transformPointForwardInternal(r, n, a = S) {
+    const t = this.getForwardTransformationInternal();
+    let i = this.transformerOptions.differentHandedness ? m(r) : r;
+    i = n.preForward(i);
+    let e = t.evaluateFunction(i);
+    e = n.postForward(e);
+    let o, s, f = /* @__PURE__ */ new Map();
+    return n.distortionMeasures.length > 0 && (o = t.evaluatePartialDerivativeX(i), s = t.evaluatePartialDerivativeY(i), f = k(n.distortionMeasures, o, s, n.referenceScale)), a({
+      source: r,
+      // don't apply differentHandedness here, this is only internally.
+      destination: e,
+      partialDerivativeX: o,
+      partialDerivativeY: s,
+      distortions: f
+    });
+  }
+  transformPointBackwardInternal(r, n, a = M) {
+    const t = this.getBackwardTransformationInternal(), i = n.preBackward(r);
+    let e = t.evaluateFunction(i);
+    e = n.postBackward(e), e = this.transformerOptions.differentHandedness ? m(e) : e;
+    let o, s, f = /* @__PURE__ */ new Map();
+    return n.distortionMeasures.length > 0 && (o = t.evaluatePartialDerivativeX(i), o = this.transformerOptions.differentHandedness ? m(o) : o, s = t.evaluatePartialDerivativeY(i), s = this.transformerOptions.differentHandedness ? m(s) : s, f = k(n.distortionMeasures, o, s, n.referenceScale)), a({
+      source: e,
+      destination: i,
+      partialDerivativeX: o,
+      partialDerivativeY: s,
+      distortions: f
+    });
+  }
+  transformLineStringForwardInternal(r, n, a) {
+    return g(r, (t) => this.transformPointForwardInternal(t, n), p(n)).map((t) => a(t));
+  }
+  transformLineStringBackwardInternal(r, n, a) {
+    return g(r, (t) => this.transformPointBackwardInternal(t, n), h(n)).map((t) => a(D(t)));
+  }
+  transformRingForwardInternal(r, n, a) {
+    return y(r, (t) => this.transformPointForwardInternal(t, n), p(n)).map((t) => a(t));
+  }
+  transformRingBackwardInternal(r, n, a) {
+    return y(r, (t) => this.transformPointBackwardInternal(t, n), h(n)).map((t) => a(D(t)));
+  }
+  transformPolygonForwardInternal(r, n, a) {
+    return r.map((t) => this.transformRingForwardInternal(t, n, a));
+  }
+  transformPolygonBackwardInternal(r, n, a) {
+    return r.map((t) => this.transformRingBackwardInternal(t, n, a));
+  }
+  isNonWarping() {
+    return this.transformerOptions.postForward === this.transformerOptions.preBackward && this.transformerOptions.postBackward === this.transformerOptions.preForward && b.includes(this.type);
+  }
+  getForwardTransformationResolutionInternal(r, n) {
+    const a = l(this.transformerOptions, n);
+    return r = r ?? w(this.sourcePointsInternal), O(r, (t) => this.transformPointForwardInternal(t, a), p(a));
+  }
+  getBackwardTransformationResolutionInternal(r, n) {
+    const a = l(this.transformerOptions, n);
+    return r = r ?? w(this.destinationPointsInternal), O(r, (t) => this.transformPointBackwardInternal(t, a), h(a));
+  }
+}
+export {
+  nr as BaseGcpTransformer
+};
+//# sourceMappingURL=index.es417.js.map

package/dist/index.es417.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.es417.js","sources":["../../../node_modules/@allmaps/transform/dist/transformers/BaseGcpTransformer.js"],"sourcesContent":["import { isPoint, isLineString, isPolygon, isMultiPoint, isMultiLineString, isMultiPolygon, flipY, mergeOptions, computeBbox } from '@allmaps/stdlib';\nimport { computeDistortionsFromPartialDerivatives } from '../shared/distortion.js';\nimport { Straight } from '../transformation-types/Straight.js';\nimport { Helmert } from '../transformation-types/Helmert.js';\nimport { Polynomial1 } from '../transformation-types/Polynomial1.js';\nimport { Polynomial2 } from '../transformation-types/Polynomial2.js';\nimport { Polynomial3 } from '../transformation-types/Polynomial3.js';\nimport { Projective } from '../transformation-types/Projective.js';\nimport { RBF } from '../transformation-types/RBF.js';\nimport { linearKernel, thinPlateKernel } from '../shared/kernel-functions.js';\nimport { euclideanNorm } from '../shared/norm-functions.js';\nimport { defaultGeneralGcpTransformerOptions, nonWarpingTransformationTypes, refinementOptionsFromBackwardTransformOptions, refinementOptionsFromForwardTransformOptions } from '../shared/transform-functions.js';\nimport { refineLineString, refineRing, getSourceRefinementResolution } from '../shared/refinement-functions.js';\nimport { generalGcpToPointForForward, generalGcpToPointForBackward, invertGeneralGcp } from '../shared/conversion-functions.js';\n/**\n * Abstract class for Ground Control Point Transformers.\n *\n * This class contains all logic to transform geometries\n * made available trough the GeneralGcpTransform and GcpTransform classes.\n *\n * The extending GeneralGcpTransform class handles the general case where:\n * - We read in Ground Control Points using the GeneralGcp type, with `source` and `destination` fields.\n * - We use the terms 'forward' and 'backward' for the two transformations.\n * - Both source and destination space are exected to be 2D cartesian spaces with the same handedness (x- and y-axes have the same orientations).\n *\n * The extending GcpTransform class handles the typical Allmaps case where:\n * - We read in Ground Control Points using the Gcp type, with `resource` and `geo` fields.\n * - We use the terms 'toGeo' for the 'forward' transformation and 'toResource' for the 'backward' transformation.\n * - The `differentHandedness` setting is `true` by default, since we expect the resource coordinates to identify pixels on an image, with origin in the top left and the y-axis pointing down.\n * */\nexport class BaseGcpTransformer {\n generalGcpsInternal;\n sourcePointsInternal;\n destinationPointsInternal;\n type;\n transformerOptions;\n forwardTransformation;\n backwardTransformation;\n /**\n * Create a BaseGcpTransformer\n *\n * @param generalGcps - An array of General Ground Control Points (GCPs)\n * @param type - The transformation type\n * @param partialGeneralGcpTransformerOptions - General GCP Transformer options\n */ constructor(generalGcps, type = 'polynomial', partialGeneralGcpTransformerOptions) {\n this.transformerOptions = mergeOptions(defaultGeneralGcpTransformerOptions, partialGeneralGcpTransformerOptions);\n if (generalGcps.length === 0) {\n throw new Error('No control points');\n }\n this.generalGcpsInternal = generalGcps;\n this.sourcePointsInternal = this.generalGcpsInternal.map((generalGcp) => {\n const source = this.transformerOptions.differentHandedness\n ? flipY(generalGcp.source)\n : generalGcp.source;\n return this.transformerOptions.preForward(source);\n });\n this.destinationPointsInternal = this.generalGcpsInternal.map((generalGcp) => this.transformerOptions.preBackward(generalGcp.destination));\n this.type = type;\n }\n /**\n * Get the forward transformation. Create if it doesn't exist yet.\n */\n getForwardTransformationInternal() {\n if (!this.forwardTransformation) {\n this.forwardTransformation = this.createTransformation(this.sourcePointsInternal, this.destinationPointsInternal);\n }\n return this.forwardTransformation;\n }\n /**\n * Get the backward transformation. Create if it doesn't exist yet.\n */\n getBackwardTransformationInternal() {\n if (!this.backwardTransformation) {\n this.backwardTransformation = this.createTransformation(this.destinationPointsInternal, this.sourcePointsInternal);\n }\n return this.backwardTransformation;\n }\n /**\n * Create the (forward or backward) transformation.\n *\n * Results in forward transformation if source and destination points are entered as such.\n * Results in backward if source points are entered for destination points and vice versa.\n *\n * Results in a transformation of this instance's transformation type.\n *\n * @param sourcePoints - source points\n * @param destinationPoints - destination points\n * @returns Transformation\n */\n createTransformation(sourcePoints, destinationPoints) {\n if (this.type === 'straight') {\n return new Straight(sourcePoints, destinationPoints);\n }\n else if (this.type === 'helmert') {\n return new Helmert(sourcePoints, destinationPoints);\n }\n else if (this.type === 'polynomial1' || this.type === 'polynomial') {\n return new Polynomial1(sourcePoints, destinationPoints);\n }\n else if (this.type === 'polynomial2') {\n return new Polynomial2(sourcePoints, destinationPoints);\n }\n else if (this.type === 'polynomial3') {\n return new Polynomial3(sourcePoints, destinationPoints);\n }\n else if (this.type === 'projective') {\n return new Projective(sourcePoints, destinationPoints);\n }\n else if (this.type === 'thinPlateSpline') {\n return new RBF(sourcePoints, destinationPoints, thinPlateKernel, euclideanNorm, 'thinPlateSpline');\n }\n else if (this.type === 'linear') {\n return new RBF(sourcePoints, destinationPoints, linearKernel, euclideanNorm, 'linear');\n }\n else {\n throw new Error(`Unsupported transformation type: ${this.type}`);\n }\n }\n /**\n * Transform a geometry forward from source space to destination space\n *\n * @param sourceGeometry - Geometry to transform\n * @param partialGeneralGcpTransformOptions - General GCP Transform options\n * @param generalGcpToP - Return type function\n * @returns Forward transform of input geometry\n */\n transformForwardInternal(sourceGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n if (this.isNonWarping()) {\n transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n }\n if (!transformOptions.isMultiGeometry) {\n if (isPoint(sourceGeometry)) {\n return this.transformPointForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n }\n else if (isLineString(sourceGeometry)) {\n return this.transformLineStringForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n }\n else if (isPolygon(sourceGeometry)) {\n return this.transformPolygonForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n }\n else {\n throw new Error('Geometry type not supported');\n }\n }\n else {\n if (transformOptions) {\n transformOptions = mergeOptions(transformOptions, {\n isMultiGeometry: false\n }); // false for piecewise single geometries\n }\n if (isMultiPoint(sourceGeometry)) {\n return sourceGeometry.map((sourcePoint) => this.transformPointForwardInternal(sourcePoint, transformOptions, generalGcpToP));\n }\n else if (isMultiLineString(sourceGeometry)) {\n return sourceGeometry.map((sourceLineString) => this.transformLineStringForwardInternal(sourceLineString, transformOptions, generalGcpToP));\n }\n else if (isMultiPolygon(sourceGeometry)) {\n return sourceGeometry.map((sourcePolygon) => this.transformPolygonForwardInternal(sourcePolygon, transformOptions, generalGcpToP));\n }\n else {\n throw new Error('Geometry type not supported');\n }\n }\n }\n /**\n * Transform a geometry backward from destination space to source space\n *\n * @param destinationGeometry - Geometry to transform\n * @param partialGeneralGcpTransformOptions - General GCP Transform options\n * @param generalGcpToP - Return type function\n * @returns Backward transform of input geometry\n */\n transformBackwardInternal(destinationGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n if (this.isNonWarping()) {\n transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n }\n if (!transformOptions.isMultiGeometry) {\n if (isPoint(destinationGeometry)) {\n return this.transformPointBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n }\n else if (isLineString(destinationGeometry)) {\n return this.transformLineStringBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n }\n else if (isPolygon(destinationGeometry)) {\n return this.transformPolygonBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n }\n else {\n throw new Error('Geometry type not supported');\n }\n }\n else {\n if (transformOptions) {\n transformOptions = mergeOptions(transformOptions, {\n isMultiGeometry: false\n }); // false for piecewise single geometries\n }\n if (isMultiPoint(destinationGeometry)) {\n return destinationGeometry.map((destinationPoint) => this.transformPointBackwardInternal(destinationPoint, transformOptions, generalGcpToP));\n }\n else if (isMultiLineString(destinationGeometry)) {\n return destinationGeometry.map((destinationLineString) => this.transformLineStringBackwardInternal(destinationLineString, transformOptions, generalGcpToP));\n }\n else if (isMultiPolygon(destinationGeometry)) {\n return destinationGeometry.map((destinationPolygon) => this.transformPolygonBackwardInternal(destinationPolygon, transformOptions, generalGcpToP));\n }\n else {\n throw new Error('Geometry type not supported');\n }\n }\n }\n // Handle specific geometries\n transformPointForwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n const forwardTransformation = this.getForwardTransformationInternal();\n let source = this.transformerOptions.differentHandedness\n ? flipY(point)\n : point;\n source = generalGcpTransformOptions.preForward(source);\n let destination = forwardTransformation.evaluateFunction(source);\n destination = generalGcpTransformOptions.postForward(destination);\n let partialDerivativeX = undefined;\n let partialDerivativeY = undefined;\n let distortions = new Map();\n if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n partialDerivativeX =\n forwardTransformation.evaluatePartialDerivativeX(source);\n partialDerivativeY =\n forwardTransformation.evaluatePartialDerivativeY(source);\n distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n }\n return generalGcpToP({\n source: point, // don't apply differentHandedness here, this is only internally.\n destination,\n partialDerivativeX,\n partialDerivativeY,\n distortions\n });\n }\n transformPointBackwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n const backwardTransformation = this.getBackwardTransformationInternal();\n const destination = generalGcpTransformOptions.preBackward(point);\n let source = backwardTransformation.evaluateFunction(destination);\n // apply differentHandedness here again, so it has been applied twice in total and is undone now.\n source = generalGcpTransformOptions.postBackward(source);\n source = this.transformerOptions.differentHandedness\n ? flipY(source)\n : source;\n let partialDerivativeX = undefined;\n let partialDerivativeY = undefined;\n let distortions = new Map();\n if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n partialDerivativeX =\n backwardTransformation.evaluatePartialDerivativeX(destination);\n partialDerivativeX = this.transformerOptions.differentHandedness\n ? flipY(partialDerivativeX)\n : partialDerivativeX;\n partialDerivativeY =\n backwardTransformation.evaluatePartialDerivativeY(destination);\n partialDerivativeY = this.transformerOptions.differentHandedness\n ? flipY(partialDerivativeY)\n : partialDerivativeY;\n distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n }\n return generalGcpToP({\n source,\n destination,\n partialDerivativeX,\n partialDerivativeY,\n distortions\n });\n }\n transformLineStringForwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n return refineLineString(lineString, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n }\n transformLineStringBackwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n return refineLineString(lineString, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n }\n transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n return refineRing(ring, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n }\n transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n return refineRing(ring, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n }\n transformPolygonForwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n return polygon.map((ring) => {\n return this.transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n });\n }\n transformPolygonBackwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n return polygon.map((ring) => {\n return this.transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n });\n }\n isNonWarping() {\n return (this.transformerOptions.postForward ===\n this.transformerOptions.preBackward &&\n this.transformerOptions.postBackward ===\n this.transformerOptions.preForward &&\n nonWarpingTransformationTypes.includes(this.type));\n }\n getForwardTransformationResolutionInternal(sourceBbox, partialGeneralGcpTransformOptions) {\n const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n sourceBbox = sourceBbox ?? computeBbox(this.sourcePointsInternal);\n return getSourceRefinementResolution(sourceBbox, (p) => this.transformPointForwardInternal(p, transformOptions), refinementOptionsFromForwardTransformOptions(transformOptions));\n }\n getBackwardTransformationResolutionInternal(destinationBbox, partialGeneralGcpTransformOptions) {\n const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n destinationBbox =\n destinationBbox ?? computeBbox(this.destinationPointsInternal);\n return getSourceRefinementResolution(destinationBbox, (p) => this.transformPointBackwardInternal(p, transformOptions), refinementOptionsFromBackwardTransformOptions(transformOptions));\n }\n}\n"],"names":["BaseGcpTransformer","generalGcps","type","partialGeneralGcpTransformerOptions","mergeOptions","defaultGeneralGcpTransformerOptions","generalGcp","source","flipY","sourcePoints","destinationPoints","Straight","Helmert","Polynomial1","Polynomial2","Polynomial3","Projective","RBF","thinPlateKernel","euclideanNorm","linearKernel","sourceGeometry","partialGeneralGcpTransformOptions","generalGcpToP","generalGcpToPointForForward","transformOptions","isMultiPoint","sourcePoint","isMultiLineString","sourceLineString","isMultiPolygon","sourcePolygon","isPoint","isLineString","isPolygon","destinationGeometry","generalGcpToPointForBackward","destinationPoint","destinationLineString","destinationPolygon","point","generalGcpTransformOptions","forwardTransformation","destination","partialDerivativeX","partialDerivativeY","distortions","computeDistortionsFromPartialDerivatives","backwardTransformation","lineString","refineLineString","p","refinementOptionsFromForwardTransformOptions","refinementOptionsFromBackwardTransformOptions","invertGeneralGcp","ring","refineRing","polygon","nonWarpingTransformationTypes","sourceBbox","computeBbox","getSourceRefinementResolution","destinationBbox"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es418.js ADDED Viewed

@@ -0,0 +1,45 @@
+function t(i) {
+  return { source: i.destination, destination: i.source };
+}
+function o(i) {
+  return i.destination;
+}
+function r(i) {
+  return i.source;
+}
+function e(i) {
+  return i.geo;
+}
+function n(i) {
+  return i.resource;
+}
+function a(i) {
+  return {
+    resource: i.source,
+    geo: i.destination,
+    partialDerivativeX: i.partialDerivativeX,
+    partialDerivativeY: i.partialDerivativeY,
+    distortions: i.distortions,
+    distortion: i.distortion
+  };
+}
+function s(i) {
+  return {
+    source: i.resource,
+    destination: i.geo,
+    partialDerivativeX: i.partialDerivativeX,
+    partialDerivativeY: i.partialDerivativeY,
+    distortions: i.distortions,
+    distortion: i.distortion
+  };
+}
+export {
+  s as gcpToGeneralGcp,
+  e as gcpToPointForToGeo,
+  n as gcpToPointForToResource,
+  a as generalGcpToGcp,
+  r as generalGcpToPointForBackward,
+  o as generalGcpToPointForForward,
+  t as invertGeneralGcp
+};
+//# sourceMappingURL=index.es418.js.map

package/dist/index.es418.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.es418.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/conversion-functions.js"],"sourcesContent":["// Invert\nexport function invertGeneralGcp(generalGcp) {\n return { source: generalGcp.destination, destination: generalGcp.source };\n}\nexport function invertGcp(gcp) {\n return { resource: gcp.geo, geo: gcp.resource };\n}\n// Select\nexport function generalGcpToPointForForward(generalGcp) {\n return generalGcp.destination;\n}\nexport function generalGcpToPointForBackward(generalGcp) {\n return generalGcp.source;\n}\nexport function gcpToPointForToGeo(gcp) {\n return gcp.geo;\n}\nexport function gcpToPointForToResource(gcp) {\n return gcp.resource;\n}\n// GeneralGcp <> G\nexport function generalGcpToGcp(generalGcp) {\n return {\n resource: generalGcp.source,\n geo: generalGcp.destination,\n partialDerivativeX: generalGcp.partialDerivativeX,\n partialDerivativeY: generalGcp.partialDerivativeY,\n distortions: generalGcp.distortions,\n distortion: generalGcp.distortion\n };\n}\nexport function gcpToGeneralGcp(gcp) {\n return {\n source: gcp.resource,\n destination: gcp.geo,\n partialDerivativeX: gcp.partialDerivativeX,\n partialDerivativeY: gcp.partialDerivativeY,\n distortions: gcp.distortions,\n distortion: gcp.distortion\n };\n}\n// TransformationType\n// TODO: implement this as a separate, callable function in @allmaps/annotation?\nexport function transformationTypeToTypeAndOrder(transformationType) {\n if (transformationType === 'polynomial' ||\n transformationType === 'polynomial1') {\n return {\n type: 'polynomial',\n options: {\n order: 1\n }\n };\n }\n else if (transformationType === 'polynomial2') {\n return {\n type: 'polynomial',\n options: {\n order: 2\n }\n };\n }\n else if (transformationType === 'polynomial3') {\n return {\n type: 'polynomial',\n options: {\n order: 3\n }\n };\n }\n else {\n return {\n type: transformationType\n };\n }\n}\nexport function typeAndOrderToTransformationType(transformation) {\n const type = transformation.type;\n const order = transformation.options?.order;\n let transformationType;\n if (type == 'polynomial1' || type === 'polynomial') {\n transformationType = 'polynomial1';\n }\n else if (type == 'polynomial2' || (type === 'polynomial' && order === 2)) {\n transformationType = 'polynomial2';\n }\n else if (type == 'polynomial3' || (type === 'polynomial' && order === 3)) {\n transformationType = 'polynomial3';\n }\n else if (type === 'thinPlateSpline') {\n transformationType = type;\n }\n else if (type === 'linear') {\n transformationType = type;\n }\n else if (type === 'helmert') {\n transformationType = type;\n }\n else if (type === 'projective') {\n transformationType = type;\n }\n else {\n throw new Error('Unrecognised transformationType.');\n }\n return transformationType;\n}\n"],"names":["invertGeneralGcp","generalGcp","generalGcpToPointForForward","generalGcpToPointForBackward","gcpToPointForToGeo","gcp","gcpToPointForToResource","generalGcpToGcp","gcpToGeneralGcp"],"mappings":"AACO,SAASA,EAAiBC,GAAY;AACzC,SAAO,EAAE,QAAQA,EAAW,aAAa,aAAaA,EAAW,OAAA;AACrE;AAKO,SAASC,EAA4BD,GAAY;AACpD,SAAOA,EAAW;AACtB;AACO,SAASE,EAA6BF,GAAY;AACrD,SAAOA,EAAW;AACtB;AACO,SAASG,EAAmBC,GAAK;AACpC,SAAOA,EAAI;AACf;AACO,SAASC,EAAwBD,GAAK;AACzC,SAAOA,EAAI;AACf;AAEO,SAASE,EAAgBN,GAAY;AACxC,SAAO;AAAA,IACH,UAAUA,EAAW;AAAA,IACrB,KAAKA,EAAW;AAAA,IAChB,oBAAoBA,EAAW;AAAA,IAC/B,oBAAoBA,EAAW;AAAA,IAC/B,aAAaA,EAAW;AAAA,IACxB,YAAYA,EAAW;AAAA,EAAA;AAE/B;AACO,SAASO,EAAgBH,GAAK;AACjC,SAAO;AAAA,IACH,QAAQA,EAAI;AAAA,IACZ,aAAaA,EAAI;AAAA,IACjB,oBAAoBA,EAAI;AAAA,IACxB,oBAAoBA,EAAI;AAAA,IACxB,aAAaA,EAAI;AAAA,IACjB,YAAYA,EAAI;AAAA,EAAA;AAExB;","x_google_ignoreList":[0]}

package/dist/index.es419.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { BaseLinearWeightsTransformation as o } from "./index.es420.js";
+class i extends o {
+  constructor(r, e, t, s) {
+    super(r, e, t, s);
+  }
+  getCoefsArrayMatrices() {
+    const r = this.getCoefsArrayMatrix();
+    return [r, r];
+  }
+  getSourcePointCoefsArrays(r) {
+    const e = this.getSourcePointCoefsArray(r);
+    return [e, e];
+  }
+}
+export {
+  i as BaseIndependentLinearWeightsTransformation
+};
+//# sourceMappingURL=index.es419.js.map

package/dist/index.es419.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.es419.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseIndependentLinearWeightsTransformation.js"],"sourcesContent":["import { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights,\n * where the system of equations for x and y are independent and can hence be solved separately.\n */\nexport class BaseIndependentLinearWeightsTransformation extends BaseLinearWeightsTransformation {\n constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n super(sourcePoints, destinationPoints, type, pointCountMinimum);\n }\n getCoefsArrayMatrices() {\n const coefsArrayMatrix = this.getCoefsArrayMatrix();\n return [coefsArrayMatrix, coefsArrayMatrix];\n }\n getSourcePointCoefsArrays(sourcePoint) {\n const sourcePointCoefsArray = this.getSourcePointCoefsArray(sourcePoint);\n return [sourcePointCoefsArray, sourcePointCoefsArray];\n }\n}\n"],"names":["BaseIndependentLinearWeightsTransformation","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","coefsArrayMatrix","sourcePoint","sourcePointCoefsArray"],"mappings":";AAKO,MAAMA,UAAmDC,EAAgC;AAAA,EAC5F,YAAYC,GAAcC,GAAmBC,GAAMC,GAAmB;AAClE,UAAMH,GAAcC,GAAmBC,GAAMC,CAAiB;AAAA,EAClE;AAAA,EACA,wBAAwB;AACpB,UAAMC,IAAmB,KAAK,oBAAA;AAC9B,WAAO,CAACA,GAAkBA,CAAgB;AAAA,EAC9C;AAAA,EACA,0BAA0BC,GAAa;AACnC,UAAMC,IAAwB,KAAK,yBAAyBD,CAAW;AACvE,WAAO,CAACC,GAAuBA,CAAqB;AAAA,EACxD;AACJ;","x_google_ignoreList":[0]}

package/dist/index.es42.js CHANGED Viewed

@@ -1,6 +1,6 @@
-import r from "./index.es218.js";
+import r from "./index.es225.js";
 import { isIE11 as t } from "./index.es39.js";
-import { ie11fingerprint as o, mapMethods as i } from "./index.es224.js";
+import { ie11fingerprint as o, mapMethods as i } from "./index.es231.js";
 const a = t ? o(i) : r("Map");
 export {
   a as default

package/dist/index.es420.js ADDED Viewed

@@ -0,0 +1,11 @@
+import { BaseTransformation as n } from "./index.es421.js";
+class e extends n {
+  destinationPointsArrays;
+  constructor(s, t, r, i) {
+    super(s, t, r, i), this.destinationPointsArrays = this.getDestinationPointsArrays();
+  }
+}
+export {
+  e as BaseLinearWeightsTransformation
+};
+//# sourceMappingURL=index.es420.js.map

package/dist/index.es420.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.es420.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseLinearWeightsTransformation.js"],"sourcesContent":["import { BaseTransformation } from './BaseTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights.\n *\n * In general, the system of equations for x and y are dependent on each other, and they are thus solved jointly.\n * For transformations where the system of equations for x and y are independent and can hence be solved separately, a dedicated class exists.\n */\nexport class BaseLinearWeightsTransformation extends BaseTransformation {\n destinationPointsArrays;\n constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n super(sourcePoints, destinationPoints, type, pointCountMinimum);\n this.destinationPointsArrays = this.getDestinationPointsArrays();\n }\n}\n"],"names":["BaseLinearWeightsTransformation","BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum"],"mappings":";AAOO,MAAMA,UAAwCC,EAAmB;AAAA,EACpE;AAAA,EACA,YAAYC,GAAcC,GAAmBC,GAAMC,GAAmB;AAClE,UAAMH,GAAcC,GAAmBC,GAAMC,CAAiB,GAC9D,KAAK,0BAA0B,KAAK,2BAAA;AAAA,EACxC;AACJ;","x_google_ignoreList":[0]}