qcobjects 2.4.107-ts → 2.5.101-ts

package/src/WidgetsFactory.ts

@@ -0,0 +1,543 @@
+ 
+/* eslint-disable no-unused-vars */
+import { I_ComponentWidget_ } from "types";
+import { _DOMCreateElement } from "./DOMCreateElement";
+import { Export } from "./Export";
+import { _protected_code_ } from "./introspection";
+import { isBrowser } from "./platform";
+
+class QCObjectsWidgetNode implements I_ComponentWidget_ {
+  accessKey!: string;
+  accessKeyLabel!: string;
+  autocapitalize!: string;
+  dir!: string;
+  draggable!: boolean;
+  hidden!: boolean;
+  inert!: boolean;
+  innerText!: string;
+  lang!: string;
+  offsetHeight!: number;
+  offsetLeft!: number;
+  offsetParent!: Element | null;
+  offsetTop!: number;
+  offsetWidth!: number;
+  outerText!: string;
+  popover!: string | null;
+  spellcheck!: boolean;
+  title!: string;
+  translate!: boolean;
+  attachInternals(): ElementInternals {
+    throw new Error("Method not implemented.");
+  }
+  click(): void {
+    throw new Error("Method not implemented.");
+  }
+  hidePopover(): void {
+    throw new Error("Method not implemented.");
+  }
+  showPopover(): void {
+    throw new Error("Method not implemented.");
+  }
+  togglePopover(force?: boolean): boolean {
+    throw new Error("Method not implemented.");
+  }
+  addEventListener(type: unknown, listener: unknown, options?: unknown): void {
+    throw new Error("Method not implemented.");
+  }
+  removeEventListener(type: unknown, listener: unknown, options?: unknown): void {
+    throw new Error("Method not implemented.");
+  }
+  attributes!: NamedNodeMap;
+  classList!: DOMTokenList;
+  className!: string;
+  clientHeight!: number;
+  clientLeft!: number;
+  clientTop!: number;
+  clientWidth!: number;
+  id!: string;
+  innerHTML!: string;
+  localName!: string;
+  namespaceURI!: string | null;
+  onfullscreenchange!: ((this: Element, ev: Event) => any) | null;
+  onfullscreenerror!: ((this: Element, ev: Event) => any) | null;
+  outerHTML!: string;
+  ownerDocument!: Document;
+  part!: DOMTokenList;
+  prefix!: string | null;
+  scrollHeight!: number;
+  scrollLeft!: number;
+  scrollTop!: number;
+  scrollWidth!: number;
+  shadowRoot!: ShadowRoot | null;
+  slot!: string;
+  tagName!: string;
+  attachShadow(init: ShadowRootInit): ShadowRoot {
+    throw new Error("Method not implemented.");
+  }
+  checkVisibility(options?: CheckVisibilityOptions): boolean {
+    throw new Error("Method not implemented.");
+  }
+  closest(selectors: unknown): any {
+    throw new Error("Method not implemented.");
+  }
+  computedStyleMap(): StylePropertyMapReadOnly {
+    throw new Error("Method not implemented.");
+  }
+  getAttribute(qualifiedName: string): string | null {
+    throw new Error("Method not implemented.");
+  }
+  getAttributeNS(namespace: string | null, localName: string): string | null {
+    throw new Error("Method not implemented.");
+  }
+  getAttributeNames(): string[] {
+    throw new Error("Method not implemented.");
+  }
+  getAttributeNode(qualifiedName: string): Attr | null {
+    throw new Error("Method not implemented.");
+  }
+  getAttributeNodeNS(namespace: string | null, localName: string): Attr | null {
+    throw new Error("Method not implemented.");
+  }
+  getBoundingClientRect(): DOMRect {
+    throw new Error("Method not implemented.");
+  }
+  getClientRects(): DOMRectList {
+    throw new Error("Method not implemented.");
+  }
+  getElementsByClassName(classNames: string): HTMLCollectionOf<Element> {
+    throw new Error("Method not implemented.");
+  }
+  getElementsByTagName(qualifiedName: unknown): HTMLCollectionOf<Element> | HTMLCollectionOf<any> {
+    throw new Error("Method not implemented.");
+  }
+  getElementsByTagNameNS(namespace: unknown, localName: unknown): HTMLCollectionOf<any> {
+    throw new Error("Method not implemented.");
+  }
+  getHTML(options?: GetHTMLOptions): string {
+    throw new Error("Method not implemented.");
+  }
+  hasAttribute(qualifiedName: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  hasAttributeNS(namespace: string | null, localName: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  hasAttributes(): boolean {
+    throw new Error("Method not implemented.");
+  }
+  hasPointerCapture(pointerId: number): boolean {
+    throw new Error("Method not implemented.");
+  }
+  insertAdjacentElement(where: InsertPosition, element: Element): Element | null {
+    throw new Error("Method not implemented.");
+  }
+  insertAdjacentHTML(position: InsertPosition, string: string): void {
+    throw new Error("Method not implemented.");
+  }
+  insertAdjacentText(where: InsertPosition, data: string): void {
+    throw new Error("Method not implemented.");
+  }
+  matches(selectors: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  releasePointerCapture(pointerId: number): void {
+    throw new Error("Method not implemented.");
+  }
+  removeAttribute(qualifiedName: string): void {
+    throw new Error("Method not implemented.");
+  }
+  removeAttributeNS(namespace: string | null, localName: string): void {
+    throw new Error("Method not implemented.");
+  }
+  removeAttributeNode(attr: Attr): Attr {
+    throw new Error("Method not implemented.");
+  }
+  requestFullscreen(options?: FullscreenOptions): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  requestPointerLock(options?: PointerLockOptions): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  scroll(x?: unknown, y?: unknown): void {
+    throw new Error("Method not implemented.");
+  }
+  scrollBy(x?: unknown, y?: unknown): void {
+    throw new Error("Method not implemented.");
+  }
+  scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void {
+    throw new Error("Method not implemented.");
+  }
+  scrollTo(x?: unknown, y?: unknown): void {
+    throw new Error("Method not implemented.");
+  }
+  setAttribute(qualifiedName: string, value: string): void {
+    throw new Error("Method not implemented.");
+  }
+  setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void {
+    throw new Error("Method not implemented.");
+  }
+  setAttributeNode(attr: Attr): Attr | null {
+    throw new Error("Method not implemented.");
+  }
+  setAttributeNodeNS(attr: Attr): Attr | null {
+    throw new Error("Method not implemented.");
+  }
+  setHTMLUnsafe(html: string): void {
+    throw new Error("Method not implemented.");
+  }
+  setPointerCapture(pointerId: number): void {
+    throw new Error("Method not implemented.");
+  }
+  toggleAttribute(qualifiedName: string, force?: boolean): boolean {
+    throw new Error("Method not implemented.");
+  }
+  webkitMatchesSelector(selectors: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  baseURI!: string;
+  childNodes!: NodeListOf<ChildNode>;
+  firstChild!: ChildNode | null;
+  isConnected!: boolean;
+  lastChild!: ChildNode | null;
+  nextSibling!: ChildNode | null;
+  nodeName!: string;
+  nodeType!: number;
+  nodeValue!: string | null;
+  parentElement!: HTMLElement | null;
+  parentNode!: ParentNode | null;
+  previousSibling!: ChildNode | null;
+  textContent!: string | null;
+  appendChild<T extends Node>(node: T): T {
+    throw new Error("Method not implemented.");
+  }
+  cloneNode(deep?: boolean): Node {
+    throw new Error("Method not implemented.");
+  }
+  compareDocumentPosition(other: Node): number {
+    throw new Error("Method not implemented.");
+  }
+  contains(other: Node | null): boolean {
+    throw new Error("Method not implemented.");
+  }
+  getRootNode(options?: GetRootNodeOptions): Node {
+    throw new Error("Method not implemented.");
+  }
+  hasChildNodes(): boolean {
+    throw new Error("Method not implemented.");
+  }
+  insertBefore<T extends Node>(node: T, child: Node | null): T {
+    throw new Error("Method not implemented.");
+  }
+  isDefaultNamespace(namespace: string | null): boolean {
+    throw new Error("Method not implemented.");
+  }
+  isEqualNode(otherNode: Node | null): boolean {
+    throw new Error("Method not implemented.");
+  }
+  isSameNode(otherNode: Node | null): boolean {
+    throw new Error("Method not implemented.");
+  }
+  lookupNamespaceURI(prefix: string | null): string | null {
+    throw new Error("Method not implemented.");
+  }
+  lookupPrefix(namespace: string | null): string | null {
+    throw new Error("Method not implemented.");
+  }
+  normalize(): void {
+    throw new Error("Method not implemented.");
+  }
+  removeChild<T extends Node>(child: T): T {
+    throw new Error("Method not implemented.");
+  }
+  replaceChild<T extends Node>(node: Node, child: T): T {
+    throw new Error("Method not implemented.");
+  }
+  ELEMENT_NODE!: 1;
+  ATTRIBUTE_NODE!: 2;
+  TEXT_NODE!: 3;
+  CDATA_SECTION_NODE!: 4;
+  ENTITY_REFERENCE_NODE!: 5;
+  ENTITY_NODE!: 6;
+  PROCESSING_INSTRUCTION_NODE!: 7;
+  COMMENT_NODE!: 8;
+  DOCUMENT_NODE!: 9;
+  DOCUMENT_TYPE_NODE!: 10;
+  DOCUMENT_FRAGMENT_NODE!: 11;
+  NOTATION_NODE!: 12;
+  DOCUMENT_POSITION_DISCONNECTED!: 1;
+  DOCUMENT_POSITION_PRECEDING!: 2;
+  DOCUMENT_POSITION_FOLLOWING!: 4;
+  DOCUMENT_POSITION_CONTAINS!: 8;
+  DOCUMENT_POSITION_CONTAINED_BY!: 16;
+  DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC!: 32;
+  dispatchEvent(event: Event): boolean {
+    throw new Error("Method not implemented.");
+  }
+  ariaAtomic!: string | null;
+  ariaAutoComplete!: string | null;
+  ariaBrailleLabel!: string | null;
+  ariaBrailleRoleDescription!: string | null;
+  ariaBusy!: string | null;
+  ariaChecked!: string | null;
+  ariaColCount!: string | null;
+  ariaColIndex!: string | null;
+  ariaColSpan!: string | null;
+  ariaCurrent!: string | null;
+  ariaDescription!: string | null;
+  ariaDisabled!: string | null;
+  ariaExpanded!: string | null;
+  ariaHasPopup!: string | null;
+  ariaHidden!: string | null;
+  ariaInvalid!: string | null;
+  ariaKeyShortcuts!: string | null;
+  ariaLabel!: string | null;
+  ariaLevel!: string | null;
+  ariaLive!: string | null;
+  ariaModal!: string | null;
+  ariaMultiLine!: string | null;
+  ariaMultiSelectable!: string | null;
+  ariaOrientation!: string | null;
+  ariaPlaceholder!: string | null;
+  ariaPosInSet!: string | null;
+  ariaPressed!: string | null;
+  ariaReadOnly!: string | null;
+  ariaRequired!: string | null;
+  ariaRoleDescription!: string | null;
+  ariaRowCount!: string | null;
+  ariaRowIndex!: string | null;
+  ariaRowSpan!: string | null;
+  ariaSelected!: string | null;
+  ariaSetSize!: string | null;
+  ariaSort!: string | null;
+  ariaValueMax!: string | null;
+  ariaValueMin!: string | null;
+  ariaValueNow!: string | null;
+  ariaValueText!: string | null;
+  role!: string | null;
+  animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation {
+    throw new Error("Method not implemented.");
+  }
+  getAnimations(options?: GetAnimationsOptions): Animation[] {
+    throw new Error("Method not implemented.");
+  }
+  after(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+  before(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+  remove(): void {
+    throw new Error("Method not implemented.");
+  }
+  replaceWith(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+  nextElementSibling!: Element | null;
+  previousElementSibling!: Element | null;
+  childElementCount!: number;
+  children!: HTMLCollection;
+  firstElementChild!: Element | null;
+  lastElementChild!: Element | null;
+   
+  append(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+   
+  prepend(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+   
+  querySelector(selectors: unknown): any {
+    throw new Error("Method not implemented.");
+  }
+   
+  querySelectorAll(selectors: unknown): NodeListOf<any> {
+    throw new Error("Method not implemented.");
+  }
+  replaceChildren(...nodes: (Node | string)[]): void {
+    throw new Error("Method not implemented.");
+  }
+  assignedSlot!: HTMLSlotElement | null;
+  attributeStyleMap!: StylePropertyMap;
+  style!: CSSStyleDeclaration;
+  contentEditable!: string;
+  enterKeyHint!: string;
+  inputMode!: string;
+  isContentEditable!: boolean;
+  onabort!: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+  onanimationcancel!: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+  onanimationend!: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+  onanimationiteration!: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+  onanimationstart!: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+  onauxclick!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onbeforeinput!: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+  onbeforetoggle!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onblur!: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+  oncancel!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncanplay!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncanplaythrough!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onchange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onclick!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onclose!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncontextlost!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncontextmenu!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  oncontextrestored!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncopy!: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+  oncuechange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oncut!: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+  ondblclick!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  ondrag!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondragend!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondragenter!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondragleave!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondragover!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondragstart!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondrop!: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+  ondurationchange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onemptied!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onended!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onerror!: OnErrorEventHandler;
+  onfocus!: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+  onformdata!: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+  ongotpointercapture!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  oninput!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  oninvalid!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onkeydown!: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+  onkeypress!: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+  onkeyup!: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+  onload!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onloadeddata!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onloadedmetadata!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onloadstart!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onlostpointercapture!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onmousedown!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmouseenter!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmouseleave!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmousemove!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmouseout!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmouseover!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onmouseup!: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+  onpaste!: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+  onpause!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onplay!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onplaying!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onpointercancel!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerdown!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerenter!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerleave!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointermove!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerout!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerover!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onpointerup!: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+  onprogress!: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+  onratechange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onreset!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onresize!: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+  onscroll!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onscrollend!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onsecuritypolicyviolation!: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+  onseeked!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onseeking!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onselect!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onselectionchange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onselectstart!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onslotchange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onstalled!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onsubmit!: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+  onsuspend!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  ontimeupdate!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  ontoggle!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+  ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+  ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+  ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+  ontransitioncancel!: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+  ontransitionend!: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+  ontransitionrun!: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+  ontransitionstart!: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+  onvolumechange!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwaiting!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwebkitanimationend!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwebkitanimationiteration!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwebkitanimationstart!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwebkittransitionend!: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+  onwheel!: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+  autofocus!: boolean;
+  dataset!: DOMStringMap;
+  nonce?: string | undefined;
+  tabIndex!: number;
+  blur(): void {
+    throw new Error("Method not implemented.");
+  }
+  focus(options?: FocusOptions): void {
+    throw new Error("Method not implemented.");
+  }
+
+}
+
+export let _ComponentWidget_:CustomElementConstructor;
+if (isBrowser) {
+  _ComponentWidget_ = class _ComponentWidget_ extends HTMLElement implements I_ComponentWidget_ {
+    constructor() {
+      super();
+      const componentWidget = this;
+      const componentName = componentWidget.nodeName.toLowerCase();
+      const componentBody = _DOMCreateElement("quick-component");
+      const __enabled__atributes__ = componentWidget.getAttributeNames();
+      componentBody.setAttribute("name", componentName);
+  
+      if (!componentWidget.hasAttribute("shadowed")) {
+        componentBody.setAttribute("shadowed", "true");
+      }
+      __enabled__atributes__.map(function (attributeName) {
+        if (componentWidget.hasAttribute(attributeName)) {
+          componentBody.setAttribute(attributeName, componentWidget?.getAttribute(attributeName) as any);
+          componentWidget.removeAttribute(attributeName);
+        }
+      });
+      const data_attributenames = componentWidget.getAttributeNames().filter(function (a) {
+        return a.startsWith("data-");
+      }).map(function (a) {
+        return a.split("-")[1];
+      });
+      data_attributenames.map(function (_attribute_name_) {
+        componentBody.setAttribute("data-" + _attribute_name_, componentWidget?.getAttribute("data-" + _attribute_name_) as any);
+        componentWidget.removeAttribute("data-" + _attribute_name_);
+      });
+      [...(componentWidget as any).children].map(function (element) {
+        componentBody.appendChild(element.cloneNode(true));
+        element.remove();
+      });
+  
+      componentWidget.append(componentBody);
+    }
+  };
+  
+} else {
+  _ComponentWidget_ = class _ComponentWidget_ extends QCObjectsWidgetNode {
+    constructor (){
+      super();
+      throw new Error ("Class not implemented.");
+    }
+  };
+}
+Export(_ComponentWidget_);
+export const RegisterWidget = function (widgetName: string) {
+  if (isBrowser){
+    customElements.define(widgetName, class extends _ComponentWidget_ { });
+  } else {
+    throw new Error ("RegisterWidget is not implemented for non browser ecosystems yet.");
+  }
+};
+export const RegisterWidgets = function (...args: string[]) {
+  const widgetList = [...args];
+  widgetList.filter(function (widgetName) {
+    return typeof widgetName === "string";
+  }).map(function (widgetName) {
+    return RegisterWidget(widgetName);
+  });
+};
+(_protected_code_)(RegisterWidget);
+(_protected_code_)(RegisterWidgets);
+Export(RegisterWidget);
+Export(RegisterWidgets);

package/src/assign.ts

@@ -0,0 +1,33 @@
+    // Object.assign Polyfilling
+    // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill
+    if (typeof Object.assign !== "function") {
+        // Must be writable: true, enumerable: false, configurable: true
+        Object.defineProperty(Object, "assign", {
+          // eslint-disable-next-line no-unused-vars
+          value: function assign(target: null, varArgs: any):any { // .length of function is 2
+            "use strict";
+            if (target === null) { // TypeError if undefined or null
+              throw new TypeError("Cannot convert undefined or null to object");
+            }
+  
+            const to = Object(target);
+  
+            for (let index = 1; index < arguments.length; index++) {
+              // eslint-disable-next-line prefer-rest-params
+              const nextSource = arguments[index];
+  
+              if (nextSource !== null) { // Skip over if undefined or null
+                for (const nextKey in nextSource) {
+                  // Avoid bugs when hasOwnProperty is shadowed
+                  if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                    to[nextKey] = nextSource[nextKey];
+                  }
+                }
+              }
+            }
+            return to;
+          },
+          writable: true,
+          configurable: true
+        });
+      }

package/src/asyncLoad.ts

@@ -0,0 +1,42 @@
+import { TAsyncLoadCallback } from "types";
+import { Export } from "./Export";
+import { isBrowser } from "./platform";
+import { _top } from "./top";
+
+export const _asyncLoad = [];
+export function asyncLoad(callback: TAsyncLoadCallback, args?: any[]): any {
+
+  class AsyncCallback {
+    func:TAsyncLoadCallback;
+    args?:any[];
+    constructor(callback: TAsyncLoadCallback, args: any[] = []) {
+      this.func = callback;
+      this.args = args;
+    }    
+    dispatch() {
+      ((this as AsyncCallback).func as Function).apply(this, ...args as [], this);
+    }
+  }
+  _asyncLoad.push((new AsyncCallback(callback, args)) as unknown as never);
+  return AsyncCallback;
+}
+
+export const _fireAsyncLoad = function () {
+        if (isBrowser){
+            document.addEventListener("readystatechange", () => {
+                if (document.readyState === "complete") {
+                    // eslint-disable-next-line array-callback-return
+                    _asyncLoad.map(function (fc) {
+                      (fc as any).dispatch.call(fc);
+                    });
+                  }
+            });
+        } else if (typeof _top.global !== "undefined") {
+            // eslint-disable-next-line array-callback-return
+            _asyncLoad.map(function (fc) {
+                (fc as any).dispatch.call(fc);
+              });
+        }
+    };
+
+Export(asyncLoad);

package/src/basePath.ts

@@ -0,0 +1,29 @@
+import { logger } from "./Logger";
+import { _require_, isBrowser } from "./platform";
+
+export var _basePath_ = (
+    function () {
+      let _basePath = "";
+      if (isBrowser) {
+        const baseURI = document.baseURI.split("?")[0].split("/");
+        baseURI.pop();
+        _basePath = baseURI.join("/") + "/";
+      } else {
+        let process;
+        try {
+          process = _require_("process");
+        } catch (e:any) {
+          logger.debug(`An error ocurred: ${e}.`);
+          // not a process module
+        }
+        if (typeof process !== "undefined") {
+          _basePath = `${(process).cwd()}/`;
+        } else {
+          _basePath = "";
+        }
+      }
+      return _basePath;
+    }
+  )();
+
+export const setBasePath = (value:string) => { _basePath_ = value;};

package/src/captureFalseTouch.ts

@@ -0,0 +1,29 @@
+import { logger } from "./Logger";
+import { isBrowser } from "./platform";
+
+export let supportsPassive = false;
+export const captureFalseTouch = () => {
+    return (supportsPassive) ? ({
+        passive: true
+    }) : (false);
+};
+
+// Test via a getter in the options object to see if the passive property is accessed
+if (isBrowser) {
+    try {
+        const opts = Object.defineProperty({}, "passive", {
+            get() {
+                supportsPassive = true;
+                return supportsPassive;
+            }
+        });
+        (window as any).addEventListener("testPassive", null, opts);
+        (window as any).removeEventListener("testPassive", null, opts);
+    } catch (e:any) {
+        logger.debug(`An error ocurred: ${e}.`);
+        supportsPassive = false;
+    }
+
+} else {
+    supportsPassive = false;
+}