tough-cookie 4.1.2 → 5.0.0-rc.0

package/README.md

@@ -9,31 +9,31 @@
 ## Synopsis
 
 ```javascript
-var tough = require("tough-cookie");
-var Cookie = tough.Cookie;
-var cookie = Cookie.parse(header);
-cookie.value = "somethingdifferent";
-header = cookie.toString();
-var cookiejar = new tough.CookieJar();
+var tough = require('tough-cookie')
+var Cookie = tough.Cookie
+var cookie = Cookie.parse(header)
+cookie.value = 'somethingdifferent'
+header = cookie.toString()
+var cookiejar = new tough.CookieJar()
 
 // Asynchronous!
 var cookie = await cookiejar.setCookie(
   cookie,
-  "https://currentdomain.example.com/path"
-);
-var cookies = await cookiejar.getCookies("https://example.com/otherpath");
+  'https://currentdomain.example.com/path',
+)
+var cookies = await cookiejar.getCookies('https://example.com/otherpath')
 
 // Or with callbacks!
 cookiejar.setCookie(
   cookie,
-  "https://currentdomain.example.com/path",
+  'https://currentdomain.example.com/path',
   function (err, cookie) {
     /* ... */
-  }
-);
-cookiejar.getCookies("http://example.com/otherpath", function (err, cookies) {
+  },
+)
+cookiejar.getCookies('http://example.com/otherpath', function (err, cookies) {
   /* ... */
-});
+})
 ```
 
 Why the name? NPM modules `cookie`, `cookies` and `cookiejar` were already taken.
@@ -113,8 +113,8 @@ For use with `.sort()`, sorts a list of cookies into the recommended order given
 ```javascript
 var cookies = [
   /* unsorted array of Cookie objects */
-];
-cookies = cookies.sort(cookieCompare);
+]
+cookies = cookies.sort(cookieCompare)
 ```
 
 > **Note**: Since the JavaScript `Date` is limited to a 1-ms precision, cookies within the same millisecond are entirely possible. This is especially true when using the `now` option to `.setCookie()`. The `.creationIndex` property is a per-process global counter, assigned during construction with `new Cookie()`, which preserves the spirit of the RFC sorting: older cookies go first. This works great for `MemoryCookieStore` since `Set-Cookie` headers are parsed in order, but is not so great for distributed systems. Sophisticated `Store`s may wish to set this to some other _logical clock_ so that if cookies A and B are created in the same millisecond, but cookie A is created before cookie B, then `A.creationIndex < B.creationIndex`. If you want to alter the global counter, which you probably _shouldn't_ do, it's stored in `Cookie.cookiesCreated`.
