xml-model 1.3.3 → 2.0.0-beta.1

package/dist/xml/index.js

@@ -1,57 +1,17 @@
-import XMLJS from "./xml-js.js";
-function parse(string) {
-  return XMLJS.parse(string);
-}
-const stringify = XMLJS.stringify;
-function getContent(xml) {
-  if (xml.elements?.length === 1) {
-    const content = xml.elements[0];
-    if (content.type === "text") return content.text;
-  }
-  if (!xml.elements) return "";
-  throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
-}
-function fromContent(content = "", tag, attributes) {
-  const el = {
-    elements: content ? [{ type: "text", text: String(content) }] : []
-  };
-  if (tag) el.name = tag;
-  if (attributes) {
-    if (!el.name) throw new TypeError("please provide a name if you want to provide attributes");
-    el.attributes = attributes;
-  }
-  if (el.name) el.type = "element";
-  return el;
-}
-function addElement(xml, element) {
-  if (!xml.elements) xml.elements = [];
-  xml.elements.push(element);
-}
-function setAttribute(xml, attribute, value) {
-  if (!xml.attributes) xml.attributes = {};
-  xml.attributes[attribute] = value;
-}
-function deleteAttribute(xml, attribute) {
-  if (!xml.attributes) return;
-  delete xml.attributes[attribute];
-}
-const XML = {
-  parse,
-  stringify,
-  fromContent,
-  getContent,
-  addElement,
-  setAttribute,
-  deleteAttribute
-};
+import { XML, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml-js.js";
+import { xml } from "./schema-meta.js";
+import { normalizeCodecOptions, registerDefault } from "./codec.js";
+import { xmlModel } from "./model.js";
 export {
-  addElement,
-  XML as default,
-  deleteAttribute,
-  fromContent,
-  getContent,
-  parse,
-  setAttribute,
-  stringify
+  XML,
+  ZXMLCommentNode,
+  ZXMLElementNode,
+  ZXMLNode,
+  ZXMLRoot,
+  ZXMLTextNode,
+  normalizeCodecOptions,
+  registerDefault,
+  xml,
+  xmlModel
 };
 //# sourceMappingURL=index.js.map

package/dist/xml/model.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { XMLElement, StringifyOptions, XMLRoot } from './xml-js';
+import { ModelConstructor } from '../model';
+import { UserCodecOptions } from './codec';
+/**
+ * Constructor type for xmlModel classes.
+ * Extends ModelConstructor with XML-specific helpers and a typed extend().
+ */
+export type XmlModelConstructor<S extends z.ZodObject<any> = z.ZodObject<any>, Inst extends z.infer<S> = z.infer<S>> = ModelConstructor<S, Inst> & {
+    /** Returns a new instance parsed from an XML string or XMLRoot. */
+    fromXML<T extends abstract new (...args: any[]) => any>(this: T, xmlInput: string | XMLRoot | XMLElement): InstanceType<T>;
+    /** Converts an instance to an XMLRoot document tree. */
+    toXML(instance: z.infer<S>): XMLRoot;
+    /** Converts an instance to an XML string. */
+    toXMLString(instance: z.infer<S>, options?: StringifyOptions): string;
+};
+export declare function xmlModel<S extends z.ZodObject<any>>(schema: S, options?: UserCodecOptions<S>): XmlModelConstructor<S>;
+//# sourceMappingURL=model.d.ts.map

package/dist/xml/model.js

@@ -0,0 +1,37 @@
+import "zod";
+import { XML } from "./xml-js.js";
+import { model } from "../model.js";
+import { decode, XML_STATE, encode } from "./codec.js";
+import { root } from "./schema-meta.js";
+function xmlModel(schema, options) {
+  const _schema = options ? root(schema, options) : schema;
+  return class extends model(_schema) {
+    static fromXML(input) {
+      if (typeof input === "string") {
+        input = XML.parse(input);
+      }
+      if (XML.isRoot(input)) {
+        input = XML.elementFromRoot(input);
+      }
+      const schema2 = this.dataSchema;
+      const inputData = decode(this.dataSchema, input);
+      const xmlState = inputData[XML_STATE];
+      const parsed = schema2.parse(inputData);
+      parsed[XML_STATE] = xmlState;
+      return this.fromData(parsed);
+    }
+    static toXML(instance) {
+      const data = this.toData(instance);
+      const element = encode(this.dataSchema, data);
+      return { elements: [element] };
+    }
+    static toXMLString(instance, options2 = {}) {
+      const xml = this.toXML(instance);
+      return XML.stringify(xml, options2);
+    }
+  };
+}
+export {
+  xmlModel
+};
+//# sourceMappingURL=model.js.map

package/dist/xml/schema-meta.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { UserCodecOptions, PropertyDecodingContext, PropertyEncodingContext } from './codec';
+import { XMLElement } from './xml-js';
+declare module "zod" {
+    interface GlobalMeta {
+        "@@xml-model"?: Record<string, unknown>;
+    }
+}
+type UserRootOptions<S extends z.ZodType = z.ZodType> = {
+    tagname?: string | UserCodecOptions<S>["tagname"];
+    decode?: UserCodecOptions<S>["decode"];
+    encode?: UserCodecOptions<S>["encode"];
+};
+type UserPropOptions = {
+    tagname?: string | UserCodecOptions["propertyTagname"];
+    inline?: boolean;
+    match?: RegExp | ((el: XMLElement) => boolean);
+    decode?: (ctx: PropertyDecodingContext) => Partial<Record<string, unknown>> | undefined;
+    encode?: (ctx: PropertyEncodingContext) => XMLElement | undefined;
+};
+export declare function root<S extends z.ZodType>(schema: S, options: UserRootOptions<S>): S;
+export declare function root(options: UserRootOptions): z.GlobalMeta;
+/**
+ * Annotate a field schema with XML child-element options.
+ *
+ * **`xml.prop()` with no options is a no-op.** The codec already iterates all
+ * ZodObject fields and defaults the tag name to `kebabCase(fieldKey)`. Wrap a
+ * schema in `xml.prop()` only when you need to customise at least one of:
+ * `tagname`, `inline`, `match`, `decode`, or `encode`.
+ *
+ * @example
+ * // ✅ Needed — custom tagname
+ * xml.prop(z.string(), { tagname: "pub-date" })
+ *
+ * // ✅ Needed — inline (children promoted to parent)
+ * xml.prop(z.array(ItemSchema), { inline: true })
+ *
+ * // ⚠️  Redundant — equivalent to plain z.string()
+ * xml.prop(z.string())
+ */
+export declare function prop<PS extends z.ZodType>(schema: PS, options: UserPropOptions): PS;
+export declare function prop(options: UserPropOptions): z.GlobalMeta;
+type AttributePropOptions = {
+    name?: string;
+};
+export declare function attr<PS extends z.ZodType>(schema: PS, options?: AttributePropOptions): PS;
+export declare function attr(options?: AttributePropOptions): z.GlobalMeta;
+/** Namespace object for XML metadata helpers. */
+export declare const xml: {
+    root: typeof root;
+    prop: typeof prop;
+    attr: typeof attr;
+};
+export declare function getOwnUserOptions<S extends z.ZodType>(schema: S): UserCodecOptions<S>;
+export declare function getUserOptions<S extends z.ZodType>(schema: S): UserCodecOptions<S>;
+export {};
+//# sourceMappingURL=schema-meta.d.ts.map

package/dist/xml/schema-meta.js

@@ -0,0 +1,96 @@
+import "zod";
+import { isZodType, getParentSchema } from "../util/zod.js";
+const metaKey = "@@xml-model";
+function setMeta(schema, partial) {
+  const existing = schema.meta()?.[metaKey] ?? {};
+  return schema.meta({ [metaKey]: { ...existing, ...partial } });
+}
+function normalizePropOptions(options) {
+  if (!options) return {};
+  const partial = {};
+  if (options.tagname !== void 0)
+    partial.propertyTagname = options.tagname;
+  if (options.inline !== void 0) partial.inlineProperty = options.inline;
+  if (options.match !== void 0)
+    partial.propertyMatch = options.match;
+  if (options.decode !== void 0) {
+    const userDecode = options.decode;
+    partial.decodeAsProperty = function(ctx) {
+      const res = userDecode(ctx);
+      if (typeof res !== "undefined") {
+        Object.assign(ctx.result, res);
+      }
+    };
+  }
+  if (options.encode !== void 0) {
+    const userEncode = options.encode;
+    partial.encodeAsProperty = function(ctx) {
+      const { property } = ctx;
+      const res = userEncode(ctx);
+      if (typeof res === "undefined") return;
+      if (property.options.inlineProperty) {
+        ctx.result.elements.push(...res.elements);
+      } else {
+        res.name = property.tagname;
+        ctx.result.elements.push(res);
+      }
+    };
+  }
+  return partial;
+}
+function root(optionsOrSchema, options) {
+  if (isZodType(optionsOrSchema)) {
+    return setMeta(optionsOrSchema, options ?? {});
+  } else {
+    return { [metaKey]: optionsOrSchema };
+  }
+}
+function prop(optionsOrSchema, options) {
+  if (isZodType(optionsOrSchema)) {
+    return setMeta(optionsOrSchema, normalizePropOptions(options));
+  } else {
+    return { [metaKey]: normalizePropOptions(optionsOrSchema) };
+  }
+}
+function attr(optionsOrSchema, options) {
+  const opts = isZodType(optionsOrSchema) ? options ?? {} : optionsOrSchema ?? {};
+  const partial = {
+    decodeAsProperty(ctx) {
+      const { name, options: propOptions } = ctx.property;
+      const attrName = opts.name ?? name;
+      const attrValue = ctx.xml?.attributes[attrName];
+      ctx.result[name] = propOptions.schema.parse(attrValue);
+    },
+    encodeAsProperty(ctx) {
+      const { value, name } = ctx.property;
+      const attrName = opts.name ?? name;
+      ctx.result.attributes[attrName] = value.toString();
+    }
+  };
+  if (isZodType(optionsOrSchema)) {
+    return setMeta(optionsOrSchema, partial);
+  } else {
+    return { [metaKey]: partial };
+  }
+}
+const xml = { root, prop, attr };
+function getOwnUserOptions(schema) {
+  const meta = schema.meta();
+  return meta?.[metaKey] ?? {};
+}
+function getUserOptions(schema) {
+  const own = getOwnUserOptions(schema);
+  const parentSchema = getParentSchema(schema);
+  if (!parentSchema) return own;
+  const parentOptions = getUserOptions(parentSchema);
+  return { ...parentOptions, ...own };
+}
+export {
+  attr,
+  getOwnUserOptions,
+  getUserOptions,
+  prop,
+  root,
+  xml
+};
+//# sourceMappingURL=schema-meta.js.map

package/dist/xml/xml-js.d.ts

@@ -1,7 +1,142 @@
-import { xml2js as parse, js2xml as stringify } from 'xml-js';
-declare const _default: {
+import { Options, Element } from 'xml-js';
+import { z } from 'zod';
+export declare const ZXMLElementNode: z.ZodObject<{
+    type: z.ZodLiteral<"element">;
+    name: z.ZodString;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    elements: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject</*elided*/ any, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"comment">;
+        comment: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+export type XMLElementNode = z.infer<typeof ZXMLElementNode>;
+export declare const ZXMLCommentNode: z.ZodObject<{
+    type: z.ZodLiteral<"comment">;
+    comment: z.ZodString;
+}, z.core.$strip>;
+export type XMLCommentNode = z.infer<typeof ZXMLCommentNode>;
+export declare const ZXMLTextNode: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type XMLTextNode = z.infer<typeof ZXMLTextNode>;
+export type XMLNode = XMLElementNode | XMLCommentNode | XMLTextNode;
+export declare const ZXMLNode: z.ZodDiscriminatedUnion<[
+    typeof ZXMLElementNode,
+    typeof ZXMLCommentNode,
+    typeof ZXMLTextNode
+], "type">;
+/**
+ * A single node in the xml-js element tree.
+ * Used as the internal representation for all XML parsing and serialization.
+ */
+export type XMLElement = XMLElementNode;
+export declare const ZXMLRoot: z.ZodObject<{
+    elements: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"element">;
+        name: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        elements: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject</*elided*/ any, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"comment">;
+            comment: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>], "type">>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"comment">;
+        comment: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/** The root of an xml-js document: a wrapper object whose `elements` array holds top-level nodes.
+ *
+ * **the `elements` array contains AT MOST one node with type `element`**
+ */
+export type XMLRoot = {
+    elements: XMLNode[];
+};
+type EmptyObj = Record<PropertyKey, never>;
+export type XMLVoid = EmptyObj;
+export type ParseOptions = Omit<Options.XML2JS, "compact">;
+declare function parse(xml: string, options?: ParseOptions): XMLRoot;
+export type StringifyOptions = Options.JS2XML;
+declare function stringify(xml: XMLRoot, options?: StringifyOptions): string;
+declare function isRoot(xml: Element): xml is XMLRoot;
+declare function elementFromRoot(root: XMLRoot): XMLElementNode | undefined;
+declare function isEmpty(xml: Element): xml is XMLVoid;
+/**
+ * Extracts the text content from an element that has a single text child node.
+ *
+ * @param xml - An `XMLElement` expected to contain a single text node.
+ * @returns The text value, or an empty string when there are no child elements.
+ * @throws {TypeError} When the element has multiple or non-text children.
+ */
+declare function getContent(xml: XMLElement): string;
+/**
+ * Creates a minimal element structure wrapping the given text content.
+ * When no tag name is provided, returns a fragment with a text child.
+ * When a tag name is provided, returns a full element with the given name and optional attributes.
+ *
+ * @param content - The text content to wrap (defaults to empty string).
+ * @param tag - Optional element tag name.
+ * @param attributes - Optional attributes; only valid when `tag` is provided.
+ * @throws {TypeError} When `attributes` are provided without a `tag`.
+ */
+declare function fromContent(content: string): {
+    elements: [{
+        type: "text";
+        text: string;
+    }] | [];
+};
+declare function fromContent(content: string, tag: string, attributes?: XMLElement["attributes"]): {
+    type: "element";
+    name: string;
+    attributes?: XMLElement["attributes"];
+    elements: [{
+        type: "text";
+        text: string;
+    }] | [];
+};
+/**
+ * Appends a child element to `xml`, initialising the `elements` array if needed.
+ *
+ * @param xml - The parent element to modify.
+ * @param element - The child element to append.
+ */
+declare function addElement(xml: XMLElement, element: XMLElement): void;
+/**
+ * Sets an attribute on an element, initialising the `attributes` map if needed.
+ *
+ * @param xml - The element to modify.
+ * @param attribute - The attribute name.
+ * @param value - The attribute value.
+ */
+declare function setAttribute(xml: XMLElement, attribute: string, value: string): void;
+/**
+ * Removes an attribute from an element. Does nothing if the element has no attributes.
+ *
+ * @param xml - The element to modify.
+ * @param attribute - The attribute name to remove.
+ */
+declare function deleteAttribute(xml: XMLElement, attribute: string): void;
+/** Namespace object bundling all XML utility functions. */
+export declare const XML: {
     parse: typeof parse;
     stringify: typeof stringify;
+    isRoot: typeof isRoot;
+    elementFromRoot: typeof elementFromRoot;
+    isEmpty: typeof isEmpty;
+    fromContent: typeof fromContent;
+    getContent: typeof getContent;
+    addElement: typeof addElement;
+    setAttribute: typeof setAttribute;
+    deleteAttribute: typeof deleteAttribute;
 };
-export default _default;
+export default XML;
 //# sourceMappingURL=xml-js.d.ts.map

package/dist/xml/xml-js.js

@@ -1,9 +1,93 @@
-import { js2xml, xml2js } from "xml-js";
-const XMLJS = {
-  parse: xml2js,
-  stringify: js2xml
+import { xml2js, js2xml } from "xml-js";
+import { z } from "zod";
+const ZXMLElementNode = z.object({
+  type: z.literal("element"),
+  // TODO: test if required
+  name: z.string(),
+  attributes: z.record(z.string(), z.string()).optional(),
+  get elements() {
+    return z.array(ZXMLNode).optional();
+  }
+  // TODO: other fields
+});
+const ZXMLCommentNode = z.object({ type: z.literal("comment"), comment: z.string() });
+const ZXMLTextNode = z.object({ type: z.literal("text"), text: z.string() });
+const ZXMLNode = z.discriminatedUnion("type", [ZXMLElementNode, ZXMLCommentNode, ZXMLTextNode]);
+const ZXMLRoot = z.object({ elements: z.array(ZXMLNode) });
+function parse(xml, options = {}) {
+  const strippedOptions = { ...options };
+  delete strippedOptions["compact"];
+  const res = xml2js(xml, strippedOptions);
+  if ("elements" in res) return res;
+  throw new Error("Got empty XML");
+}
+function stringify(xml, options = {}) {
+  return js2xml(xml, options);
+}
+function isRoot(xml) {
+  const keys = Object.keys(xml);
+  return keys.length === 1 && Array.isArray(xml.elements);
+}
+function elementFromRoot(root) {
+  return root.elements.find((el) => el.type === "element");
+}
+function isEmpty(xml) {
+  return Object.keys(xml).length === 0;
+}
+function getContent(xml) {
+  if (xml.elements?.length === 1) {
+    const content = xml.elements[0];
+    if (content.type === "text") return content.text;
+  }
+  if (!xml.elements) return "";
+  throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
+}
+function fromContent(content = "", tag, attributes) {
+  const elements = content ? [{ type: "text", text: String(content) }] : [];
+  if (!tag) {
+    return { elements };
+  }
+  const el = {
+    type: "element",
+    name: tag,
+    elements
+  };
+  if (attributes) {
+    el.attributes = attributes;
+  }
+  return el;
+}
+function addElement(xml, element) {
+  if (!xml.elements) xml.elements = [];
+  xml.elements.push(element);
+}
+function setAttribute(xml, attribute, value) {
+  if (!xml.attributes) xml.attributes = {};
+  xml.attributes[attribute] = value;
+}
+function deleteAttribute(xml, attribute) {
+  if (!xml.attributes) return;
+  delete xml.attributes[attribute];
+}
+const XML = {
+  parse,
+  stringify,
+  isRoot,
+  elementFromRoot,
+  isEmpty,
+  fromContent,
+  getContent,
+  addElement,
+  setAttribute,
+  deleteAttribute
 };
 export {
-  XMLJS as default
+  XML,
+  ZXMLCommentNode,
+  ZXMLElementNode,
+  ZXMLNode,
+  ZXMLRoot,
+  ZXMLTextNode,
+  XML as default
 };
 //# sourceMappingURL=xml-js.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "1.3.3",
+  "version": "2.0.0-beta.1",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -11,9 +11,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./vite": {
-      "types": "./dist/vite/index.d.ts",
-      "import": "./dist/vite/index.js"
+    "./xml": {
+      "types": "./dist/xml/index.d.ts",
+      "import": "./dist/xml/index.js"
     },
     "./*": {
       "types": "./dist/*.d.ts",
@@ -26,6 +26,7 @@
     "postversion": "git push && git push --tags",
     "build": "vite build",
     "dev": "vite build --watch",
+    "docs": "vite dev",
     "test": "vitest",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
@@ -34,38 +35,24 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "typescript-rtti": "0.9.6",
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@rollup/plugin-typescript": "*",
     "@types/node": "^24.10.11",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
-    "marmotte": "^0.4.2",
+    "marmotte": "^0.4.4",
     "oxfmt": "^0.36.0",
     "oxlint": "^1.51.0",
-    "reflect-metadata": "^0.1.14",
-    "typescript": "*",
-    "vite": "*",
+    "typescript": "^5.9.3",
     "vitepress": "^2.0.0-alpha.16",
+    "vitepress-plugin-llms": "^1.11.0",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@rollup/plugin-typescript": "^12.3.0",
-    "tslib": "^2.8.1",
-    "typescript": "~5.1.6",
-    "vite": "^7.3.1"
-  },
-  "peerDependenciesMeta": {
-    "@rollup/plugin-typescript": {
-      "optional": true
-    },
-    "vite": {
-      "optional": true
-    }
+    "zod": "^4.1.0"
   },
   "lint-staged": {
     "*": "oxfmt --no-error-on-unmatched-pattern"
   }
-}
+}

package/dist/_virtual/Reflect.js

@@ -1,8 +0,0 @@
-import { getDefaultExportFromCjs } from "./_commonjsHelpers.js";
-import { __require as require_Reflect } from "../node_modules/reflect-metadata/Reflect.js";
-var _ReflectExports = require_Reflect();
-const Reflect = /* @__PURE__ */ getDefaultExportFromCjs(_ReflectExports);
-export {
-  Reflect as default
-};
-//# sourceMappingURL=Reflect.js.map

package/dist/_virtual/Reflect2.js

@@ -1,5 +0,0 @@
-var _Reflect = {};
-export {
-  _Reflect as __exports
-};
-//# sourceMappingURL=Reflect2.js.map

package/dist/_virtual/_commonjsHelpers.js

@@ -1,47 +0,0 @@
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-function getDefaultExportFromNamespaceIfPresent(n) {
-  return n && Object.prototype.hasOwnProperty.call(n, "default") ? n["default"] : n;
-}
-function getDefaultExportFromNamespaceIfNotNamed(n) {
-  return n && Object.prototype.hasOwnProperty.call(n, "default") && Object.keys(n).length === 1 ? n["default"] : n;
-}
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
-  var f = n.default;
-  if (typeof f == "function") {
-    var a = function a2() {
-      var isInstance = false;
-      try {
-        isInstance = this instanceof a2;
-      } catch {
-      }
-      if (isInstance) {
-        return Reflect.construct(f, arguments, this.constructor);
-      }
-      return f.apply(this, arguments);
-    };
-    a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
-export {
-  commonjsGlobal,
-  getAugmentedNamespace,
-  getDefaultExportFromCjs,
-  getDefaultExportFromNamespaceIfNotNamed,
-  getDefaultExportFromNamespaceIfPresent
-};
-//# sourceMappingURL=_commonjsHelpers.js.map