catto.js 0.0.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/AuthClient.js

@@ -0,0 +1,141 @@
+var request = require("./request");
+var User = require("./User");
+module.exports = class {
+  constructor(options) {
+    this.options = Object.assign({
+      "server": null,
+      "scopes": [],
+      "id": "",
+      "secret": "",
+      "tokenType": "",
+      "accessToken": "",
+      "expires": new Date(0),
+      "refreshToken": "",
+      "apiv": 10,
+      "redirectPath": ""
+    }, options || {});
+    this.user = null;
+  }
+  get available() {
+    return (this.options.server
+       && this.options.scopes.length > 0
+       && this.options.id
+       && this.options.secret
+       && this.options.tokenType
+       && this.options.accessToken
+       && this.options.expires
+       && this.options.refreshToken
+       && this.options.apiv
+       && this.options.redirectPath
+    );
+  }
+  get redirectUri() {
+    return `http${((this.options.server.options.ssl || this.options.server.options.sslProxy) ? "s" : "")}://${this.options.server.options.domain}${this.options.redirectPath}`;
+  }
+  get link() {
+    return `https://discord.com/oauth2/authorize?client_id=${encodeURIComponent(this.options.id)}&scope=${encodeURIComponent(this.options.scopes.join(" "))}&redirect_uri=${encodeURIComponent(this.redirectUri)}&response_type=code&prompt=none`;
+  }
+  redirect(res) {
+    res.redirect(this.link);
+  }
+  async auth(req) {
+    try {
+      var result = await request.post({
+        "url": "https://discord.com/api/oauth2/token",
+        "form": {
+          "client_id": this.options.id,
+          "client_secret": this.options.secret,
+          "grant_type": "authorization_code",
+          "code": req.query.code,
+          "redirect_uri": this.redirectUri
+        }
+      });
+    } catch(e) {
+      return !1;
+    }
+    if (result.response.statusCode == 200) {
+      this.writeToken(result.body);
+      return !0;
+    } else {
+      return !1;
+    }
+  }
+  async renew(req) {
+    if (!this.available) {
+      throw new Error(`renew: Not available.`);
+    }
+    try {
+      var result = await request.post({
+        "url": "https://discord.com/api/oauth2/token",
+        "form": {
+          "client_id": this.options.id,
+          "client_secret": this.options.secret,
+          "grant_type": "refresh_token",
+          "refreshToken": this.options.refreshToken
+        }
+      });
+    } catch(e) {
+      return !1;
+    }
+    if (result.response.statusCode == 200) {
+      this.writeToken(result.body);
+      return !0;
+    } else {
+      return !1;
+    }
+  }
+  async revoke(req) {
+    if (!this.available) {
+      throw new Error(`revoke: Not available.`);
+    }
+    try {
+      var result = await request.post({
+        "url": "https://discord.com/api/oauth2/token/revoke",
+        "form": {
+          "client_id": this.options.id,
+          "client_secret": this.options.secret,
+          "token": this.options.accessToken
+        }
+      });
+    } catch(e) {
+      return !1;
+    }
+    if (result.response.statusCode == 200) {
+      this.options.accessToken = "";
+      this.options.refreshToken = "";
+      return !0;
+    } else {
+      return !1;
+    }
+  }
+  async sync() {
+    if (!this.available) {
+      throw new Error(`sync: Not available.`);
+    }
+    try {
+      var result = await request.get({
+        "url": `https://discord.com/api/v${this.options.apiv}/users/@me`,
+        "headers": {
+          "Authorization": `${this.options.tokenType} ${this.options.accessToken}`
+        }
+      });
+    } catch(e) {
+      return !1;
+    }
+    if (result.response.statusCode == 200) {
+      this.user = new User(result.body);
+      return !0;
+    } else {
+      return !1;
+    }
+  }
+  writeToken(body) {
+    this.options.tokenType = body.token_type;
+    this.options.accessToken = body.access_token;
+    this.options.expires = new Date(Date.now() +(body.expires_in *1e3));
+    this.options.refreshToken = body.refresh_token;
+  }
+  get expired() {
+    return (Date.now() >= this.options.expires.getTime());
+  }
+};

package/Base64.js

@@ -0,0 +1,8 @@
+module.exports = {
+  "encode": text => {
+    return Buffer.from(text, "utf-8").toString("base64")
+  },
+  "decode": text => {
+    return Buffer.from(text, "base64").toString("utf-8")
+  }
+};

package/GitHub.js

