@skmtc/core 0.28.7 → 0.30.1

package/esm/parse/v3-2/tag/toTagsV3.js

@@ -0,0 +1,78 @@
+import { OasTag } from '../../../oas/tag/Tag.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toTagsV3 = ({ tags, stackTrail, context }) => {
+    if (!tags) {
+        return undefined;
+    }
+    const parents = new Map(tags.map(({ name, parent }) => [name, parent]));
+    return tags.map(tag => {
+        const parentError = toParentError({ name: tag.name, parent: tag.parent, parents });
+        if (!parentError) {
+            return toTagV3({ tag, stackTrail, context });
+        }
+        context.logIssue({
+            key: 'parent',
+            level: 'warning',
+            message: `Tag '${tag.name}' ${parentError}; dropping 'parent'`,
+            parent: tag,
+            stackTrail,
+            type: 'INVALID_TAG_PARENT'
+        });
+        return toTagV3({ tag: { ...tag, parent: undefined }, stackTrail, context });
+    });
+};
+/** Describes why the tag's `parent` is invalid, or returns undefined when it is valid. */
+const toParentError = ({ name, parent, parents }) => {
+    if (parent === undefined) {
+        return undefined;
+    }
+    if (!parents.has(parent)) {
+        return `names parent '${parent}', which is not a tag`;
+    }
+    if (leadsBackTo({ name, current: parent, parents, visited: new Set() })) {
+        return `is in a parent cycle through '${parent}'`;
+    }
+    return undefined;
+};
+/** Follows the parent chain from `current` and reports whether it reaches `name`. */
+const leadsBackTo = ({ name, current, parents, visited }) => {
+    if (current === undefined) {
+        return false;
+    }
+    if (current === name) {
+        return true;
+    }
+    // The chain loops without reaching `name`: the cycle is above this tag, and
+    // the tags in it report it.
+    if (visited.has(current)) {
+        return false;
+    }
+    return leadsBackTo({
+        name,
+        current: parents.get(current),
+        parents,
+        visited: new Set([...visited, current])
+    });
+};
+export const toTagV3 = ({ tag, stackTrail, context }) => {
+    const { name, description, summary, parent, kind, externalDocs, ...skipped } = tag;
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: tag,
+        context,
+        stackTrail,
+        parentType: 'tag'
+    });
+    const fields = {
+        name,
+        description,
+        summary,
+        parent,
+        kind,
+        externalDocs: parsedExternalDocs,
+        extensionFields
+    };
+    return new OasTag(fields);
+};

package/esm/parse/v3-2/union/toUnion.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnion } from '../../../oas/union/Union.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnionArgs = {
+    value: OpenAPIV3.SchemaObject;
+    members: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    parentType: 'anyOf' | 'oneOf';
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnion: ({ value, members, parentType, stackTrail, context }: ToUnionArgs) => OasUnion;

package/esm/parse/v3-2/union/toUnion.js

@@ -0,0 +1,68 @@
+import { OasUnion } from '../../../oas/union/Union.js';
+import { toDiscriminatorV3 } from '../discriminator/toDiscriminatorV3.js';
+import { toSchemaV3 } from '../schema/toSchemasV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { parseNullable } from '../_helpers/parseNullable.js';
+import { parseExample } from '../_helpers/parseExample.js';
+import { parseDefault } from '../_helpers/parseDefault.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toUnion = ({ value, members, parentType, stackTrail, context }) => {
+    const { nullable, value: valueWithoutNullable } = parseNullable({
+        value,
+        context,
+        stackTrail
+    });
+    const { discriminator, title, description, externalDocs, example: unparsedExample, default: unparsedDefaultValue, ...skipped } = valueWithoutNullable;
+    const example = parseExample({
+        value: unparsedExample,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid example. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const defaultValue = parseDefault({
+        value: unparsedDefaultValue,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid default. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: `schema:${parentType}`
+    });
+    const discriminatorParsed = stackTrail.trace('discriminator', st => toDiscriminatorV3({ discriminator, stackTrail: st, context }));
+    const membersParsed = members.reduce((acc, item, index) => {
+        if (item === undefined || item === null) {
+            return acc;
+        }
+        return [
+            ...acc,
+            stackTrail.trace(`${index}`, st => toSchemaV3({ schema: item, stackTrail: st, context }))
+        ];
+    }, []);
+    return context.withStackTrail(stackTrail, () => new OasUnion({
+        title,
+        description,
+        externalDocs: stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context })),
+        nullable,
+        default: defaultValue,
+        discriminator: discriminatorParsed,
+        members: membersParsed,
+        example,
+        extensionFields
+    }, context));
+};
+// A union (anyOf/oneOf) value may match any of its members, so the most we
+// can validate without resolving members is that a present default/example
+// is not a bare `null` on a non-nullable schema.
+const isPresent = (value) => {
+    return value !== null && value !== undefined;
+};

