argous 1.2.131 → 1.2.135

package/lib/components/ConfirmModal/BasicModal.tsx

@@ -0,0 +1,63 @@
+import { Dialog, DialogTitle, DialogContent, DialogContentText, DialogActions, Button, DialogProps } from '@material-ui/core';
+import React from 'react';
+
+export interface BasicModalProps {
+  /**
+   * Label no botao de confirmar
+   */
+  okLabel: React.ReactNode,
+  /**
+   * Label no botao de cancelar
+   */
+  cancelLabel: React.ReactNode,
+  /**
+   * Titulo do modal
+   */
+  title: React.ReactNode,
+  /**
+   * Descricao do modal
+   */
+  description: React.ReactNode,
+  /**
+   * Props repassados ao componente dialog
+   */
+  dialogProps: Omit<DialogProps, 'open'>,
+  /**
+   * @ignore
+   */
+  proceed: Function,
+  /**
+   * @ignore
+   */
+  cancel: Function,
+  /**
+   * @ignore
+   */
+  open: boolean,
+}
+
+const BasicModal = ({
+  okLabel = 'Ok',
+  cancelLabel = 'Cancelar',
+  title = '',
+  description = '',
+  open,
+  proceed,
+  dialogProps,
+  cancel
+}: BasicModalProps) => {
+  return (
+    <Dialog open={open} onClose={() => cancel(false)} {...dialogProps}>
+      <DialogTitle>{title}</DialogTitle>
+      <DialogContent>
+        <DialogContentText component='div'>{description}</DialogContentText>
+      </DialogContent>
+      <DialogActions>
+        <Button variant='contained' color='secondary' onClick={() => proceed(false)}>{cancelLabel}</Button>
+        <Button variant='contained' color='primary' onClick={() => proceed(true)}>{okLabel}</Button>
+      </DialogActions>
+    </Dialog>
+  );
+};
+
+export default BasicModal;

package/lib/components/ConfirmModal/ModalProvider.tsx

@@ -0,0 +1,81 @@
+import { CreateModalType, ModalProviderContextProps } from '.';
+import BasicModal from './BasicModal';
+import { setAnotherProgramField } from '../../fieldsRedux';
+import { ArgousType } from '../../types';
+import React, { createContext, useCallback, useEffect, useMemo, useState } from 'react';
+import { connect } from 'react-redux';
+import { useImmer } from 'use-immer';
+
+// @ts-ignore
+export const ModalProviderContext = createContext<ModalProviderContextProps>();
+
+const ModalProvider = ({ children, argousSystem }: any) => {
+
+  const [modals, setCurrentModal] = useImmer<unknown[]>([]);
+
+  const close = useCallback((unmountDelay: number, index: number) => () => {
+    setTimeout(() => setCurrentModal(modais => void(modais.splice(index, 1))), unmountDelay);
+  }, [setCurrentModal]);
+
+  const createModal = useCallback<CreateModalType>((Component, unmountDelay = 0) => (props) => {
+    const promise = new Promise((resolve, reject) => {
+      setCurrentModal(modais => void(modais.push(<ModalWrapper Component={Component} close={close(unmountDelay, modals.length)} resolve={resolve} reject={reject} {...props} />)));
+    });
+
+    return promise.then((result) => {
+      close(unmountDelay, modals.length);
+      return result;
+    }, (result) => {
+      close(unmountDelay, modals.length);
+      return Promise.reject(result);
+    });
+  }, [close, modals.length, setCurrentModal]);
+
+  const openModal = useMemo(() => argousSystem?.openModal?.value, [argousSystem]); 
+
+  useEffect(() => {
+    if (!openModal) return;
+    const { reject, resolve, ...props } = openModal;
+    createModal(BasicModal)(props).then(resolve as any, reject);
+    setAnotherProgramField('openModal', undefined, 'argousSystem');
+    //eslint-disable-next-line
+  }, [openModal]);
+
+  const context = useMemo(() => ({ createModal }), [createModal]);
+
+  return (
+    <ModalProviderContext.Provider value={context}>
+      {children}
+      {modals.map(Modal => Modal)}
+    </ModalProviderContext.Provider>
+  );
+};
+
+const mapStateToProps = (state: { argous: ArgousType }) => ({
+  argousSystem: state.argous.fields.argousSystem, 
+});
+
+export default connect(mapStateToProps)(ModalProvider);
+
+const ModalWrapper = ({ Component, reject, resolve, close, ...props }) => {
+  const [show, setShow] = useState(true);
+
+  const cancel = useCallback((reject: (reason?: any) => void) => <V extends unknown>(value: V) => {
+    setShow(false);
+    reject(value);
+    close();
+  }, [close]);
+
+  const proceed = useCallback((resolve: (value: unknown) => void) => <V extends unknown>(value: V) => {
+    setShow(false);
+    resolve(value);
+    close();
+  }, [close]);
+
+  return <Component
+    cancel={cancel(reject)}
+    proceed={proceed(resolve)}
+    open={show}
+    {...props}
+  />;
+};

