nhj

more

unified-ai-platform/node_modules/formdata-polyfill/FormData.js

@@ -0,0 +1,441 @@
+/* formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+/* global FormData self Blob File */
+/* eslint-disable no-inner-declarations */
+
+if (typeof Blob !== 'undefined' && (typeof FormData === 'undefined' || !FormData.prototype.keys)) {
+  const global = typeof globalThis === 'object'
+    ? globalThis
+    : typeof window === 'object'
+      ? window
+      : typeof self === 'object' ? self : this
+
+  // keep a reference to native implementation
+  const _FormData = global.FormData
+
+  // To be monkey patched
+  const _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send
+  const _fetch = global.Request && global.fetch
+  const _sendBeacon = global.navigator && global.navigator.sendBeacon
+  // Might be a worker thread...
+  const _match = global.Element && global.Element.prototype
+
+  // Unable to patch Request/Response constructor correctly #109
+  // only way is to use ES6 class extend
+  // https://github.com/babel/babel/issues/1966
+
+  const stringTag = global.Symbol && Symbol.toStringTag
+
+  // Add missing stringTags to blob and files
+  if (stringTag) {
+    if (!Blob.prototype[stringTag]) {
+      Blob.prototype[stringTag] = 'Blob'
+    }
+
+    if ('File' in global && !File.prototype[stringTag]) {
+      File.prototype[stringTag] = 'File'
+    }
+  }
+
+  // Fix so you can construct your own File
+  try {
+    new File([], '') // eslint-disable-line
+  } catch (a) {
+    global.File = function File (b, d, c) {
+      const blob = new Blob(b, c || {})
+      const t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date()
+
+      Object.defineProperties(blob, {
+        name: {
+          value: d
+        },
+        lastModified: {
+          value: +t
+        },
+        toString: {
+          value () {
+            return '[object File]'
+          }
+        }
+      })
+
+      if (stringTag) {
+        Object.defineProperty(blob, stringTag, {
+          value: 'File'
+        })
+      }
+
+      return blob
+    }
+  }
+
+  function ensureArgs (args, expected) {
+    if (args.length < expected) {
+      throw new TypeError(`${expected} argument required, but only ${args.length} present.`)
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {string | undefined} filename
+   * @returns {[string, File|string]}
+   */
+  function normalizeArgs (name, value, filename) {
+    if (value instanceof Blob) {
+      filename = filename !== undefined
+      ? String(filename + '')
+      : typeof value.name === 'string'
+      ? value.name
+      : 'blob'
+
+      if (value.name !== filename || Object.prototype.toString.call(value) === '[object Blob]') {
+        value = new File([value], filename)
+      }
+      return [String(name), value]
+    }
+    return [String(name), String(value)]
+  }
+
+  // normalize line feeds for textarea
+  // https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
+  function normalizeLinefeeds (value) {
+    return value.replace(/\r?\n|\r/g, '\r\n')
+  }
+
+  /**
+   * @template T
+   * @param {ArrayLike<T>} arr
+   * @param {{ (elm: T): void; }} cb
+   */
+  function each (arr, cb) {
+    for (let i = 0; i < arr.length; i++) {
+      cb(arr[i])
+    }
+  }
+
+  const escape = str => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
+
+  /**
+   * @implements {Iterable}
+   */
+  class FormDataPolyfill {
+    /**
+     * FormData class
+     *
+     * @param {HTMLFormElement=} form
+     */
+    constructor (form) {
+      /** @type {[string, string|File][]} */
+      this._data = []
+
+      const self = this
+      form && each(form.elements, (/** @type {HTMLInputElement} */ elm) => {
+        if (
+          !elm.name ||
+          elm.disabled ||
+          elm.type === 'submit' ||
+          elm.type === 'button' ||
+          elm.matches('form fieldset[disabled] *')
+        ) return
+
+        if (elm.type === 'file') {
+          const files = elm.files && elm.files.length
+            ? elm.files
+            : [new File([], '', { type: 'application/octet-stream' })] // #78
+
+          each(files, file => {
+            self.append(elm.name, file)
+          })
+        } else if (elm.type === 'select-multiple' || elm.type === 'select-one') {
+          each(elm.options, opt => {
+            !opt.disabled && opt.selected && self.append(elm.name, opt.value)
+          })
+        } else if (elm.type === 'checkbox' || elm.type === 'radio') {
+          if (elm.checked) self.append(elm.name, elm.value)
+        } else {
+          const value = elm.type === 'textarea' ? normalizeLinefeeds(elm.value) : elm.value
+          self.append(elm.name, value)
+        }
+      })
+    }
+
+    /**
+     * Append a field
+     *
+     * @param   {string}           name      field name
+     * @param   {string|Blob|File} value     string / blob / file
+     * @param   {string=}          filename  filename to use with blob
+     * @return  {undefined}
+     */
+    append (name, value, filename) {
+      ensureArgs(arguments, 2)
+      this._data.push(normalizeArgs(name, value, filename))
+    }
+
+    /**
+     * Delete all fields values given name
+     *
+     * @param   {string}  name  Field name
+     * @return  {undefined}
+     */
+    delete (name) {
+      ensureArgs(arguments, 1)
+      const result = []
+      name = String(name)
+
+      each(this._data, entry => {
+        entry[0] !== name && result.push(entry)
+      })
+
+      this._data = result
+    }
+
+    /**
+     * Iterate over all fields as [name, value]
+     *
+     * @return {Iterator}
+     */
+    * entries () {
+      for (var i = 0; i < this._data.length; i++) {
+        yield this._data[i]
+      }
+    }
+
+    /**
+     * Iterate over all fields
+     *
+     * @param   {Function}  callback  Executed for each item with parameters (value, name, thisArg)
+     * @param   {Object=}   thisArg   `this` context for callback function
+     */
+    forEach (callback, thisArg) {
+      ensureArgs(arguments, 1)
+      for (const [name, value] of this) {
+        callback.call(thisArg, value, name, this)
+      }
+    }
+
+    /**
+     * Return first field value given name
+     * or null if non existent
+     *
+     * @param   {string}  name      Field name
+     * @return  {string|File|null}  value Fields value
+     */
+    get (name) {
+      ensureArgs(arguments, 1)
+      const entries = this._data
+      name = String(name)
+      for (let i = 0; i < entries.length; i++) {
+        if (entries[i][0] === name) {
+          return entries[i][1]
+        }
+      }
+      return null
+    }
+
+    /**
+     * Return all fields values given name
+     *
+     * @param   {string}  name  Fields name
+     * @return  {Array}         [{String|File}]
+     */
+    getAll (name) {
+      ensureArgs(arguments, 1)
+      const result = []
+      name = String(name)
+      each(this._data, data => {
+        data[0] === name && result.push(data[1])
+      })
+
+      return result
+    }
+
+    /**
+     * Check for field name existence
+     *
+     * @param   {string}   name  Field name
+     * @return  {boolean}
+     */
+    has (name) {
+      ensureArgs(arguments, 1)
+      name = String(name)
+      for (let i = 0; i < this._data.length; i++) {
+        if (this._data[i][0] === name) {
+          return true
+        }
+      }
+      return false
+    }
+
+    /**
+     * Iterate over all fields name
+     *
+     * @return {Iterator}
+     */
+    * keys () {
+      for (const [name] of this) {
+        yield name
+      }
+    }
+
+    /**
+     * Overwrite all values given name
+     *
+     * @param   {string}    name      Filed name
+     * @param   {string}    value     Field value
+     * @param   {string=}   filename  Filename (optional)
+     */
+    set (name, value, filename) {
+      ensureArgs(arguments, 2)
+      name = String(name)
+      /** @type {[string, string|File][]} */
+      const result = []
+      const args = normalizeArgs(name, value, filename)
+      let replace = true
+
+      // - replace the first occurrence with same name
+      // - discards the remaining with same name
+      // - while keeping the same order items where added
+      each(this._data, data => {
+        data[0] === name
+          ? replace && (replace = !result.push(args))
+          : result.push(data)
+      })
+
+      replace && result.push(args)
+
+      this._data = result
+    }
+
+    /**
+     * Iterate over all fields
+     *
+     * @return {Iterator}
+     */
+    * values () {
+      for (const [, value] of this) {
+        yield value
+      }
+    }
+
+    /**
+     * Return a native (perhaps degraded) FormData with only a `append` method
+     * Can throw if it's not supported
+     *
+     * @return {FormData}
+     */
+    ['_asNative'] () {
+      const fd = new _FormData()
+
+      for (const [name, value] of this) {
+        fd.append(name, value)
+      }
+
+      return fd
+    }
+
+    /**
+     * [_blob description]
+     *
+     * @return {Blob} [description]
+     */
+    ['_blob'] () {
+        const boundary = '----formdata-polyfill-' + Math.random(),
+          chunks = [],
+          p = `--${boundary}\r\nContent-Disposition: form-data; name="`
+        this.forEach((value, name) => typeof value == 'string'
+          ? chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
+          : chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type||"application/octet-stream"}\r\n\r\n`, value, `\r\n`))
+        chunks.push(`--${boundary}--`)
+        return new Blob(chunks, {
+          type: "multipart/form-data; boundary=" + boundary
+        })
+    }
+
+    /**
+     * The class itself is iterable
+     * alias for formdata.entries()
+     *
+     * @return {Iterator}
+     */
+    [Symbol.iterator] () {
+      return this.entries()
+    }
+
+    /**
+     * Create the default string description.
+     *
+     * @return  {string} [object FormData]
+     */
+    toString () {
+      return '[object FormData]'
+    }
+  }
+
+  if (_match && !_match.matches) {
+    _match.matches =
+      _match.matchesSelector ||
+      _match.mozMatchesSelector ||
+      _match.msMatchesSelector ||
+      _match.oMatchesSelector ||
+      _match.webkitMatchesSelector ||
+      function (s) {
+        var matches = (this.document || this.ownerDocument).querySelectorAll(s)
+        var i = matches.length
+        while (--i >= 0 && matches.item(i) !== this) {}
+        return i > -1
+      }
+  }
+
+  if (stringTag) {
+    /**
+     * Create the default string description.
+     * It is accessed internally by the Object.prototype.toString().
+     */
+    FormDataPolyfill.prototype[stringTag] = 'FormData'
+  }
+
+  // Patch xhr's send method to call _blob transparently
+  if (_send) {
+    const setRequestHeader = global.XMLHttpRequest.prototype.setRequestHeader
+
+    global.XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
+      setRequestHeader.call(this, name, value)
+      if (name.toLowerCase() === 'content-type') this._hasContentType = true
+    }
+
+    global.XMLHttpRequest.prototype.send = function (data) {
+      // need to patch send b/c old IE don't send blob's type (#44)
+      if (data instanceof FormDataPolyfill) {
+        const blob = data['_blob']()
+        if (!this._hasContentType) this.setRequestHeader('Content-Type', blob.type)
+        _send.call(this, blob)
+      } else {
+        _send.call(this, data)
+      }
+    }
+  }
+
+  // Patch fetch's function to call _blob transparently
+  if (_fetch) {
+    global.fetch = function (input, init) {
+      if (init && init.body && init.body instanceof FormDataPolyfill) {
+        init.body = init.body['_blob']()
+      }
+
+      return _fetch.call(this, input, init)
+    }
+  }
+
+  // Patch navigator.sendBeacon to use native FormData
+  if (_sendBeacon) {
+    global.navigator.sendBeacon = function (url, data) {
+      if (data instanceof FormDataPolyfill) {
+        data = data['_asNative']()
+      }
+      return _sendBeacon.call(this, url, data)
+    }
+  }
+
+  global['FormData'] = FormDataPolyfill
+}

unified-ai-platform/node_modules/formdata-polyfill/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Jimmy Karl Roland Wärting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unified-ai-platform/node_modules/formdata-polyfill/esm.min.js

@@ -0,0 +1,40 @@
+/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+import C from 'fetch-blob'
+import F from 'fetch-blob/file.js'
+
+var {toStringTag:t,iterator:i,hasInstance:h}=Symbol,
+r=Math.random,
+m='append,set,get,getAll,delete,keys,values,entries,forEach,constructor'.split(','),
+f=(a,b,c)=>(a+='',/^(Blob|File)$/.test(b && b[t])?[(c=c!==void 0?c+'':b[t]=='File'?b.name:'blob',a),b.name!==c||b[t]=='blob'?new F([b],c,b):b]:[a,b+'']),
+e=(c,f)=>(f?c:c.replace(/\r?\n|\r/g,'\r\n')).replace(/\n/g,'%0A').replace(/\r/g,'%0D').replace(/"/g,'%22'),
+x=(n, a, e)=>{if(a.length<e){throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`)}}
+
+export const File = F
+
+/** @type {typeof globalThis.FormData} */
+export const FormData = class FormData {
+#d=[];
+constructor(...a){if(a.length)throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`)}
+get [t]() {return 'FormData'}
+[i](){return this.entries()}
+static [h](o) {return o&&typeof o==='object'&&o[t]==='FormData'&&!m.some(m=>typeof o[m]!='function')}
+append(...a){x('append',arguments,2);this.#d.push(f(...a))}
+delete(a){x('delete',arguments,1);a+='';this.#d=this.#d.filter(([b])=>b!==a)}
+get(a){x('get',arguments,1);a+='';for(var b=this.#d,l=b.length,c=0;c<l;c++)if(b[c][0]===a)return b[c][1];return null}
+getAll(a,b){x('getAll',arguments,1);b=[];a+='';this.#d.forEach(c=>c[0]===a&&b.push(c[1]));return b}
+has(a){x('has',arguments,1);a+='';return this.#d.some(b=>b[0]===a)}
+forEach(a,b){x('forEach',arguments,1);for(var [c,d]of this)a.call(b,d,c,this)}
+set(...a){x('set',arguments,2);var b=[],c=!0;a=f(...a);this.#d.forEach(d=>{d[0]===a[0]?c&&(c=!b.push(a)):b.push(d)});c&&b.push(a);this.#d=b}
+*entries(){yield*this.#d}
+*keys(){for(var[a]of this)yield a}
+*values(){for(var[,a]of this)yield a}}
+
+/** @param {FormData} F */
+export function formDataToBlob (F,B=C){
+var b=`${r()}${r()}`.replace(/\./g, '').slice(-28).padStart(32, '-'),c=[],p=`--${b}\r\nContent-Disposition: form-data; name="`
+F.forEach((v,n)=>typeof v=='string'
+?c.push(p+e(n)+`"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`)
+:c.push(p+e(n)+`"; filename="${e(v.name, 1)}"\r\nContent-Type: ${v.type||"application/octet-stream"}\r\n\r\n`, v, '\r\n'))
+c.push(`--${b}--`)
+return new B(c,{type:"multipart/form-data; boundary="+b})}

unified-ai-platform/node_modules/formdata-polyfill/formdata-to-blob.js

@@ -0,0 +1,39 @@
+/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+const escape = (str, filename) =>
+  (filename ? str : str.replace(/\r?\n|\r/g, '\r\n'))
+  .replace(/\n/g, '%0A')
+  .replace(/\r/g, '%0D')
+  .replace(/"/g, '%22')
+
+/**
+ * pure function to convert any formData instance to a Blob
+ * instances synchronous without reading all of the files
+ *
+ * @param {FormData|*} formData an instance of a formData Class
+ * @param {Blob|*} [BlobClass=Blob] the Blob class to use when constructing it
+ */
+export function formDataToBlob (formData, BlobClass = Blob) {
+  const boundary = ('----formdata-polyfill-' + Math.random())
+  const chunks = []
+  const prefix = `--${boundary}\r\nContent-Disposition: form-data; name="`
+
+  for (let [name, value] of formData) {
+    if (typeof value === 'string') {
+      chunks.push(prefix + escape(name) + `"\r\n\r\n${value.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`)
+    } else {
+      chunks.push(
+        prefix + escape(name) + `"; filename="${escape(value.name, 1)}"\r\n` +
+        `Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`,
+        value,
+        '\r\n'
+      )
+    }
+  }
+
+  chunks.push(`--${boundary}--`)
+
+  return new BlobClass(chunks, {
+    type: 'multipart/form-data; boundary=' + boundary
+  })
+}