package/esm/parse/v3-2/unknown/toUnknown.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnknownArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnknown: ({ value, stackTrail, context }: ToUnknownArgs) => OasUnknown;

package/esm/parse/v3-2/unknown/toUnknown.js

@@ -0,0 +1,19 @@
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+export const toUnknown = ({ value, stackTrail, context }) => {
+    const { type: _type, title, description, example, nullable, ...skipped } = value;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:unknown'
+    });
+    return context.withStackTrail(stackTrail, () => new OasUnknown({
+        title,
+        description,
+        nullable,
+        extensionFields,
+        example
+    }, context));
+};

package/esm/parse/v3-2/webhook/toWebhooksV3.d.ts

@@ -0,0 +1,48 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * The 3.1 `webhooks` object: a map of webhook NAME → PathItem, identical
+ * in shape to `paths` but keyed by name rather than URL path. Inline
+ * PathItems only — a webhook PathItem `$ref` is a 3.1 edge case not yet
+ * handled (see the arc note §5 Refs).
+ */
+export type WebhooksObject = Record<string, OpenAPIV3.PathItemObject>;
+type WebhookInfo = {
+    method: Method;
+    name: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToWebhookV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    webhookInfo: WebhookInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export declare const toWebhookV3: ({ operation, webhookInfo, stackTrail, context }: ToWebhookV3Args) => OasWebhook;
+export type ToWebhooksV3Args = {
+    webhooks: WebhooksObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export declare const toWebhooksV3: ({ webhooks, stackTrail, context }: ToWebhooksV3Args) => OasWebhook[];
+export {};

package/esm/parse/v3-2/webhook/toWebhooksV3.js

@@ -0,0 +1,139 @@
+import { toRequestBodyV3 } from '../requestBody/toRequestBodiesV3.js';
+import { toResponsesV3 } from '../response/toResponseV3.js';
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import { toPathItemResultV3 } from '../pathItem/toPathItemV3.js';
+import { toPathItemMethod } from '../methods.js';
+import { dropAdditionalOperationsV3 } from '../pathItem/dropAdditionalOperationsV3.js';
+import { warnQuerystringConflictsV3 } from '../parameter/warnQuerystringConflictsV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toSecurityRequirementsV3 } from '../securityRequirement/toSecurityRequirement.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+import { toOptionalServersV3 } from '../server/toServerV3.js';
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export const toWebhookV3 = ({ operation, webhookInfo, stackTrail, context }) => {
+    const { method, name, pathItem } = webhookInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, ...skipped } = operation;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context }));
+    warnQuerystringConflictsV3({ parameters: parsedParameters, pathItem, stackTrail, context });
+    const parsedRequestBody = stackTrail.trace('requestBody', st => toRequestBodyV3({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => toResponsesV3({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => toSecurityRequirementsV3({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => toOptionalServersV3({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new OasWebhook({
+        pathItem,
+        name,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export const toWebhooksV3 = ({ webhooks, stackTrail, context }) => {
+    if (!webhooks) {
+        return [];
+    }
+    return Object.entries(webhooks).flatMap(([name, pathItem]) => {
+        return stackTrail.trace(name, nameStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const fixedFields = dropAdditionalOperationsV3({ pathItem, stackTrail: nameStack, context });
+            const cleaned = Object.entries(fixedFields).reduce(({ rest, methodObject }, [key, operation]) => {
+                const method = toPathItemMethod(key);
+                if (method) {
+                    const { [method]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [method]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: fixedFields,
+                methodObject: {}
+            });
+            const pathItemResult = toPathItemResultV3({
+                pathItem: cleaned.rest,
+                stackTrail: nameStack,
+                context
+            });
+            if (!pathItemResult.valid) {
+                return [];
+            }
+            const pathItemObject = pathItemResult.pathItem;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `nameStack` (the trail with the webhook name already
+                // pushed) so downstream traces record webhooks:<name>:<method>:…
+                // — the trail `OasDocument.removeItem` matches a webhook on.
+                return nameStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return toWebhookV3({
+                            operation,
+                            webhookInfo: {
+                                method: method,
+                                name,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};

package/esm/types/Method.d.ts

@@ -5,9 +5,11 @@ import * as v from 'valibot';
  *
  * This constant array includes all HTTP methods that can be used
  * in OpenAPI path operations, as defined by the OpenAPI specification.
- * All methods are in lowercase to match OpenAPI conventions.
+ * All methods are in lowercase to match OpenAPI conventions. `query` is
+ * an OpenAPI 3.2 method; each parser tree reads its own list from
+ * `parse/v3-X/methods.ts`.
  */
-export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace", "query"];
 /**
  * Array of HTTP methods excluding TRACE.
  *
@@ -23,8 +25,9 @@ export declare const method: v.UnionSchema<[
     v.LiteralSchema<'delete', undefined>,
     v.LiteralSchema<'head', undefined>,
     v.LiteralSchema<'options', undefined>,
-    v.LiteralSchema<'trace', undefined>
+    v.LiteralSchema<'trace', undefined>,
+    v.LiteralSchema<'query', undefined>
 ], undefined>;
-export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace' | 'query';
 export declare const methods: v.ArraySchema<typeof method, undefined>;
 export declare const isMethod: (arg: unknown) => arg is Method;

package/esm/types/Method.js

@@ -5,7 +5,9 @@ import * as v from 'valibot';
  *
  * This constant array includes all HTTP methods that can be used
  * in OpenAPI path operations, as defined by the OpenAPI specification.
- * All methods are in lowercase to match OpenAPI conventions.
+ * All methods are in lowercase to match OpenAPI conventions. `query` is
+ * an OpenAPI 3.2 method; each parser tree reads its own list from
+ * `parse/v3-X/methods.ts`.
  */
 export const methodValues = [
     'get',
@@ -15,7 +17,8 @@ export const methodValues = [
     'options',
     'head',
     'patch',
-    'trace'
+    'trace',
+    'query'
 ];
 /**
  * Array of HTTP methods excluding TRACE.
@@ -23,7 +26,16 @@ export const methodValues = [
  * This is a filtered version of {@link methodValues} that excludes the TRACE method,
  * which is sometimes excluded from API operations for security reasons.
  */
-export const methodValuesNoTrace = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch'];
+export const methodValuesNoTrace = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'query'
+];
 export const method = v.union([
     v.literal('get'),
     v.literal('post'),
@@ -32,7 +44,8 @@ export const method = v.union([
     v.literal('delete'),
     v.literal('head'),
     v.literal('options'),
-    v.literal('trace')
+    v.literal('trace'),
+    v.literal('query')
 ]);
 export const methods = v.array(method);
 export const isMethod = (arg) => {

package/esm/types/Preview.d.ts

@@ -139,7 +139,8 @@ export declare const oasOperationSource: v.ObjectSchema<{
         v.LiteralSchema<'delete', undefined>,
         v.LiteralSchema<'head', undefined>,
         v.LiteralSchema<'options', undefined>,
-        v.LiteralSchema<'trace', undefined>
+        v.LiteralSchema<'trace', undefined>,
+        v.LiteralSchema<'query', undefined>
     ], undefined>;
     readonly variant: v.StringSchema<undefined>;
 }, undefined>;

package/esm/types/Settings.js

@@ -52,13 +52,8 @@ import "../_dnt.polyfills.js";
 import { generatorEnrichments } from './Enrichments.js';
 import * as v from 'valibot';
 import { method } from './Method.js';
+import { hasParentSegment, isAbsolutePath, isValidWorkspacePath } from '../helpers/normalizeWorkspacePath.js';
 import { toWorkspacePath } from '../helpers/toWorkspacePath.js';
-/**
- * Whether a relative path contains a `..` parent-reference segment.
- * `..` is a parent reference only as a whole path segment — a
- * directory name that merely contains dots is not flagged.
- */
-const hasParentSegment = (path) => path.split(/[/\\]/).some(segment => segment === '..');
 /**
  * Valibot schema for {@link ModulePackage}.
  *
@@ -175,7 +170,9 @@ export const anchorsSettings = v.object({
     out: v.optional(v.string())
 });
 export const clientSettings = v.object({
-    basePath: v.optional(v.string()),
+    basePath: v.optional(v.pipe(v.string(), v.check(basePath => !isAbsolutePath(basePath), 'basePath must be relative to the SKMTC root (the directory containing .skmtc/); ' +
+        'absolute paths are not supported because generated output is always written under it'), v.check(basePath => !hasParentSegment(basePath), 'basePath must be a forward path with no ".." segments — it is the on-disk anchor ' +
+        'every generated file sits below'))),
     schemaSource: v.optional(v.string()),
     packages: v.optional(modulePackages),
     enrichments: v.optional(generatorEnrichments),
@@ -185,7 +182,8 @@ export const clientSettings = v.object({
     inputDirs: v.optional(v.array(v.string())),
     formatter: v.optional(v.string()),
     generatedSuffix: v.optional(v.string()),
-    ejected: v.optional(v.array(v.string()))
+    ejected: v.optional(v.array(v.pipe(v.string(), v.check(isValidWorkspacePath, 'settings.ejected entries are export paths: a forward path below basePath, ' +
+        'with no ".." segment and not a Windows drive or UNC path'))))
 });
 /**
  * Valibot schema for validating SKMTC client configuration.

package/esm/types/SkmtcDocument.d.ts

@@ -59,12 +59,12 @@ export declare const toGqlParsedDocument: (value: GqlDocument) => SkmtcParsedDoc
  * pipeline runs the protocol-appropriate parser before handing the
  * post-parse {@link SkmtcParsedDocument} to the generate phase.
  *
- * - `oas.value` is an `OpenAPIV3.Document`. Schema versions other than
- *   3.0 (Swagger 2, OpenAPI 3.1) are normalized to 3.0 by
- *   `@skmtc/convert` before reaching `toArtifacts`. 3.1 `webhooks` ride
- *   *on* that document as a retained member (the 3.0 base type omits
- *   `webhooks`, so it is widened here) — the parser flattens them into
- *   {@link OasDocument.webhooks}.
+ * - `oas.value` is an `OpenAPIV3.Document` carrying an OpenAPI 3.0, 3.1 or
+ *   3.2 document; each is parsed natively by its own parser tree. Swagger 2
+ *   is converted to 3.0 by `@skmtc/convert` before reaching `toArtifacts`.
+ *   3.1 and 3.2 `webhooks` ride *on* that document as a retained member
+ *   (the 3.0 base type omits `webhooks`, so it is widened here) — the
+ *   parser flattens them into {@link OasDocument.webhooks}.
  * - `gql.value` is either a raw SDL string or a pre-built
  *   `GraphQLSchema`. Strings are run through `buildSchema` inside the
  *   pipeline; pre-built `GraphQLSchema` instances are used as-is.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.28.7",
+  "version": "0.30.1",
   "description": "Skmtc is a declarative code generation framework",
   "keywords": [
     "openapi",

package/script/_dnt.polyfills.d.ts

@@ -4,6 +4,17 @@ declare global {
     }
 }
 export {};
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/script/_dnt.polyfills.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.import_meta_ponyfill = exports.import_meta_ponyfill_esmodule = exports.import_meta_ponyfill_commonjs = void 0;
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,