package/lib/components/ConfirmModal/WrapperModal.tsx

@@ -0,0 +1,33 @@
+import Button from '../MaterialButton/MaterialButton';
+import { Dialog, DialogActions, DialogContent, DialogProps, DialogTitle } from '@material-ui/core';
+import React from 'react';
+
+export interface WrapperModalProps {
+  okLabel: React.ReactNode,
+  cancelLabel: React.ReactNode,
+  title: React.ReactNode,
+  dialogProps: Omit<DialogProps, 'open'>,
+  /**
+   * @ignore
+   */
+  proceed: Function,
+  /**
+   * @ignore
+   */
+  open: boolean,
+}
+
+const WrapperModal = (Component: (props: any) => JSX.Element) => ({ proceed, open, title, cancelLabel = 'Cancelar', okLabel = 'Ok', dialogProps, ...props }: WrapperModalProps) => {
+  return <Dialog open={open} onClose={() => proceed(false)} {...dialogProps}>
+    {title && <DialogTitle>{title}</DialogTitle>}
+    <DialogContent>
+      <Component {...props}/>
+    </DialogContent>
+    <DialogActions>
+      {cancelLabel && <Button variant='contained' color='secondary' onClick={() => proceed(false)}>{cancelLabel}</Button>}
+      {okLabel && <Button variant='contained' color='primary' onClick={() => proceed(true)}>{okLabel}</Button>}
+    </DialogActions>
+  </Dialog>;
+};
+
+export default WrapperModal;

package/lib/components/ConfirmModal/index.d.ts

@@ -0,0 +1,20 @@
+export interface BasicComponentProps {
+  cancel: (value: unknown) => void,
+  proceed: (value: unknown) => void,
+  open: boolean
+}
+
+export type CreateModalType = <P>(Component: (props: P & BasicComponentProps) => JSX.Element, unmountDelay?: number) => (props?: Omit<P, keyof BasicComponentProps>) => Promise<unknown>
+
+export interface ModalProviderContextProps {
+  createModal: CreateModalType
+}
+
+export { default } from './ModalProvider';
+export * from './ModalProvider';
+
+export { default as BasicModal } from './BasicModal';
+export * from './BasicModal';
+
+export { default as WrapperModal } from './WrapperModal';
+export * from './WrapperModal';

package/lib/components/ConfirmModal/index.js

@@ -0,0 +1,8 @@
+export { default } from './ModalProvider';
+export * from './ModalProvider';
+
+export { default as BasicModal } from './BasicModal';
+export * from './BasicModal';
+
+export { default as WrapperModal } from './WrapperModal';
+export * from './WrapperModal';

package/lib/components/DropArea/DropArea.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+
+export interface DropAreaProps extends Omit<React.HTMLProps<HTMLDivElement>, 'onChange'> {
+  /**
+   * Função chamada ao receber arquivo
+   * 
+   * @param arquivo - Arquivo
+   * 
+   * @returns {void} Sem Retorno
+   */
+  onChange?: (arquivo: File) => void
+}
+
+/**
+ * Componente para drop de arquivos
+ * 
+ * Repassa o arquivo dropado diretamente para um file preparer se tiver o mesmo como filho
+ */
+declare function DropArea(props: DropAreaProps): JSX.Element
+
+export default DropArea;

package/lib/components/DropArea/DropArea.js

