Brunobkr/llama.cpp_AlgMor24_github

1"use strict";2 3const conversions = require("webidl-conversions");4const utils = require("./utils.js");5 6const impl = utils.implSymbol;7 8const IteratorPrototype = Object.create(utils.IteratorPrototype, {9  next: {10    value: function next() {11      const internal = this[utils.iterInternalSymbol];12      const { target, kind, index } = internal;13      const values = Array.from(target[impl]);14      const len = values.length;15      if (index >= len) {16        return { value: undefined, done: true };17      }18 19      const pair = values[index];20      internal.index = index + 1;21      const [key, value] = pair.map(utils.tryWrapperForImpl);22 23      let result;24      switch (kind) {25        case "key":26          result = key;27          break;28        case "value":29          result = value;30          break;31        case "key+value":32          result = [key, value];33          break;34      }35      return { value: result, done: false };36    },37    writable: true,38    enumerable: true,39    configurable: true40  },41  [Symbol.toStringTag]: {42    value: "URLSearchParams Iterator",43    configurable: true44  }45});46class URLSearchParams {47  constructor() {48    const args = [];49    {50      let curArg = arguments[0];51      if (curArg !== undefined) {52        if (utils.isObject(curArg)) {53          if (curArg[Symbol.iterator] !== undefined) {54            if (!utils.isObject(curArg)) {55              throw new TypeError(56                "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + " is not an iterable object."57              );58            } else {59              const V = [];60              const tmp = curArg;61              for (let nextItem of tmp) {62                if (!utils.isObject(nextItem)) {63                  throw new TypeError(64                    "Failed to construct 'URLSearchParams': parameter 1" +65                      " sequence" +66                      "'s element" +67                      " is not an iterable object."68                  );69                } else {70                  const V = [];71                  const tmp = nextItem;72                  for (let nextItem of tmp) {73                    nextItem = conversions["USVString"](nextItem, {74                      context:75                        "Failed to construct 'URLSearchParams': parameter 1" + " sequence" + "'s element" + "'s element"76                    });77 78                    V.push(nextItem);79                  }80                  nextItem = V;81                }82 83                V.push(nextItem);84              }85              curArg = V;86            }87          } else {88            if (!utils.isObject(curArg)) {89              throw new TypeError(90                "Failed to construct 'URLSearchParams': parameter 1" + " record" + " is not an object."91              );92            } else {93              const result = Object.create(null);94              for (const key of Reflect.ownKeys(curArg)) {95                const desc = Object.getOwnPropertyDescriptor(curArg, key);96                if (desc && desc.enumerable) {97                  let typedKey = key;98                  let typedValue = curArg[key];99 100                  typedKey = conversions["USVString"](typedKey, {101                    context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s key"102                  });103 104                  typedValue = conversions["USVString"](typedValue, {105                    context: "Failed to construct 'URLSearchParams': parameter 1" + " record" + "'s value"106                  });107 108                  result[typedKey] = typedValue;109                }110              }111              curArg = result;112            }113          }114        } else {115          curArg = conversions["USVString"](curArg, { context: "Failed to construct 'URLSearchParams': parameter 1" });116        }117      } else {118        curArg = "";119      }120      args.push(curArg);121    }122    return iface.setup(Object.create(new.target.prototype), args);123  }124 125  append(name, value) {126    if (!this || !module.exports.is(this)) {127      throw new TypeError("Illegal invocation");128    }129 130    if (arguments.length < 2) {131      throw new TypeError(132        "Failed to execute 'append' on 'URLSearchParams': 2 arguments required, but only " +133          arguments.length +134          " present."135      );136    }137    const args = [];138    {139      let curArg = arguments[0];140      curArg = conversions["USVString"](curArg, {141        context: "Failed to execute 'append' on 'URLSearchParams': parameter 1"142      });143      args.push(curArg);144    }145    {146      let curArg = arguments[1];147      curArg = conversions["USVString"](curArg, {148        context: "Failed to execute 'append' on 'URLSearchParams': parameter 2"149      });150      args.push(curArg);151    }152    return this[impl].append(...args);153  }154 155  delete(name) {156    if (!this || !module.exports.is(this)) {157      throw new TypeError("Illegal invocation");158    }159 160    if (arguments.length < 1) {161      throw new TypeError(162        "Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only " +163          arguments.length +164          " present."165      );166    }167    const args = [];168    {169      let curArg = arguments[0];170      curArg = conversions["USVString"](curArg, {171        context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1"172      });173      args.push(curArg);174    }175    return this[impl].delete(...args);176  }177 178  get(name) {179    if (!this || !module.exports.is(this)) {180      throw new TypeError("Illegal invocation");181    }182 183    if (arguments.length < 1) {184      throw new TypeError(185        "Failed to execute 'get' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."186      );187    }188    const args = [];189    {190      let curArg = arguments[0];191      curArg = conversions["USVString"](curArg, {192        context: "Failed to execute 'get' on 'URLSearchParams': parameter 1"193      });194      args.push(curArg);195    }196    return this[impl].get(...args);197  }198 199  getAll(name) {200    if (!this || !module.exports.is(this)) {201      throw new TypeError("Illegal invocation");202    }203 204    if (arguments.length < 1) {205      throw new TypeError(206        "Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only " +207          arguments.length +208          " present."209      );210    }211    const args = [];212    {213      let curArg = arguments[0];214      curArg = conversions["USVString"](curArg, {215        context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1"216      });217      args.push(curArg);218    }219    return utils.tryWrapperForImpl(this[impl].getAll(...args));220  }221 222  has(name) {223    if (!this || !module.exports.is(this)) {224      throw new TypeError("Illegal invocation");225    }226 227    if (arguments.length < 1) {228      throw new TypeError(229        "Failed to execute 'has' on 'URLSearchParams': 1 argument required, but only " + arguments.length + " present."230      );231    }232    const args = [];233    {234      let curArg = arguments[0];235      curArg = conversions["USVString"](curArg, {236        context: "Failed to execute 'has' on 'URLSearchParams': parameter 1"237      });238      args.push(curArg);239    }240    return this[impl].has(...args);241  }242 243  set(name, value) {244    if (!this || !module.exports.is(this)) {245      throw new TypeError("Illegal invocation");246    }247 248    if (arguments.length < 2) {249      throw new TypeError(250        "Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only " + arguments.length + " present."251      );252    }253    const args = [];254    {255      let curArg = arguments[0];256      curArg = conversions["USVString"](curArg, {257        context: "Failed to execute 'set' on 'URLSearchParams': parameter 1"258      });259      args.push(curArg);260    }261    {262      let curArg = arguments[1];263      curArg = conversions["USVString"](curArg, {264        context: "Failed to execute 'set' on 'URLSearchParams': parameter 2"265      });266      args.push(curArg);267    }268    return this[impl].set(...args);269  }270 271  sort() {272    if (!this || !module.exports.is(this)) {273      throw new TypeError("Illegal invocation");274    }275 276    return this[impl].sort();277  }278 279  toString() {280    if (!this || !module.exports.is(this)) {281      throw new TypeError("Illegal invocation");282    }283 284    return this[impl].toString();285  }286 287  keys() {288    if (!this || !module.exports.is(this)) {289      throw new TypeError("Illegal invocation");290    }291    return module.exports.createDefaultIterator(this, "key");292  }293 294  values() {295    if (!this || !module.exports.is(this)) {296      throw new TypeError("Illegal invocation");297    }298    return module.exports.createDefaultIterator(this, "value");299  }300 301  entries() {302    if (!this || !module.exports.is(this)) {303      throw new TypeError("Illegal invocation");304    }305    return module.exports.createDefaultIterator(this, "key+value");306  }307 308  forEach(callback) {309    if (!this || !module.exports.is(this)) {310      throw new TypeError("Illegal invocation");311    }312    if (arguments.length < 1) {313      throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " + "but only 0 present.");314    }315    if (typeof callback !== "function") {316      throw new TypeError(317        "Failed to execute 'forEach' on 'iterable': The callback provided " + "as parameter 1 is not a function."318      );319    }320    const thisArg = arguments[1];321    let pairs = Array.from(this[impl]);322    let i = 0;323    while (i < pairs.length) {324      const [key, value] = pairs[i].map(utils.tryWrapperForImpl);325      callback.call(thisArg, value, key, this);326      pairs = Array.from(this[impl]);327      i++;328    }329  }330}331Object.defineProperties(URLSearchParams.prototype, {332  append: { enumerable: true },333  delete: { enumerable: true },334  get: { enumerable: true },335  getAll: { enumerable: true },336  has: { enumerable: true },337  set: { enumerable: true },338  sort: { enumerable: true },339  toString: { enumerable: true },340  keys: { enumerable: true },341  values: { enumerable: true },342  entries: { enumerable: true },343  forEach: { enumerable: true },344  [Symbol.toStringTag]: { value: "URLSearchParams", configurable: true },345  [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true }346});347const iface = {348  // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`349  // method into this array. It allows objects that directly implements *those* interfaces to be recognized as350  // implementing this mixin interface.351  _mixedIntoPredicates: [],352  is(obj) {353    if (obj) {354      if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {355        return true;356      }357      for (const isMixedInto of module.exports._mixedIntoPredicates) {358        if (isMixedInto(obj)) {359          return true;360        }361      }362    }363    return false;364  },365  isImpl(obj) {366    if (obj) {367      if (obj instanceof Impl.implementation) {368        return true;369      }370 371      const wrapper = utils.wrapperForImpl(obj);372      for (const isMixedInto of module.exports._mixedIntoPredicates) {373        if (isMixedInto(wrapper)) {374          return true;375        }376      }377    }378    return false;379  },380  convert(obj, { context = "The provided value" } = {}) {381    if (module.exports.is(obj)) {382      return utils.implForWrapper(obj);383    }384    throw new TypeError(`${context} is not of type 'URLSearchParams'.`);385  },386 387  createDefaultIterator(target, kind) {388    const iterator = Object.create(IteratorPrototype);389    Object.defineProperty(iterator, utils.iterInternalSymbol, {390      value: { target, kind, index: 0 },391      configurable: true392    });393    return iterator;394  },395 396  create(constructorArgs, privateData) {397    let obj = Object.create(URLSearchParams.prototype);398    obj = this.setup(obj, constructorArgs, privateData);399    return obj;400  },401  createImpl(constructorArgs, privateData) {402    let obj = Object.create(URLSearchParams.prototype);403    obj = this.setup(obj, constructorArgs, privateData);404    return utils.implForWrapper(obj);405  },406  _internalSetup(obj) {},407  setup(obj, constructorArgs, privateData) {408    if (!privateData) privateData = {};409 410    privateData.wrapper = obj;411 412    this._internalSetup(obj);413    Object.defineProperty(obj, impl, {414      value: new Impl.implementation(constructorArgs, privateData),415      configurable: true416    });417 418    obj[impl][utils.wrapperSymbol] = obj;419    if (Impl.init) {420      Impl.init(obj[impl], privateData);421    }422    return obj;423  },424  interface: URLSearchParams,425  expose: {426    Window: { URLSearchParams },427    Worker: { URLSearchParams }428  }429}; // iface430module.exports = iface;431 432const Impl = require("./URLSearchParams-impl.js");433