@@ -0,0 +1,43 @@
+var request = require("./request");
+var Base64 = require("./Base64");
+module.exports = class {
+  constructor(options) {
+    this.options = Object.assign({
+      "token": "",
+      "username": "",
+      "repository": "",
+      "message": "cattojs"
+    }, options || {});
+  }
+  async read(file) {
+    var value = Base64.decode((await request.get({
+      "url": `https://api.github.com/repos/${this.options.username}/${this.options.repository}/contents/${file}`,
+      "headers": {
+        "User-Agent": this.options.username,
+        "Authorization": `token ${this.options.token}`
+      }
+    })).body.content);
+    try {
+      value = JSON.parse(value);
+    } catch(e) {}
+    return value;
+  }
+  async write(file, value) {
+    if (typeof value === "object") {
+      value = JSON.stringify(value);
+    }
+    await request.put({
+      "url": `https://api.github.com/repos/${this.options.username}/${this.options.repository}/contents/${file}`,
+      "headers": {
+        "User-Agent": this.options.username,
+        "Authorization": `token ${this.options.token}`
+      },
+      "json": !0,
+      "body": {
+        "content": Base64.encode(value),
+        "message": this.options.message
+      }
+    });
+    return !0;
+  }
+};

package/HTML.js

@@ -0,0 +1,5 @@
+module.exports = {
+  "disable": text => {
+    return text.split("<").join("&lt;").split(">").join("&gt;");
+  }
+};

package/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/Server.js

@@ -0,0 +1,151 @@
+/** @module Server */
+
+var events = require("events");
+var express = require("express");
+var expressWs = require("express-ws");
+var http = require("http");
+var https = require("https");
+var bodyParser = require("body-parser");
+var urlencodedParser = bodyParser.urlencoded({"extended":!0});
+var jsonParser = bodyParser.json();
+var fs = require("fs");
+var path = require("path");
+var session = require("express-session");
+var FileStore = require("session-file-store")(session);
+if (typeof EventEmitter !== "undefined") {} else {
+  var { EventEmitter } = events;
+}
+
+/**
+ * Server.
+ * @class
+ * @param {object} options
+ */
+class Server extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = Object.assign({
+      "domain": null,
+      "port": (process.env.PORT || 80),
+      "ssl": !1,
+      "sslProxy": !1,
+      "cert": null,
+      "key": null,
+      "serverOptions": {},
+      "expressWsiOptions": {},
+      "secret": null,
+      "storeOptions": {},
+      "ejs": !1
+    }, options || {});
+    this.app = express();
+    if (this.ssl) {
+      this.server = https.createServer(Object.assign(this.options.serverOptions, {
+        "cert": fs.readFileSync(path.join(__dirname, "..", "..", this.options.cert), "utf8"),
+        "key": fs.readFileSync(path.join(__dirname, "..", "..", this.options.key), "utf8")
+      }), this.app);
+    } else {
+      this.server = http.createServer(this.options.serverOptions, this.app);
+    }
+    this.expressWsi = expressWs(this.app, this.server, this.options.expressWsiOptions);
+    this.app.set("trust proxy", !0);
+    this.app.use(urlencodedParser);
+    this.app.use(jsonParser);
+    if (this.options.ejs) {
+      this.app.set("view engine", "ejs");
+    }
+    if (this.options.secret) {
+      this.app.use(session({
+        "store": new FileStore(this.options.storeOptions),
+        "secret": this.options.secret,
+        "cookie": {
+          "secure": (this.options.ssl || this.options.sslProxy)
+        }
+      }));
+    }
+  }
+  run() {
+    this.server.listen(this.options.port, () => {
+      this.emit("running");
+    });
+    return this;
+  }
+  all(...args) {
+    this.app.all(...args);
+    return this;
+  }
+  delete(...args) {
+    this.app.delete(...args);
+    return this;
+  }
+  disable(...args) {
+    this.app.disable(...args);
+    return this;
+  }
+  disabled(...args) {
+    this.app.disabled(...args);
+    return this;
+  }
+  enable(...args) {
+    this.app.enable(...args);
+    return this;
+  }
+  enabled(...args) {
+    this.app.enabled(...args);
+    return this;
+  }
+  engine(...args) {
+    this.app.engine(...args);
+    return this;
+  }
+  get(...args) {
+    this.app.get(...args);
+    return this;
+  }
+  param(...args) {
+    this.app.param(...args);
+    return this;
+  }
+  path(...args) {
+    this.app.path(...args);
+    return this;
+  }
+  post(...args) {
+    this.app.post(...args);
+    return this;
+  }
+  put(...args) {
+    this.app.put(...args);
+    return this;
+  }
+  render(...args) {
+    this.app.render(...args);
+    return this;
+  }
+  route(...args) {
+    this.app.route(...args);
+    return this;
+  }
+  set(...args) {
+    this.app.set(...args);
+    return this;
+  }
+  use(...args) {
+    this.app.use(...args);
+    return this;
+  }
+  ws(...args) {
+    this.app.ws(...args);
+    return this;
+  }
+  static(folder) {
+    this.app.use(express.static(path.join(__dirname,"..","..",folder)));
+    return this;
+  }
+  static fa(text) {
+    return (req,res) => {
+      res.end(text);
+    };
+  }
+}
+
+module.exports = Server;