@@ -0,0 +1,90 @@
+import { getDroppedOrSelectedFiles } from './Html5FileSelector';
+import { FilePreparer } from '../';
+import { Box, CircularProgress } from '@material-ui/core';
+import React, { useState, Children, isValidElement, cloneElement, forwardRef } from 'react';
+import { MdFileUpload } from 'react-icons/md';
+
+const DropArea = ({ children, onChange, style, ...props }, ref) => {
+  
+  const [abrir, setAbrir] = useState(false);
+  const [loading, setLoading] = useState(false);
+
+  /** @param {React.DragEvent<HTMLDivElement>} e */
+  const dropArquivo = async e => {
+    e.preventDefault();
+    setLoading(true);
+
+    const finalArray = await getDroppedOrSelectedFiles(e);
+
+    // console.log(temp, temp.reduce((acc, { fileObject, fullPath }) => {
+    //   const fileName = fullPath.match(/\/([^\/]*)$/)?.at(1);
+    //   const objectPath = fullPath.replace(fileName, '').substring(1).slice(0, -1);
+    //   return set(acc, objectPath.length ? [...objectPath.split('/'), fileName] : fileName, fileObject)
+    // }, {}));
+
+    // const length = e.dataTransfer.items.length, 
+    //     i = 0, itens = e.dataTransfer.items, finalArray = [];
+
+    // for (i; i < length; i++) {
+    //   const item = itens[i];
+    //   if (item.kind === 'file') finalArray.push(item.getAsFile())
+    // }
+
+    // onChange && onChange(finalArray)
+    // if (ref?.current) ref.current.preparaArquivo(finalArray)
+
+    onChange && onChange(finalArray);
+    if (ref?.current) ref.current.preparaArquivo(finalArray);
+
+    setLoading(false);
+    setAbrir(false);
+  };
+
+  return (
+    <div onDragEnter={() => setAbrir(true)} style={{ position: 'relative', ...style }} {...props}>
+      {abrir && (!ref?.current || (ref.current && !ref.current.loading)) && (
+        <div onDragLeave={() => setAbrir(false)} onDrop={dropArquivo} onDragOver={e => e.preventDefault() }
+          style={{ 
+            position: 'absolute', 
+            border: '1px dashed', 
+            background: 'rgba(0,0,0,0.5)', 
+            zIndex: 5, width: '100%', height: '100%'
+          }}>
+          {loading ? 
+            <Box display='flex' justifyContent='center' alignItems='center' height='100%'>
+              <CircularProgress disableShrink/>
+            </Box>
+            :
+            <MdFileUpload style={{ width: '100%', height: '100%' }}/>
+          }
+        </div>
+      )} 
+      {deepMap(children, (filho) => filho.type === FilePreparer ? cloneElement(filho, { ...filho.props, ref }) : filho)}
+    </div>
+  );
+};
+
+export default forwardRef(DropArea);
+
+
+const deepMap = (children, deepMapFn) => {
+  return Children.toArray(children).map((child, index, mapChildren) => {
+    if (isValidElement(child) && hasComplexChildren(child)) {
+      return deepMapFn(
+        cloneElement(child, {
+          ...child.props,
+          children: deepMap(child.props.children, deepMapFn),
+        }),
+      );
+    }
+    return deepMapFn(child, index, mapChildren);
+  },
+  );
+};
+
+const hasComplexChildren = (element) =>
+  isValidElement(element) &&
+  hasChildren(element) &&
+  Children.toArray(element.props.children).reduce((response, child) => response || isValidElement(child), false);
+
+const hasChildren = (element) => isValidElement(element) && element.props.children;

package/lib/components/DropArea/Html5FileSelector.js

