@heartlandone/vega 2.75.1 → 2.76.0

package/dist/cjs/language-extension-8c4a56ff.js

@@ -1,210 +0,0 @@
-'use strict';
-
-const dtoRendererManager = require('./dto-renderer-manager-03e1a038.js');
-const functionExtension = require('./function-extension-cfbbc57e.js');
-require('./global-slimmer-registry-b3bce7e0.js');
-
-/**
- * Toolbar button renderer for language selection in Vega Rich Text Editor.
- */
-class RTELanguageToolbarButtonRenderer extends functionExtension.VegaRTEToolbarButtonRenderer {
-  constructor(languageList, languageChangeCallback, selectedLanguage) {
-    super();
-    this.languageList = [];
-    this.selectedLanguage = 'Select Language';
-    this.labelRef = null;
-    /**
-     * Handles the language selection event.
-     *
-     * @param {string} itemKey - The key of the selected language item.
-     */
-    this.handleDropdownClick = (itemKey) => {
-      this.setSelectedLanguage(itemKey);
-      if (typeof this.languageChangeCallback === 'function') {
-        this.languageChangeCallback(this.selectedLanguage);
-      }
-    };
-    this.languageList = languageList;
-    this.selectedLanguage = selectedLanguage;
-    this.languageChangeCallback = languageChangeCallback;
-  }
-  /**
-   * Public method to set the selected language.
-   *
-   * @param {string} language The language key to set as selected.
-   */
-  setSelectedLanguage(language) {
-    this.selectedLanguage = language;
-    if (this.labelRef) {
-      this.labelRef.textContent = this.getLanguageLabelByKey(language);
-    }
-  }
-  /**
-   * The source edit mode does not affect the language button visibility.
-   *
-   * @returns {boolean} True if the button is hidden, false otherwise.
-   */
-  isHidden() {
-    return false;
-  }
-  /**
-   * @inheritDoc
-   */
-  render(createElement, editorContext) {
-    return this.renderDropdown(createElement, editorContext, { source: this.languageList }, [
-      this.renderButton(createElement, editorContext, {
-        label: this.getLanguageLabelByKey(this.selectedLanguage),
-        showArrowIcon: true,
-      }),
-    ]);
-  }
-  /**
-   * Override to render the button label with custom behavior.
-   *
-   * @inheritDoc
-   */
-  renderButtonLabel(h, editorContext, label) {
-    const isDisabled = this.isDisabled(editorContext);
-    return h('vega-font', {
-      variant: 'font-field-label-sm',
-      color: isDisabled ? 'text-disabled' : 'text-primary',
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      ref: (el) => (this.labelRef = el),
-    }, label);
-  }
-  /* istanbul ignore next */
-  /**
-   * Handles the button click event. No need this method for language button.
-   *
-   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
-   */
-  handleButtonClick(editorContext) {
-  }
-  /**
-   * Gets the label of a language by its key.
-   *
-   * @param {string} key The language key to look up.
-   * @returns {string} The label of the language, or the key if not found.
-   */
-  getLanguageLabelByKey(key) {
-    const language = this.getListItemByKey(this.languageList, key);
-    return language.label;
-  }
-}
-
-/**
- * Language extension for Vega Rich Text Editor.
- * This extension allows users to switch between different languages and maintain separate content for each language.
- */
-class VegaRTELanguageExtension extends functionExtension.VegaRTEExtension {
-  constructor(languageList, languagesState) {
-    super();
-    this.languageState = {
-      selectedLanguage: '',
-      contentMap: {},
-    };
-    /**
-     * Listener for language change events from the toolbar button renderer.
-     *
-     * @param {string} selectedLanguage - The newly selected language.
-     */
-    this.languageChangeCallBack = (selectedLanguage) => {
-      const previousLanguage = this.languageState.selectedLanguage;
-      if (this.extensionContext && previousLanguage) {
-        this.languageState.contentMap[previousLanguage] = this.getRTELatestValue(this.extensionContext.host);
-      }
-      this.languageState.selectedLanguage = selectedLanguage;
-      this.applyLanguageContent(selectedLanguage, this.languageState.contentMap);
-    };
-    if (languagesState) {
-      this.languageState = Object.assign(Object.assign({}, this.languageState), languagesState);
-    }
-    if (!this.languageState.selectedLanguage && languageList.length > 0) {
-      this.languageState.selectedLanguage = languageList[0].key;
-    }
-    this.languageToolbarButtonRenderer = new RTELanguageToolbarButtonRenderer(languageList, this.languageChangeCallBack, this.languageState.selectedLanguage);
-    this.registerToolbarButtonRenderer('languages', this.languageToolbarButtonRenderer);
-  }
-  /**
-   * Initializes the language extension.
-   * Applies the content for the selected language upon initialization.
-   *
-   * @param {RTEExtensionContext} context The extension context.
-   */
-  initialExtension(context) {
-    super.initialExtension(context);
-    const { selectedLanguage, contentMap } = this.languageState;
-    if (contentMap && contentMap[selectedLanguage]) {
-      this.applyLanguageContent(this.languageState.selectedLanguage, this.languageState.contentMap);
-    }
-  }
-  /**
-   * Invoked to set the language extension state. The method used if the state can not be provide when the editor is initialized.
-   *
-   * @param {RTELanguageExtensionState} state The language extension state to set.
-   */
-  setState(state) {
-    const { selectedLanguage, contentMap } = state;
-    this.languageToolbarButtonRenderer.setSelectedLanguage(selectedLanguage);
-    this.languageState.selectedLanguage = selectedLanguage;
-    this.languageState.contentMap = Object.assign({}, contentMap);
-    this.applyLanguageContent(selectedLanguage, contentMap);
-  }
-  /**
-   * Invoked to get the language extension state.
-   *
-   * @returns {RTELanguageExtensionState} The current language extension state.
-   */
-  getState() {
-    const { selectedLanguage, contentMap } = this.languageState;
-    if (this.extensionContext) {
-      contentMap[selectedLanguage] = this.getRTELatestValue(this.extensionContext.host);
-    }
-    return this.languageState;
-  }
-  /**
-   * Applies the content for the selected language.
-   *
-   * @param {string} selectedLanguage - The newly selected language.
-   * @param {RTELanguageExtensionState['contentMap']} contentMap - The content map for all languages.
-   */
-  applyLanguageContent(selectedLanguage, contentMap) {
-    if (this.extensionContext && contentMap) {
-      let content = contentMap[selectedLanguage];
-      const { host, flushValue } = this.extensionContext;
-      if (content) {
-        content =
-          content instanceof dtoRendererManager.VegaRTEContent
-            ? content
-            : dtoRendererManager.VegaRTEContent.fromJSON(content, host.sourceEditConfig);
-      }
-      else {
-        content = dtoRendererManager.VegaRTEContent.createEmptyContent();
-      }
-      if (host.value !== content) {
-        flushValue(content, true);
-      }
-    }
-  }
-  /**
-   * Get the RTE latest value. The value is from the code block when in source edit mode; otherwise, it's from the host value.
-   *
-   * @param {HTMLElement} host - The host element of the rich text editor.
-   * @returns {VegaRTEContent} - The content.
-   */
-  getRTELatestValue(host) {
-    let result = host.value;
-    if (this.extensionContext && this.extensionContext.isSourceEditMode() && host.shadowRoot) {
-      const codeBlock = host.shadowRoot.querySelector('.source-view-container vega-code-block');
-      if (codeBlock) {
-        result = dtoRendererManager.VegaRTEContent.fromHtml(codeBlock.value.code, {
-          autoMatchFormat: host.sourceEditConfig.autoMatchFormat,
-        });
-      }
-    }
-    return result;
-  }
-}
-
-exports.RTELanguageToolbarButtonRenderer = RTELanguageToolbarButtonRenderer;
-exports.VegaRTELanguageExtension = VegaRTELanguageExtension;