package/User.js

@@ -0,0 +1,141 @@
+module.exports = class {
+  constructor(options) {
+    this.options = Object.assign({
+      "id": "",
+      "username": "",
+      "avatar": "",
+      "discriminator": "",
+      "public_flags": 0,
+      "flags": 0,
+      "banner": "",
+      "banner_color": "",
+      "accent_color": 0,
+      "locale": "",
+      "mfa_enabled": !1,
+      "premium_type": 0,
+      "email": "",
+      "verified": !1,
+      "bot": !1,
+      "system": !1
+    }, options || {});
+  }
+  get id() {
+    return this.options.id;
+  }
+  get name() {
+    return this.options.username;
+  }
+  get avatarHash() {
+    return this.options.avatar;
+  }
+  get avatar() {
+    var avataru = this.avatarHash;
+    if (avataru.startsWith("a_")) {
+      avataru = `https://cdn.discordapp.com/avatars/${avataru}.gif?size=4096`;
+    } else if (avataru) {
+      avataru = `https://cdn.discordapp.com/avatars/${avataru}.webp?size=4096`;
+    } else {
+      avataru = `https://cdn.discordapp.com/embed/avatars/${(parseInt(this.discrim) % 5).toString()}.png`;
+    }
+    return avataru;
+  }
+  get discrim() {
+    return this.options.discriminator;
+  }
+  get tag() {
+    return `${this.name}#${this.discrim}`;
+  }
+  get badges() {
+    var i = 23;
+    var p = this.options.badges;
+    var f = [];
+    while (--i > -1) {
+      if (![21, 20, 15, 13, 12, 11, 5, 4].includes(i) && p >= (1 << i)) {
+        p -= (1 << i);
+        f.push(i);
+      }
+    }
+    var fl = [
+      "STAFF",
+      "PARTNER",
+      "HYPESQUAD",
+      "BUG_HUNTER_LEVEL_1",
+      null,
+      null,
+      "HYPESQUAD_ONLINE_HOUSE_1",
+      "HYPESQUAD_ONLINE_HOUSE_2",
+      "HYPESQUAD_ONLINE_HOUSE_3",
+      "PREMIUM_EARLY_SUPPORTER",
+      "TEAM_PSEUDO_USER",
+      null,
+      null,
+      null,
+      "BUG_HUNTER_LEVEL_2",
+      null,
+      "VERIFIED_BOT",
+      "VERIFIED_DEVELOPER",
+      "CERTIFIED_MODERATOR",
+      "BOT_HTTP_INTERACTIONS",
+      null,
+      null,
+      "ACTIVE_DEVELOPER"
+    ];
+    return f.map(n => fl[n]);
+  }
+  get bannerHash() {
+    return this.options.banner;
+  }
+  get bannerColor() {
+    return this.options.banner_color;
+  }
+  get banner() {
+    var banneru = this.bannerHash;
+    if (banneru.startsWith("a_")) {
+      banneru = `https://cdn.discordapp.com/avatars/${banneru}.gif?size=4096`;
+    } else if (banneru) {
+      banneru = `https://cdn.discordapp.com/avatars/${banneru}.webp?size=4096`;
+    } else {
+      banneru = this.bannerColor || this.accentColor;
+    }
+    return banneru;
+  }
+  get accentColor() {
+    return this.options.accent_color;
+  }
+  get lang() {
+    return this.options.locale;
+  }
+  get isRussian() {
+    return (this.lang == "ru");
+  }
+  get is2FAEnabled() {
+    return this.options.mfa_enabled;
+  }
+  get hasNitro() {
+    return (this.isBot || this.options.premium_type > 0);
+  }
+  get hasNitroClassic() {
+    return (this.options.premium_type == 1);
+  }
+  get hasNitroBoost() {
+    return (this.isBot || this.options.premium_type == 2);
+  }
+  get hasNitroBasic() {
+    return (this.options.premium_type == 3);
+  }
+  get email() {
+    return this.options.email;
+  }
+  get isEmailVerified() {
+    return this.options.verified;
+  }
+  get isBot() {
+    return this.options.bot;
+  }
+  get isBotVerified() {
+    return this.badges.has("VERIFIED_BOT");
+  }
+  get isSystem() {
+    return this.options.system;
+  }
+};