@@ -0,0 +1,164 @@
+const DEFAULT_FILES_TO_IGNORE = [
+  '.DS_Store', // OSX indexing file
+  'Thumbs.db' // Windows indexing file
+];
+
+// map of common (mostly media types) mime types to use when the browser does not supply the mime type
+const EXTENSION_TO_MIME_TYPE_MAP = {
+  avi: 'video/avi',
+  gif: 'image/gif',
+  ico: 'image/x-icon',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  mkv: 'video/x-matroska',
+  mov: 'video/quicktime',
+  mp4: 'video/mp4',
+  pdf: 'application/pdf',
+  png: 'image/png',
+  zip: 'application/zip'
+};
+
+function shouldIgnoreFile(file) {
+  return DEFAULT_FILES_TO_IGNORE.indexOf(file.name) >= 0;
+}
+
+function copyString(aString) {
+  return ` ${aString}`.slice(1);
+}
+
+function traverseDirectory(entry) {
+  const reader = entry.createReader();
+  // Resolved when the entire directory is traversed
+  return new Promise((resolveDirectory) => {
+    const iterationAttempts = [];
+    const errorHandler = () => {};
+    function readEntries() {
+      // According to the FileSystem API spec, readEntries() must be called until
+      // it calls the callback with an empty array.
+      reader.readEntries((batchEntries) => {
+        if (!batchEntries.length) {
+          // Done iterating this particular directory
+          resolveDirectory(Promise.all(iterationAttempts));
+        } else {
+          // Add a list of promises for each directory entry.  If the entry is itself
+          // a directory, then that promise won't resolve until it is fully traversed.
+          iterationAttempts.push(Promise.all(batchEntries.map((batchEntry) => {
+            if (batchEntry.isDirectory) {
+              return traverseDirectory(batchEntry);
+            }
+            return Promise.resolve(batchEntry);
+          })));
+          // Try calling readEntries() again for the same dir, according to spec
+          readEntries();
+        }
+      }, errorHandler);
+    }
+    // initial call to recursive entry reader function
+    readEntries();
+  });
+}
+
+// package the file in an object that includes the fullPath from the file entry
+// that would otherwise be lost
+function packageFile(file, entry) {
+  // let fileTypeOverride = '';
+  // handle some browsers sometimes missing mime types for dropped files
+  // const hasExtension = file.name && file.name.lastIndexOf('.') !== -1;
+  // if (hasExtension && !file.type) {
+  // const fileExtension = (file.name || '').split('.').pop();
+  // fileTypeOverride = EXTENSION_TO_MIME_TYPE_MAP[fileExtension];
+  // }
+  return {
+    fileObject: file, // provide access to the raw File object (required for uploading)
+    fullPath: entry ? copyString(entry.fullPath)?.replace(file.name, '') : file.name,
+    // lastModified: file.lastModified,
+    // lastModifiedDate: file.lastModifiedDate,
+    // name: file.name,
+    // size: file.size,
+    // type: file.type ? file.type : fileTypeOverride,
+    // webkitRelativePath: file.webkitRelativePath
+  };
+}
+
+function getFile(entry) {
+  return new Promise((resolve) => {
+    entry.file((file) => {
+      resolve(packageFile(file, entry));
+    });
+  });
+}
+
+async function handleFilePromises(promises, fileList) {
+  const files = await Promise.all(promises);
+  files.forEach((file) => {
+    if (!shouldIgnoreFile(file)) {
+      fileList.push(file);
+    }
+  });
+  return fileList;
+}
+
+/**
+ * @param {DataTransfer} dataTransfer 
+ */
+export async function getDataTransferFiles(dataTransfer) {
+  const dataTransferFiles = [];
+  const folderPromises = [];
+  const filePromises = [];
+
+  [].slice.call(dataTransfer.items).forEach((listItem) => {
+    if (typeof listItem.webkitGetAsEntry === 'function') {
+      const entry = listItem.webkitGetAsEntry();
+
+      if (entry) {
+        if (entry.isDirectory) {
+          folderPromises.push(traverseDirectory(entry));
+        } else {
+          filePromises.push(getFile(entry));
+        }
+      }
+    } else {
+      dataTransferFiles.push(listItem);
+    }
+  });
+  if (folderPromises.length) {
+    const flatten = (array) => array.reduce((a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []);
+    const fileEntries = await Promise.all(folderPromises);
+    const flattenedEntries = flatten(fileEntries);
+    // collect async promises to convert each fileEntry into a File object
+    flattenedEntries.forEach((fileEntry) => {
+      filePromises.push(getFile(fileEntry));
+    });
+    return await handleFilePromises(filePromises, dataTransferFiles);
+  } else if (filePromises.length) {
+    return handleFilePromises(filePromises, dataTransferFiles);
+  }
+  return Promise.resolve(dataTransferFiles);
+}
+
+/**
+ * This function should be called from both the onDrop event from your drag/drop
+ * dropzone as well as from the HTML5 file selector input field onChange event
+ * handler.  Pass the event object from the triggered event into this function.
+ * Supports mix of files and folders dropped via drag/drop.
+ *
+ * Returns: an array of File objects, that includes all files within folders
+ *   and subfolders of the dropped/selected items.
+ * 
+ * @param {React.DragEvent<HTMLDivElement>} event
+ */
+export async function getDroppedOrSelectedFiles(event) {
+  const dataTransfer = event.dataTransfer;
+  if (dataTransfer && dataTransfer.items) {
+    return await getDataTransferFiles(dataTransfer);
+  }
+  const files = [];
+  const dragDropFileList = dataTransfer && dataTransfer.files;
+  const inputFieldFileList = event.target && event.target.files;
+  const fileList = dragDropFileList || inputFieldFileList || [];
+  // convert the FileList to a simple array of File objects
+  for (let i = 0; i < fileList.length; i++) {
+    files.push(packageFile(fileList[i]));
+  }
+  return files;
+}

package/lib/components/DropArea/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './DropArea';
+export * from './DropArea'; 

package/lib/components/DropArea/index.js

@@ -0,0 +1 @@
+export { default } from './DropArea';

package/lib/components/Editor/Events.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { Editor as TinyMCEEditor, EditorEvent, Events } from './tinymce/tinymce';
+
+export type EventHandler<A> = (a: EditorEvent<A>, editor: TinyMCEEditor) => unknown;
+
+type EEventHandler<K extends keyof Events.EditorEventMap> = EventHandler<Events.EditorEventMap[K]>;
+
+export interface INativeEvents {
+  onBeforePaste: EEventHandler<'beforepaste'>;
+  onBlur: EEventHandler<'blur'>;
+  onClick: EEventHandler<'click'>;
+  onContextMenu: EEventHandler<'contextmenu'>;
+  onCopy: EEventHandler<'copy'>;
+  onCut: EEventHandler<'cut'>;
+  onDblclick: EEventHandler<'dblclick'>;
+  onDrag: EEventHandler<'drag'>;
+  onDragDrop: EEventHandler<'dragdrop'>;
+  onDragEnd: EEventHandler<'dragend'>;
+  onDragGesture: EEventHandler<'draggesture'>;
+  onDragOver: EEventHandler<'dragover'>;
+  onDrop: EEventHandler<'drop'>;
+  onFocus: EEventHandler<'focus'>;
+  onFocusIn: EEventHandler<'focusin'>;
+  onFocusOut: EEventHandler<'focusout'>;
+  onKeyDown: EEventHandler<'keydown'>;
+  onKeyPress: EEventHandler<'keypress'>;
+  onKeyUp: EEventHandler<'keyup'>;
+  onMouseDown: EEventHandler<'mousedown'>;
+  onMouseEnter: EEventHandler<'mouseenter'>;
+  onMouseLeave: EEventHandler<'mouseleave'>;
+  onMouseMove: EEventHandler<'mousemove'>;
+  onMouseOut: EEventHandler<'mouseout'>;
+  onMouseOver: EEventHandler<'mouseover'>;
+  onMouseUp: EEventHandler<'mouseup'>;
+  onPaste: EEventHandler<'paste'>;
+  onSelectionChange: EEventHandler<'selectionchange'>;
+}
+
+export interface ITinyEvents {
+  onActivate: EEventHandler<'activate'>;
+  onAddUndo: EEventHandler<'AddUndo'>;
+  onBeforeAddUndo: EEventHandler<'BeforeAddUndo'>;
+  onBeforeExecCommand: EEventHandler<'BeforeExecCommand'>;
+  onBeforeGetContent: EEventHandler<'BeforeGetContent'>;
+  onBeforeRenderUI: EventHandler<unknown>;
+  onBeforeSetContent: EEventHandler<'BeforeSetContent'>;
+  onChange: EventHandler<unknown>;
+  onClearUndos: EEventHandler<'ClearUndos'>;
+  onDeactivate: EEventHandler<'deactivate'>;
+  onDirty: EventHandler<unknown>;
+  onExecCommand: EEventHandler<'ExecCommand'>;
+  onGetContent: EEventHandler<'GetContent'>;
+  onHide: EventHandler<unknown>;
+  onInit: EEventHandler<'init'>;
+  onLoadContent: EEventHandler<'LoadContent'>;
+  onNodeChange: EEventHandler<'NodeChange'>;
+  onPostProcess: EventHandler<unknown>;
+  onPostRender: EEventHandler<'PostRender'>;
+  onPreProcess: EventHandler<unknown>;
+  onProgressState: EEventHandler<'ProgressState'>;
+  onRedo: EEventHandler<'Redo'>;
+  onRemove: EEventHandler<'remove'>;
+  onReset: EventHandler<unknown>;
+  onSaveContent: EventHandler<unknown>;
+  onSetAttrib: EventHandler<unknown>;
+  onObjectResizeStart: EEventHandler<'ObjectResizeStart'>;
+  onObjectResized: EEventHandler<'ObjectResized'>;
+  onObjectSelected: EEventHandler<'ObjectSelected'>;
+  onSetContent: EEventHandler<'SetContent'>;
+  onShow: EventHandler<unknown>;
+  onSubmit: EventHandler<unknown>;
+  onUndo: EEventHandler<'Undo'>;
+  onVisualAid: EventHandler<unknown>;
+}
+
+export interface IEvents extends INativeEvents, ITinyEvents {}

package/lib/components/Editor/ScriptLoader.ts

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2017-present, Ephox, Inc.
+ *
+ * This source code is licensed under the Apache 2 license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import { uuid } from './Utils';
+
+export type callbackFn = () => void;
+export interface IStateObj {
+  listeners: callbackFn[];
+  scriptId: string;
+  scriptLoading: boolean;
+  scriptLoaded: boolean;
+}
+
+const createState = (): IStateObj => ({
+  listeners: [],
+  scriptId: uuid('tiny-script'),
+  scriptLoading: false,
+  scriptLoaded: false
+});
+
+interface ScriptLoaderInterface {
+  load: (doc: Document, url: string, async: boolean, defer: boolean, delay: number, callback: callbackFn) => void;
+  reinitialize: () => void;
+}
+
+const CreateScriptLoader = (): ScriptLoaderInterface => {
+  let state: IStateObj = createState();
+
+  const injectScriptTag = (scriptId: string, doc: Document, url: string, async: boolean, defer: boolean, callback: callbackFn) => {
+    const scriptTag = doc.createElement('script');
+    scriptTag.referrerPolicy = 'origin';
+    scriptTag.type = 'application/javascript';
+    scriptTag.id = scriptId;
+    scriptTag.src = url;
+    scriptTag.async = async;
+    scriptTag.defer = defer;
+
+    // scriptTag.appendChild(document.createTextNode(url));
+
+    const handler = () => {
+      scriptTag.removeEventListener('load', handler);
+      callback();
+    };
+    scriptTag.addEventListener('load', handler);
+    if (doc.head) {
+      doc.head.appendChild(scriptTag);
+    }
+    // document.body.appendChild(scriptTag);
+  };
+
+  const load = (doc: Document, url: string, async: boolean, defer: boolean, delay: number, callback: callbackFn) => {
+
+    const scriptTagInjection = () => injectScriptTag(
+      state.scriptId, doc, url, async, defer,
+      () => {
+        state.listeners.forEach((fn) => fn());
+        state.scriptLoaded = true;
+      }
+    );
+
+    if (state.scriptLoaded) {
+      callback();
+    } else {
+      state.listeners.push(callback);
+      if (!state.scriptLoading) {
+        state.scriptLoading = true;
+        if (delay > 0) {
+          setTimeout(scriptTagInjection, delay);
+        } else {
+          scriptTagInjection();
+        }
+      }
+    }
+  };
+
+  // Only to be used by tests.
+  const reinitialize = () => {
+    state = createState();
+  };
+
+  return {
+    load,
+    reinitialize
+  };
+};
+
+const ScriptLoader = CreateScriptLoader();
+
+export {
+  ScriptLoader
+};