package/dist/cjs/sanitize-fb222510.js

@@ -1,131 +0,0 @@
-'use strict';
-
-const tryGetDocument = require('./try-get-document-c0ebd39a.js');
-
-/**
- * Helper utilities for sanitizing string from harmful tags
- * This utility is intentionally restrictive of allowed tags depending on expected output.
- *
- * - Uses DOM-based parsing (no regex)
- * - All attributes are stripped
- * - Disallowed elements are unwrapped (children preserved)
- */
-class SanitizeUtility {
-  /**
-   * It cleans up string for labels and allow minor formatting like bold, italic, strong
-   *
-   * @param {string} input - the passed label input string for sanitization
-   * @returns {string} returns sanitized string
-   */
-  static sanitizeHtmlLabel(input) {
-    return this.sanitize(input, this.LABEL_ALLOWED_TAGS);
-  }
-  /**
-   * Sanitizes the provided HTML string by parsing it into a DOM tree and
-   * removing all disallowed elements and attributes.
-   *
-   * @param {string} input - raw HTML string to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @returns {string} sanitized HTML string
-   */
-  static sanitize(input, allowedTags) {
-    if (input.trim() === '')
-      return '';
-    const doc = tryGetDocument.tryGetDocument();
-    if (!doc)
-      return '';
-    const parser = new DOMParser();
-    const parsedDocument = parser.parseFromString(input, 'text/html');
-    const outputFragment = doc.createDocumentFragment();
-    parsedDocument.body.childNodes.forEach((node) => {
-      const cleanNode = this.sanitizeNode(node, allowedTags, doc);
-      if (cleanNode) {
-        outputFragment.appendChild(cleanNode);
-      }
-    });
-    return this.serializeFragment(outputFragment, doc);
-  }
-  /**
-   * Sanitizes a DOM node recursively.
-   * - Text nodes are preserved
-   * - Element nodes are sanitized based on allowed tags
-   * - Other node types are discarded
-   *
-   * @param {Node} node - DOM node to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @param {Document} doc - document reference
-   * @returns {Nullable<Node>} sanitized node or null if not allowed
-   */
-  static sanitizeNode(node, allowedTags, doc) {
-    switch (node.nodeType) {
-      case Node.TEXT_NODE:
-        return node.cloneNode(true);
-      case Node.ELEMENT_NODE:
-        return this.sanitizeElement(node, allowedTags, doc);
-      default:
-        return null;
-    }
-  }
-  /**
-   * Sanitizes an HTML element.
-   * - If the element tag is not allowed, it is removed but its children are preserved
-   * - If allowed, a clean element is created with no attributes
-   *
-   * @param {HTMLElement} element - element to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @param {Document} doc - document reference
-   * @returns {Node} sanitized node or fragment
-   */
-  static sanitizeElement(element, allowedTags, doc) {
-    if (!allowedTags.has(element.tagName)) {
-      const fragment = doc.createDocumentFragment();
-      element.childNodes.forEach((child) => {
-        const cleanChild = this.sanitizeNode(child, allowedTags, doc);
-        if (cleanChild) {
-          fragment.appendChild(cleanChild);
-        }
-      });
-      return fragment;
-    }
-    const cleanElement = doc.createElement(element.tagName.toLowerCase());
-    element.childNodes.forEach((child) => {
-      const cleanChild = this.sanitizeNode(child, allowedTags, doc);
-      if (cleanChild) {
-        cleanElement.appendChild(cleanChild);
-      }
-    });
-    return cleanElement;
-  }
-  /**
-   * Serializes a DocumentFragment back into an HTML string.
-   *
-   * @param {DocumentFragment} fragment - fragment to serialize
-   * @param {Document} doc - document reference
-   * @returns {string} serialized HTML string
-   */
-  static serializeFragment(fragment, doc) {
-    var _a;
-    const container = doc.createElement('div');
-    container.appendChild(fragment);
-    // If no HTML elements exist, return textContent
-    return container.children.length === 0 ? (_a = container.textContent) !== null && _a !== void 0 ? _a : '' : container.innerHTML;
-  }
-}
-/**
- * Set of allowed HTML tags for label rendering.
- * Tags must be uppercase to match DOMParser element.tagName output.
- */
-SanitizeUtility.LABEL_ALLOWED_TAGS = new Set(['B', 'I', 'STRONG', 'EM']);
-/**
- * Standalone helper (keeps parity with existing utility exports pattern)
- *
- * It cleans up string for labels and allow minor formatting like bold, italic, strong
- *
- * @param {string} input - the passed label input string for sanitization
- * @returns {string} returns sanitized string
- */
-function sanitizeHtmlLabel(input) {
-  return SanitizeUtility.sanitizeHtmlLabel(input);
-}
-
-exports.sanitizeHtmlLabel = sanitizeHtmlLabel;