package/index.js

@@ -0,0 +1,5 @@
+var mod = {};
+["random", "Server", "HTML", "request", "AuthClient", "utils", "GitHub", "Base64"].forEach(part => {
+  mod[part] = require(`./${part}`);
+});
+module.exports = mod;

package/index.test.js

@@ -0,0 +1,27 @@
+var cattojs = require("./index");
+test("random float", () => {
+  expect(typeof cattojs.random.float(1, 3)).toBe("number");
+});
+test("random int", () => {
+  expect(typeof cattojs.random.int(1, 3)).toBe("number");
+});
+test("random range", () => {
+  expect(typeof cattojs.random.range(1, 3)).toBe("number");
+});
+test("random bool", () => {
+  expect(typeof cattojs.random.bool()).toBe("boolean");
+});
+test("html disable", () => {
+  expect(cattojs.HTML.disable("<>")).toBe("&lt;&gt;");
+});
+test("array remove", () => {
+  var arr = ["a", "b", "c"];
+  expect(arr.remove(1)).toBe("b");
+  expect(arr).toMatchObject(["a", "c"]);
+});
+test("base64 encode", () => {
+  expect(cattojs.Base64.encode("Test.")).toBe("VGVzdC4=");
+});
+test("base64 decode", () => {
+  expect(cattojs.Base64.decode("VGVzdC4=")).toBe("Test.");
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "catto.js",
+  "version": "0.0.1",
+  "description": "Universal module for everything.",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BoryaGames/catto.js.git"
+  },
+  "keywords": [
+    "catto",
+    "cat",
+    "js",
+    "discord",
+    "discord.js",
+    "express",
+    "passport",
+    "authorization",
+    "auth",
+    "discord-auth",
+    "kitten",
+    "cats",
+    "kittens",
+    "cattoes",
+    "easy",
+    "slash",
+    "random"
+  ],
+  "author": "cat1234",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/BoryaGames/catto.js/issues"
+  },
+  "homepage": "https://github.com/BoryaGames/catto.js#readme",
+  "devDependencies": {
+    "jest": "^29.4.1"
+  },
+  "dependencies": {
+    "body-parser": "^1.20.1",
+    "ejs": "^3.1.8",
+    "express": "^4.18.2",
+    "express-session": "^1.17.3",
+    "express-ws": "^5.0.2",
+    "request": "^2.88.2",
+    "session-file-store": "^1.5.0"
+  }
+}

package/random.js

@@ -0,0 +1,15 @@
+function float(min, max) {
+  return (Math.random() *(max -min) +min);
+}
+function int(min, max) {
+  return Math.floor(Math.random() *(max -min) +min);
+}
+function range(min, max) {
+  return Math.floor(Math.random() *(max -min +1) +min);
+}
+function bool() {
+  return !Math.floor(Math.random() *2);
+}
+module.exports = {
+  float, int, range, bool
+};

package/request.js

@@ -0,0 +1,50 @@
+/** @module request */
+
+var request = require("request");
+
+function wrap(method, options) {
+  return new Promise((res, rej) => {
+    request[method](options, (error, response, body) => {
+      if (error) {
+        return rej(error);
+      }
+      try {
+        body = JSON.parse(body);
+      } catch(e) {}
+      res({
+        response, body
+      });
+    });
+  });
+}
+
+/**
+ * GET request.
+ * @param {object} options
+ * @return {promise}
+ */
+function get(options) {
+  return wrap("get", options);
+}
+
+/**
+ * POST request.
+ * @param {object} options
+ * @return {promise}
+ */
+function post(options) {
+  return wrap("post", options);
+}
+
+/**
+ * PUT request.
+ * @param {object} options
+ * @return {promise}
+ */
+function put(options) {
+  return wrap("put", options);
+}
+
+module.exports = {
+  get, post, put
+};

package/utils.js

@@ -0,0 +1,3 @@
+Array.prototype.remove = function(index) {
+  return this.splice(index, 1)[0];
+};