@@ -144,9 +144,9 @@ If options is not an object it is ignored, which means it can be used with [`Arr
 To process the Set-Cookie header(s) on a node HTTP/HTTPS response:
 
 ```javascript
-if (Array.isArray(res.headers["set-cookie"]))
-  cookies = res.headers["set-cookie"].map(Cookie.parse);
-else cookies = [Cookie.parse(res.headers["set-cookie"])];
+if (Array.isArray(res.headers['set-cookie']))
+  cookies = res.headers['set-cookie'].map(Cookie.parse)
+else cookies = [Cookie.parse(res.headers['set-cookie'])]
 ```
 
 _Note:_ In version 2.3.3, tough-cookie limited the number of spaces before the `=` to 256 characters. This limitation was removed in version 2.3.4.
@@ -406,7 +406,7 @@ Retrieve a cookie with the given domain, path, and key (name). The RFC maintains
 
 Callback takes an error and the resulting `Cookie` object. If no cookie is found then `null` MUST be passed instead (that is, not an error).
 
-#### `store.findCookies(domain, path, callback(err, cookies))`
+#### `store.findCookies(domain, path, allowSpecialUseDomain, callback(err, cookies))`
 
 Locates cookies matching the given domain and path. This is most often called in the context of [`cookiejar.getCookies()`](#getcookiescurrenturl-options-callbackerr-cookies).
 

package/dist/memstore.js

@@ -0,0 +1,313 @@
+/*!
+ * Copyright (c) 2015, Salesforce.com, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of Salesforce.com nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectFallback = exports.MemoryCookieStore = void 0;
+const pathMatch_1 = require("./pathMatch");
+const permuteDomain_1 = require("./permuteDomain");
+const store_1 = require("./store");
+const utilHelper_1 = require("./utilHelper");
+const utils_1 = require("./utils");
+class MemoryCookieStore extends store_1.Store {
+    constructor() {
+        super();
+        this.synchronous = true;
+        this.idx = Object.create(null);
+        const customInspectSymbol = (0, utilHelper_1.getCustomInspectSymbol)();
+        if (customInspectSymbol) {
+            Object.defineProperty(this, customInspectSymbol, {
+                value: this.inspect.bind(this),
+                enumerable: false,
+                writable: false,
+                configurable: false,
+            });
+        }
+    }
+    inspect() {
+        const util = { inspect: (0, utilHelper_1.getUtilInspect)(inspectFallback) };
+        return `{ idx: ${util.inspect(this.idx, false, 2)} }`;
+    }
+    findCookie(domain, path, key, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        if (domain == null || path == null) {
+            return promiseCallback.resolve(undefined);
+        }
+        const domainEntry = this.idx[domain];
+        if (!domainEntry) {
+            return promiseCallback.resolve(undefined);
+        }
+        const pathEntry = domainEntry[path];
+        if (!pathEntry) {
+            return promiseCallback.resolve(undefined);
+        }
+        if (key == null) {
+            return promiseCallback.resolve(null);
+        }
+        cb(null, pathEntry[key] || null);
+        return promiseCallback.promise;
+    }
+    findCookies(domain, path, allowSpecialUseDomain = false, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        if (typeof allowSpecialUseDomain === 'function') {
+            allowSpecialUseDomain = true;
+        }
+        const results = [];
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        if (!domain) {
+            return promiseCallback.resolve([]);
+        }
+        let pathMatcher;
+        if (!path) {
+            // null means "all paths"
+            pathMatcher = function matchAll(domainIndex) {
+                for (const curPath in domainIndex) {
+                    const pathIndex = domainIndex[curPath];
+                    for (const key in pathIndex) {
+                        const value = pathIndex[key];
+                        if (value) {
+                            results.push(value);
+                        }
+                    }
+                }
+            };
+        }
+        else {
+            pathMatcher = function matchRFC(domainIndex) {
+                //NOTE: we should use path-match algorithm from S5.1.4 here
+                //(see : https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/canonical_cookie.cc#L299)
+                for (const cookiePath in domainIndex) {
+                    if ((0, pathMatch_1.pathMatch)(path, cookiePath)) {
+                        const pathIndex = domainIndex[cookiePath];
+                        for (const key in pathIndex) {
+                            const value = pathIndex[key];
+                            if (value) {
+                                results.push(value);
+                            }
+                        }
+                    }
+                }
+            };
+        }
+        const domains = (0, permuteDomain_1.permuteDomain)(domain, allowSpecialUseDomain) || [domain];
+        const idx = this.idx;
+        domains.forEach((curDomain) => {
+            const domainIndex = idx[curDomain];
+            if (!domainIndex) {
+                return;
+            }
+            pathMatcher(domainIndex);
+        });
+        cb(null, results);
+        return promiseCallback.promise;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    putCookie(cookie, _callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        const { domain, path, key } = cookie;
+        if (domain == null || path == null || key == null) {
+            cb(null, undefined);
+            return promiseCallback.promise;
+        }
+        const domainEntry = this.idx[domain] ??
+            Object.create(null);
+        this.idx[domain] = domainEntry;
+        const pathEntry = domainEntry[path] ??
+            Object.create(null);
+        domainEntry[path] = pathEntry;
+        pathEntry[key] = cookie;
+        cb(null, undefined);
+        return promiseCallback.promise;
+    }
+    updateCookie(_oldCookie, newCookie, callback) {
+        // this seems wrong but it stops typescript from complaining and all the test pass...
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        callback = callback ?? function () { };
+        // updateCookie() may avoid updating cookies that are identical.  For example,
+        // lastAccessed may not be important to some stores and an equality
+        // comparison could exclude that field.
+        return this.putCookie(newCookie, callback);
+    }
+    removeCookie(domain, path, key, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        const domainEntry = this.idx[domain];
+        if (domainEntry) {
+            const pathEntry = domainEntry[path];
+            if (pathEntry) {
+                const keyEntry = pathEntry[key];
+                if (keyEntry) {
+                    delete pathEntry[key];
+                }
+            }
+        }
+        cb(null, undefined);
+        return promiseCallback.promise;
+    }
+    removeCookies(domain, path, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        const domainEntry = this.idx[domain];
+        if (domainEntry) {
+            if (path) {
+                delete domainEntry[path];
+            }
+            else {
+                delete this.idx[domain];
+            }
+        }
+        cb(null);
+        return promiseCallback.promise;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    removeAllCookies(_callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        this.idx = Object.create(null);
+        cb(null);
+        return promiseCallback.promise;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getAllCookies(_callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(arguments);
+        const cb = promiseCallback.callback;
+        const cookies = [];
+        const idx = this.idx;
+        const domains = Object.keys(idx);
+        domains.forEach((domain) => {
+            const domainEntry = idx[domain] ?? {};
+            const paths = Object.keys(domainEntry);
+            paths.forEach((path) => {
+                const pathEntry = domainEntry[path] ?? {};
+                const keys = Object.keys(pathEntry);
+                keys.forEach((key) => {
+                    const keyEntry = pathEntry[key];
+                    if (keyEntry != null) {
+                        cookies.push(keyEntry);
+                    }
+                });
+            });
+        });
+        // Sort by creationIndex so deserializing retains the creation order.
+        // When implementing your own store, this SHOULD retain the order too
+        cookies.sort((a, b) => {
+            return (a.creationIndex || 0) - (b.creationIndex || 0);
+        });
+        cb(null, cookies);
+        return promiseCallback.promise;
+    }
+}
+exports.MemoryCookieStore = MemoryCookieStore;
+function inspectFallback(val) {
+    if (typeof val === 'string') {
+        return `'${val}'`;
+    }
+    if (val && typeof val === 'object') {
+        const domains = Object.keys(val);
+        if (domains.length === 0) {
+            return '[Object: null prototype] {}';
+        }
+        let result = '[Object: null prototype] {\n';
+        Object.keys(val).forEach((domain, i) => {
+            if ((0, utils_1.inOperator)(domain, val)) {
+                result += formatDomain(domain, val[domain]);
+                if (i < domains.length - 1) {
+                    result += ',';
+                }
+                result += '\n';
+            }
+        });
+        result += '}';
+        return result;
+    }
+    return String(val);
+}
+exports.inspectFallback = inspectFallback;
+function formatDomain(domainName, domainValue) {
+    if (typeof domainValue === 'string') {
+        return `'${domainValue}'`;
+    }
+    if (domainValue && typeof domainValue === 'object') {
+        const indent = '  ';
+        let result = `${indent}'${domainName}': [Object: null prototype] {\n`;
+        Object.keys(domainValue).forEach((path, i, paths) => {
+            if ((0, utils_1.inOperator)(path, domainValue)) {
+                result += formatPath(path, domainValue[path]);
+                if (i < paths.length - 1) {
+                    result += ',';
+                }
+                result += '\n';
+            }
+        });
+        result += `${indent}}`;
+        return result;
+    }
+    return String(domainValue);
+}
+function formatPath(pathName, pathValue) {
+    if (typeof pathValue === 'string') {
+        return `'${pathValue}'`;
+    }
+    if (pathValue && typeof pathValue === 'object') {
+        const indent = '    ';
+        let result = `${indent}'${pathName}': [Object: null prototype] {\n`;
+        Object.keys(pathValue).forEach((cookieName, i, cookieNames) => {
+            if ((0, utils_1.inOperator)(cookieName, pathValue)) {
+                const cookie = pathValue[cookieName];
+                if (cookie != null &&
+                    typeof cookie === 'object' &&
+                    (0, utils_1.inOperator)('inspect', cookie) &&
+                    typeof cookie.inspect === 'function') {
+                    const inspectedValue = cookie.inspect();
+                    if (typeof inspectedValue === 'string') {
+                        result += `      ${cookieName}: ${inspectedValue}`;
+                        if (i < cookieNames.length - 1) {
+                            result += ',';
+                        }
+                        result += '\n';
+                    }
+                }
+            }
+        });
+        result += `${indent}}`;
+        return result;
+    }
+    return String(pathValue);
+}

package/{lib → dist}/pathMatch.js

@@ -1,3 +1,4 @@
+"use strict";
 /*!
  * Copyright (c) 2015, Salesforce.com, Inc.
  * All rights reserved.
@@ -28,34 +29,32 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathMatch = void 0;
 /*
  * "A request-path path-matches a given cookie-path if at least one of the
  * following conditions holds:"
  */
 function pathMatch(reqPath, cookiePath) {
-  // "o  The cookie-path and the request-path are identical."
-  if (cookiePath === reqPath) {
-    return true;
-  }
-
-  const idx = reqPath.indexOf(cookiePath);
-  if (idx === 0) {
-    // "o  The cookie-path is a prefix of the request-path, and the last
-    // character of the cookie-path is %x2F ("/")."
-    if (cookiePath.substr(-1) === "/") {
-      return true;
+    // "o  The cookie-path and the request-path are identical."
+    if (cookiePath === reqPath) {
+        return true;
     }
-
-    // " o  The cookie-path is a prefix of the request-path, and the first
-    // character of the request-path that is not included in the cookie- path
-    // is a %x2F ("/") character."
-    if (reqPath.substr(cookiePath.length, 1) === "/") {
-      return true;
+    const idx = reqPath.indexOf(cookiePath);
+    if (idx === 0) {
+        // "o  The cookie-path is a prefix of the request-path, and the last
+        // character of the cookie-path is %x2F ("/")."
+        if (cookiePath[cookiePath.length - 1] === '/') {
+            return true;
+        }
+        // " o  The cookie-path is a prefix of the request-path, and the first
+        // character of the request-path that is not included in the cookie- path
+        // is a %x2F ("/") character."
+        if (new RegExp(`^${cookiePath}`).test(reqPath) &&
+            reqPath[cookiePath.length] === '/') {
+            return true;
+        }
     }
-  }
-
-  return false;
+    return false;
 }
-
 exports.pathMatch = pathMatch;

package/{lib → dist}/permuteDomain.js

@@ -28,38 +28,36 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-"use strict";
-const pubsuffix = require("./pubsuffix-psl");
-
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permuteDomain = void 0;
+const pubsuffix_psl_1 = require("./pubsuffix-psl");
 // Gives the permutation of all possible domainMatch()es of a given domain. The
 // array is in shortest-to-longest order.  Handy for indexing.
-
 function permuteDomain(domain, allowSpecialUseDomain) {
-  const pubSuf = pubsuffix.getPublicSuffix(domain, {
-    allowSpecialUseDomain: allowSpecialUseDomain
-  });
-
-  if (!pubSuf) {
-    return null;
-  }
-  if (pubSuf == domain) {
-    return [domain];
-  }
-
-  // Nuke trailing dot
-  if (domain.slice(-1) == ".") {
-    domain = domain.slice(0, -1);
-  }
-
-  const prefix = domain.slice(0, -(pubSuf.length + 1)); // ".example.com"
-  const parts = prefix.split(".").reverse();
-  let cur = pubSuf;
-  const permutations = [cur];
-  while (parts.length) {
-    cur = `${parts.shift()}.${cur}`;
-    permutations.push(cur);
-  }
-  return permutations;
+    const pubSuf = (0, pubsuffix_psl_1.getPublicSuffix)(domain, {
+        allowSpecialUseDomain: allowSpecialUseDomain,
+    });
+    if (!pubSuf) {
+        return null;
+    }
+    if (pubSuf == domain) {
+        return [domain];
+    }
+    // Nuke trailing dot
+    if (domain.slice(-1) == '.') {
+        domain = domain.slice(0, -1);
+    }
+    const prefix = domain.slice(0, -(pubSuf.length + 1)); // ".example.com"
+    const parts = prefix.split('.').reverse();
+    let cur = pubSuf;
+    const permutations = [cur];
+    while (parts.length) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const part = parts.shift();
+        cur = `${part}.${cur}`;
+        permutations.push(cur);
+    }
+    return permutations;
 }
-
 exports.permuteDomain = permuteDomain;

package/dist/pubsuffix-psl.js

@@ -0,0 +1,94 @@
+/*!
+ * Copyright (c) 2018, Salesforce.com, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of Salesforce.com nor the names of its contributors may
+ * be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicSuffix = void 0;
+const psl = __importStar(require("psl"));
+// RFC 6761
+const SPECIAL_USE_DOMAINS = ['local', 'example', 'invalid', 'localhost', 'test'];
+const SPECIAL_TREATMENT_DOMAINS = ['localhost', 'invalid'];
+const defaultGetPublicSuffixOptions = {
+    allowSpecialUseDomain: false,
+    ignoreError: false,
+};
+function getPublicSuffix(domain, options = {}) {
+    options = { ...defaultGetPublicSuffixOptions, ...options };
+    const domainParts = domain.split('.');
+    const topLevelDomain = domainParts[domainParts.length - 1];
+    const allowSpecialUseDomain = !!options.allowSpecialUseDomain;
+    const ignoreError = !!options.ignoreError;
+    if (allowSpecialUseDomain &&
+        topLevelDomain !== undefined &&
+        SPECIAL_USE_DOMAINS.includes(topLevelDomain)) {
+        if (domainParts.length > 1) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const secondLevelDomain = domainParts[domainParts.length - 2];
+            // In aforementioned example, the eTLD/pubSuf will be apple.localhost
+            return `${secondLevelDomain}.${topLevelDomain}`;
+        }
+        else if (SPECIAL_TREATMENT_DOMAINS.includes(topLevelDomain)) {
+            // For a single word special use domain, e.g. 'localhost' or 'invalid', per RFC 6761,
+            // "Application software MAY recognize {localhost/invalid} names as special, or
+            // MAY pass them to name resolution APIs as they would for other domain names."
+            return `${topLevelDomain}`;
+        }
+    }
+    if (!ignoreError &&
+        topLevelDomain !== undefined &&
+        SPECIAL_USE_DOMAINS.includes(topLevelDomain)) {
+        throw new Error(`Cookie has domain set to the public suffix "${topLevelDomain}" which is a special use domain. To allow this, configure your CookieJar with {allowSpecialUseDomain:true, rejectPublicSuffixes: false}.`);
+    }
+    return psl.get(domain);
+}
+exports.getPublicSuffix = getPublicSuffix;