package/dist/cjs/wait-for-vega-handler-5469ff80.js

@@ -1,63 +0,0 @@
-'use strict';
-
-require('./global-slimmer-registry-b3bce7e0.js');
-const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-e2e274e1.js');
-
-const WaitForVegaPayloadDefinition = [
-  {
-    payloadKey: 'IS_WAITFORVEGA_METHOD_CALLED',
-    payloadDescription: 'Indicate if the method waitForVega of public API WaitForVegaHandler is called',
-    /**
-     * Indicate whether the method is collected when the method been called .
-     *
-     * @param {string} scope - The class name of public api
-     * @param {string} methodName - The method name called by the public api
-     * @returns {boolean} A boolean value
-     */
-    canAccept: (scope, methodName) => scope === 'WaitForVegaHandler' && methodName === 'handle',
-    /**
-     * The function checks if the method name is waitForVega.
-     *
-     * @returns {boolean} A boolean value
-     */
-    payloadValue: () => {
-      return true;
-    },
-  },
-];
-
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-/**
- * WaitForVegaHandler to check whether the vega component has been loaded.
- */
-class WaitForVegaHandler {
-  constructor() {
-    this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicApiRuntimeMetricsSlimmer.createPublicAPIRuntimeMetricsSlimmer(WaitForVegaHandler, ['handle'], WaitForVegaPayloadDefinition);
-  }
-  /* istanbul ignore next */
-  /**
-   * Wait for all vega elements to be ready.
-   *
-   * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
-   *
-   * @vegaVersion 2.8.0
-   */
-  async handle() {
-    return await Promise.all(
-    // eslint-disable-next-line no-restricted-globals
-    Array.from(document.querySelectorAll('*:not(.hydrated)'))
-      .filter((item) => item.tagName.startsWith('VEGA'))
-      .map((item) => { var _a; return (_a = item.componentOnReady) === null || _a === void 0 ? void 0 : _a.call(item); }));
-  }
-}
-__decorate([
-  createPublicApiRuntimeMetricsSlimmer.InjectVegaTelemetrySlimmer()
-], WaitForVegaHandler.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
-const WaitForVega = new WaitForVegaHandler();
-
-exports.WaitForVega = WaitForVega;

package/dist/collection/utils/sanitize.js

@@ -1,126 +0,0 @@
-import { tryGetDocument } from './try-get-document';
-/**
- * Helper utilities for sanitizing string from harmful tags
- * This utility is intentionally restrictive of allowed tags depending on expected output.
- *
- * - Uses DOM-based parsing (no regex)
- * - All attributes are stripped
- * - Disallowed elements are unwrapped (children preserved)
- */
-export class SanitizeUtility {
-  /**
-   * It cleans up string for labels and allow minor formatting like bold, italic, strong
-   *
-   * @param {string} input - the passed label input string for sanitization
-   * @returns {string} returns sanitized string
-   */
-  static sanitizeHtmlLabel(input) {
-    return this.sanitize(input, this.LABEL_ALLOWED_TAGS);
-  }
-  /**
-   * Sanitizes the provided HTML string by parsing it into a DOM tree and
-   * removing all disallowed elements and attributes.
-   *
-   * @param {string} input - raw HTML string to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @returns {string} sanitized HTML string
-   */
-  static sanitize(input, allowedTags) {
-    if (input.trim() === '')
-      return '';
-    const doc = tryGetDocument();
-    if (!doc)
-      return '';
-    const parser = new DOMParser();
-    const parsedDocument = parser.parseFromString(input, 'text/html');
-    const outputFragment = doc.createDocumentFragment();
-    parsedDocument.body.childNodes.forEach((node) => {
-      const cleanNode = this.sanitizeNode(node, allowedTags, doc);
-      if (cleanNode) {
-        outputFragment.appendChild(cleanNode);
-      }
-    });
-    return this.serializeFragment(outputFragment, doc);
-  }
-  /**
-   * Sanitizes a DOM node recursively.
-   * - Text nodes are preserved
-   * - Element nodes are sanitized based on allowed tags
-   * - Other node types are discarded
-   *
-   * @param {Node} node - DOM node to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @param {Document} doc - document reference
-   * @returns {Nullable<Node>} sanitized node or null if not allowed
-   */
-  static sanitizeNode(node, allowedTags, doc) {
-    switch (node.nodeType) {
-      case Node.TEXT_NODE:
-        return node.cloneNode(true);
-      case Node.ELEMENT_NODE:
-        return this.sanitizeElement(node, allowedTags, doc);
-      default:
-        return null;
-    }
-  }
-  /**
-   * Sanitizes an HTML element.
-   * - If the element tag is not allowed, it is removed but its children are preserved
-   * - If allowed, a clean element is created with no attributes
-   *
-   * @param {HTMLElement} element - element to sanitize
-   * @param {ReadonlySet<string>} allowedTags - set of allowed HTML tag names
-   * @param {Document} doc - document reference
-   * @returns {Node} sanitized node or fragment
-   */
-  static sanitizeElement(element, allowedTags, doc) {
-    if (!allowedTags.has(element.tagName)) {
-      const fragment = doc.createDocumentFragment();
-      element.childNodes.forEach((child) => {
-        const cleanChild = this.sanitizeNode(child, allowedTags, doc);
-        if (cleanChild) {
-          fragment.appendChild(cleanChild);
-        }
-      });
-      return fragment;
-    }
-    const cleanElement = doc.createElement(element.tagName.toLowerCase());
-    element.childNodes.forEach((child) => {
-      const cleanChild = this.sanitizeNode(child, allowedTags, doc);
-      if (cleanChild) {
-        cleanElement.appendChild(cleanChild);
-      }
-    });
-    return cleanElement;
-  }
-  /**
-   * Serializes a DocumentFragment back into an HTML string.
-   *
-   * @param {DocumentFragment} fragment - fragment to serialize
-   * @param {Document} doc - document reference
-   * @returns {string} serialized HTML string
-   */
-  static serializeFragment(fragment, doc) {
-    var _a;
-    const container = doc.createElement('div');
-    container.appendChild(fragment);
-    // If no HTML elements exist, return textContent
-    return container.children.length === 0 ? (_a = container.textContent) !== null && _a !== void 0 ? _a : '' : container.innerHTML;
-  }
-}
-/**
- * Set of allowed HTML tags for label rendering.
- * Tags must be uppercase to match DOMParser element.tagName output.
- */
-SanitizeUtility.LABEL_ALLOWED_TAGS = new Set(['B', 'I', 'STRONG', 'EM']);
-/**
- * Standalone helper (keeps parity with existing utility exports pattern)
- *
- * It cleans up string for labels and allow minor formatting like bold, italic, strong
- *
- * @param {string} input - the passed label input string for sanitization
- * @returns {string} returns sanitized string
- */
-export function sanitizeHtmlLabel(input) {
-  return SanitizeUtility.sanitizeHtmlLabel(input);
-}

package/dist/collection/utils/test/sanitize.test.js

@@ -1,65 +0,0 @@
-import { tryGetDocument } from '../try-get-document';
-import { sanitizeHtmlLabel } from '../sanitize';
-test('sanitizeHtmlLabel should render simple string as it is', () => {
-  expect(sanitizeHtmlLabel('Hello')).toEqual('Hello');
-  expect(sanitizeHtmlLabel('Hello world paragraph text')).toEqual('Hello world paragraph text');
-  expect(sanitizeHtmlLabel('')).toBe('');
-  expect(sanitizeHtmlLabel('   ')).toBe('');
-  expect(sanitizeHtmlLabel('\n\t')).toBe('');
-});
-test('sanitizeHtmlLabel should preserve allowed formatting tags', () => {
-  // bold
-  expect(sanitizeHtmlLabel('<b>Hello</b>')).toEqual('<b>Hello</b>');
-  // italic
-  expect(sanitizeHtmlLabel('<i>Hello</i>')).toEqual('<i>Hello</i>');
-  // em
-  expect(sanitizeHtmlLabel('<em>Em</em>')).toEqual('<em>Em</em>');
-  // strong
-  expect(sanitizeHtmlLabel('<strong>Strong text</strong>')).toEqual('<strong>Strong text</strong>');
-});
-test('sanitizeHtmlLabel should not allow executable tags and functions', () => {
-  expect(sanitizeHtmlLabel('<script>window.__xssExecuted = true</script>')).toEqual('');
-  expect(sanitizeHtmlLabel('<img src="x" onerror="window.__xssImg = true">')).toEqual('');
-  expect(sanitizeHtmlLabel('<span onclick="window.__xssClick = true">Span</span>')).toEqual('Span');
-});
-test('sanitizeHtmlLabel should unwrap disallowed elements but preserve their children', () => {
-  expect(sanitizeHtmlLabel('<div>Hello <span>World</span></div>')).toEqual('Hello World');
-});
-test('sanitizeHtmlLabel should ignore non-element, non-text nodes', () => {
-  expect(sanitizeHtmlLabel('Text <!-- malicious comment --><script>alert(1)</script>')).toEqual('Text alert(1)');
-});
-it('sanitizeHtmlLabel should not return empty string if document is available', () => {
-  expect(typeof document).toBe('object');
-  expect(tryGetDocument()).toBe(document);
-  expect(sanitizeHtmlLabel('<b>Some</b> text')).toEqual('<b>Some</b> text');
-});
-it('sanitizeHtmlLabel should return empty string if document is not available', () => {
-  const originalDocument = globalThis.document;
-  delete globalThis.document;
-  expect(tryGetDocument()).toBeUndefined();
-  expect(sanitizeHtmlLabel('<b>Some</b> text')).toEqual('');
-  globalThis.document = originalDocument;
-});
-test('sanitizeHtmlLabel should return textContent if no HTML elements exist', () => {
-  expect(sanitizeHtmlLabel('>hello')).toEqual('>hello');
-  expect(sanitizeHtmlLabel('Me > You')).toEqual('Me > You');
-  expect(sanitizeHtmlLabel('Me <b>></b> You')).toEqual('Me <b>&gt;</b> You');
-});
-test('serializeFragment should return innerHTML when HTML elements exist', () => {
-  expect(sanitizeHtmlLabel('<b>Bold</b>')).toBe('<b>Bold</b>');
-});
-test('serializeFragment falls back to empty string when textContent is null', () => {
-  const originalCreateElement = document.createElement;
-  jest.spyOn(document, 'createElement').mockImplementation((tagName) => {
-    const el = originalCreateElement.call(document, tagName);
-    if (tagName === 'div') {
-      Object.defineProperty(el, 'textContent', {
-        get: () => null,
-        configurable: true,
-      });
-    }
-    return el;
-  });
-  expect(sanitizeHtmlLabel('plain text')).toBe('');
-  document.createElement.mockRestore();
-});

package/dist/esm/_commonjsHelpers-9943807e.js

@@ -1,17 +0,0 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-export { commonjsGlobal as a, createCommonjsModule as c };