conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/pac-proxy-agent/dist/index.js

@@ -0,0 +1,238 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacProxyAgent = void 0;
+const net = __importStar(require("net"));
+const tls = __importStar(require("tls"));
+const crypto = __importStar(require("crypto"));
+const events_1 = require("events");
+const debug_1 = __importDefault(require("debug"));
+const url_1 = require("url");
+const agent_base_1 = require("agent-base");
+const get_uri_1 = require("get-uri");
+const pac_resolver_1 = require("pac-resolver");
+const quickjs_emscripten_1 = require("@tootallnate/quickjs-emscripten");
+const debug = (0, debug_1.default)('pac-proxy-agent');
+const setServernameFromNonIpHost = (options) => {
+    if (options.servername === undefined &&
+        options.host &&
+        !net.isIP(options.host)) {
+        return {
+            ...options,
+            servername: options.host,
+        };
+    }
+    return options;
+};
+/**
+ * The `PacProxyAgent` class.
+ *
+ * A few different "protocol" modes are supported (supported protocols are
+ * backed by the `get-uri` module):
+ *
+ *   - "pac+data", "data" - refers to an embedded "data:" URI
+ *   - "pac+file", "file" - refers to a local file
+ *   - "pac+ftp", "ftp" - refers to a file located on an FTP server
+ *   - "pac+http", "http" - refers to an HTTP endpoint
+ *   - "pac+https", "https" - refers to an HTTPS endpoint
+ */
+class PacProxyAgent extends agent_base_1.Agent {
+    constructor(uri, opts) {
+        super(opts);
+        this.clearResolverPromise = () => {
+            this.resolverPromise = undefined;
+        };
+        // Strip the "pac+" prefix
+        const uriStr = typeof uri === 'string' ? uri : uri.href;
+        this.uri = new url_1.URL(uriStr.replace(/^pac\+/i, ''));
+        debug('Creating PacProxyAgent with URI %o', this.uri.href);
+        // @ts-expect-error Not sure why TS is complaining here…
+        this.opts = { ...opts };
+        this.cache = undefined;
+        this.resolver = undefined;
+        this.resolverHash = '';
+        this.resolverPromise = undefined;
+        // For `PacResolver`
+        if (!this.opts.filename) {
+            this.opts.filename = this.uri.href;
+        }
+    }
+    /**
+     * Loads the PAC proxy file from the source if necessary, and returns
+     * a generated `FindProxyForURL()` resolver function to use.
+     */
+    getResolver() {
+        if (!this.resolverPromise) {
+            this.resolverPromise = this.loadResolver();
+            this.resolverPromise.then(this.clearResolverPromise, this.clearResolverPromise);
+        }
+        return this.resolverPromise;
+    }
+    async loadResolver() {
+        try {
+            // (Re)load the contents of the PAC file URI
+            const [qjs, code] = await Promise.all([
+                (0, quickjs_emscripten_1.getQuickJS)(),
+                this.loadPacFile(),
+            ]);
+            // Create a sha1 hash of the JS code
+            const hash = crypto.createHash('sha1').update(code).digest('hex');
+            if (this.resolver && this.resolverHash === hash) {
+                debug('Same sha1 hash for code - contents have not changed, reusing previous proxy resolver');
+                return this.resolver;
+            }
+            // Cache the resolver
+            debug('Creating new proxy resolver instance');
+            this.resolver = (0, pac_resolver_1.createPacResolver)(qjs, code, this.opts);
+            // Store that sha1 hash for future comparison purposes
+            this.resolverHash = hash;
+            return this.resolver;
+        }
+        catch (err) {
+            if (this.resolver &&
+                err.code === 'ENOTMODIFIED') {
+                debug('Got ENOTMODIFIED response, reusing previous proxy resolver');
+                return this.resolver;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Loads the contents of the PAC proxy file.
+     *
+     * @api private
+     */
+    async loadPacFile() {
+        debug('Loading PAC file: %o', this.uri);
+        const rs = await (0, get_uri_1.getUri)(this.uri, { ...this.opts, cache: this.cache });
+        debug('Got `Readable` instance for URI');
+        this.cache = rs;
+        const buf = await (0, agent_base_1.toBuffer)(rs);
+        debug('Read %o byte PAC file from URI', buf.length);
+        return buf.toString('utf8');
+    }
+    /**
+     * Called when the node-core HTTP client library is creating a new HTTP request.
+     */
+    async connect(req, opts) {
+        const { secureEndpoint } = opts;
+        const isWebSocket = req.getHeader('upgrade') === 'websocket';
+        // First, get a generated `FindProxyForURL()` function,
+        // either cached or retrieved from the source
+        const resolver = await this.getResolver();
+        // Calculate the `url` parameter
+        const protocol = secureEndpoint ? 'https:' : 'http:';
+        const host = opts.host && net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+        const defaultPort = secureEndpoint ? 443 : 80;
+        const url = Object.assign(new url_1.URL(req.path, `${protocol}//${host}`), defaultPort ? undefined : { port: opts.port });
+        debug('url: %s', url);
+        let result = await resolver(url);
+        // Default to "DIRECT" if a falsey value was returned (or nothing)
+        if (!result) {
+            result = 'DIRECT';
+        }
+        const proxies = String(result)
+            .trim()
+            .split(/\s*;\s*/g)
+            .filter(Boolean);
+        if (this.opts.fallbackToDirect && !proxies.includes('DIRECT')) {
+            proxies.push('DIRECT');
+        }
+        for (const proxy of proxies) {
+            let agent = null;
+            let socket = null;
+            const [type, target] = proxy.split(/\s+/);
+            debug('Attempting to use proxy: %o', proxy);
+            if (type === 'DIRECT') {
+                // Direct connection to the destination endpoint
+                if (secureEndpoint) {
+                    socket = tls.connect(setServernameFromNonIpHost(opts));
+                }
+                else {
+                    socket = net.connect(opts);
+                }
+            }
+            else if (type === 'SOCKS' || type === 'SOCKS5') {
+                // Use a SOCKSv5h proxy
+                const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar(require('socks-proxy-agent')));
+                agent = new SocksProxyAgent(`socks://${target}`, this.opts);
+            }
+            else if (type === 'SOCKS4') {
+                // Use a SOCKSv4a proxy
+                const { SocksProxyAgent } = await Promise.resolve().then(() => __importStar(require('socks-proxy-agent')));
+                agent = new SocksProxyAgent(`socks4a://${target}`, this.opts);
+            }
+            else if (type === 'PROXY' ||
+                type === 'HTTP' ||
+                type === 'HTTPS') {
+                // Use an HTTP or HTTPS proxy
+                // http://dev.chromium.org/developers/design-documents/secure-web-proxy
+                const proxyURL = `${type === 'HTTPS' ? 'https' : 'http'}://${target}`;
+                if (secureEndpoint || isWebSocket) {
+                    const { HttpsProxyAgent } = await Promise.resolve().then(() => __importStar(require('https-proxy-agent')));
+                    agent = new HttpsProxyAgent(proxyURL, this.opts);
+                }
+                else {
+                    const { HttpProxyAgent } = await Promise.resolve().then(() => __importStar(require('http-proxy-agent')));
+                    agent = new HttpProxyAgent(proxyURL, this.opts);
+                }
+            }
+            try {
+                if (socket) {
+                    // "DIRECT" connection, wait for connection confirmation
+                    await (0, events_1.once)(socket, 'connect');
+                    req.emit('proxy', { proxy, socket });
+                    return socket;
+                }
+                if (agent) {
+                    const s = await agent.connect(req, opts);
+                    if (!(s instanceof net.Socket)) {
+                        throw new Error('Expected a `net.Socket` to be returned from agent');
+                    }
+                    req.emit('proxy', { proxy, socket: s });
+                    return s;
+                }
+                throw new Error(`Could not determine proxy type for: ${proxy}`);
+            }
+            catch (err) {
+                debug('Got error for proxy %o: %o', proxy, err);
+                req.emit('proxy', { proxy, error: err });
+            }
+        }
+        throw new Error(`Failed to establish a socket connection to proxies: ${JSON.stringify(proxies)}`);
+    }
+}
+PacProxyAgent.protocols = [
+    'pac+data',
+    'pac+file',
+    'pac+ftp',
+    'pac+http',
+    'pac+https',
+];
+exports.PacProxyAgent = PacProxyAgent;
+//# sourceMappingURL=index.js.map

package/web/.next/standalone/node_modules/pac-proxy-agent/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "pac-proxy-agent",
+  "version": "7.2.0",
+  "description": "A PAC file proxy `http.Agent` implementation for HTTP",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TooTallNate/proxy-agents.git",
+    "directory": "packages/pac-proxy-agent"
+  },
+  "keywords": [
+    "pac",
+    "proxy",
+    "agent",
+    "http",
+    "https",
+    "socks",
+    "request",
+    "access"
+  ],
+  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)",
+  "license": "MIT",
+  "dependencies": {
+    "@tootallnate/quickjs-emscripten": "^0.23.0",
+    "agent-base": "^7.1.2",
+    "debug": "^4.3.4",
+    "get-uri": "^6.0.1",
+    "http-proxy-agent": "^7.0.0",
+    "https-proxy-agent": "^7.0.6",
+    "pac-resolver": "^7.0.1",
+    "socks-proxy-agent": "^8.0.5"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/jest": "^29.5.1",
+    "@types/node": "^14.18.45",
+    "async-listen": "^3.0.0",
+    "jest": "^29.5.0",
+    "socksv5": "0.0.6",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.4",
+    "proxy": "2.2.0",
+    "tsconfig": "0.0.0"
+  },
+  "engines": {
+    "node": ">= 14"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --env node --verbose --bail",
+    "lint": "eslint --ext .ts",
+    "pack": "node ../../scripts/pack.mjs"
+  }
+}

package/web/.next/standalone/node_modules/pac-resolver/dist/dateRange.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * If only a single value is specified (from each category: day, month, year), the
+ * function returns a true value only on days that match that specification. If
+ * both values are specified, the result is true between those times, including
+ * bounds.
+ *
+ * Even though the examples don't show, the "GMT" parameter can be specified
+ * in any of the 9 different call profiles, always as the last parameter.
+ *
+ * Examples:
+ *
+ * ``` js
+ * dateRange(1)
+ * true on the first day of each month, local timezone.
+ *
+ * dateRange(1, "GMT")
+ * true on the first day of each month, GMT timezone.
+ *
+ * dateRange(1, 15)
+ * true on the first half of each month.
+ *
+ * dateRange(24, "DEC")
+ * true on 24th of December each year.
+ *
+ * dateRange(24, "DEC", 1995)
+ * true on 24th of December, 1995.
+ *
+ * dateRange("JAN", "MAR")
+ * true on the first quarter of the year.
+ *
+ * dateRange(1, "JUN", 15, "AUG")
+ * true from June 1st until August 15th, each year (including June 1st and August
+ * 15th).
+ *
+ * dateRange(1, "JUN", 15, 1995, "AUG", 1995)
+ * true from June 1st, 1995, until August 15th, same year.
+ *
+ * dateRange("OCT", 1995, "MAR", 1996)
+ * true from October 1995 until March 1996 (including the entire month of October
+ * 1995 and March 1996).
+ *
+ * dateRange(1995)
+ * true during the entire year 1995.
+ *
+ * dateRange(1995, 1997)
+ * true from beginning of year 1995 until the end of year 1997.
+ * ```
+ *
+ * dateRange(day)
+ * dateRange(day1, day2)
+ * dateRange(mon)
+ * dateRange(month1, month2)
+ * dateRange(year)
+ * dateRange(year1, year2)
+ * dateRange(day1, month1, day2, month2)
+ * dateRange(month1, year1, month2, year2)
+ * dateRange(day1, month1, year1, day2, month2, year2)
+ * dateRange(day1, month1, year1, day2, month2, year2, gmt)
+ *
+ * @param {String} day is the day of month between 1 and 31 (as an integer).
+ * @param {String} month is one of the month strings: JAN FEB MAR APR MAY JUN JUL AUG SEP OCT NOV DEC
+ * @param {String} year is the full year number, for example 1995 (but not 95). Integer.
+ * @param {String} gmt is either the string "GMT", which makes time comparison occur in GMT timezone; if left unspecified, times are taken to be in the local timezone.
+ * @return {Boolean}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function dateRange() {
+    // TODO: implement me!
+    return false;
+}
+exports.default = dateRange;
+//# sourceMappingURL=dateRange.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/dnsDomainIs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Returns true iff the domain of hostname matches.
+ *
+ * Examples:
+ *
+ * ``` js
+ * dnsDomainIs("www.netscape.com", ".netscape.com")
+ *   // is true.
+ *
+ * dnsDomainIs("www", ".netscape.com")
+ *   // is false.
+ *
+ * dnsDomainIs("www.mcom.com", ".netscape.com")
+ *   // is false.
+ * ```
+ *
+ *
+ * @param {String} host is the hostname from the URL.
+ * @param {String} domain is the domain name to test the hostname against.
+ * @return {Boolean} true iff the domain of the hostname matches.
+ */
+function dnsDomainIs(host, domain) {
+    host = String(host);
+    domain = String(domain);
+    return host.substr(domain.length * -1) === domain;
+}
+exports.default = dnsDomainIs;
+//# sourceMappingURL=dnsDomainIs.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/dnsDomainLevels.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Returns the number (integer) of DNS domain levels (number of dots) in the
+ * hostname.
+ *
+ * Examples:
+ *
+ * ``` js
+ * dnsDomainLevels("www")
+ *   // returns 0.
+ * dnsDomainLevels("www.netscape.com")
+ *   // returns 2.
+ * ```
+ *
+ * @param {String} host is the hostname from the URL.
+ * @return {Number} number of domain levels
+ */
+function dnsDomainLevels(host) {
+    const match = String(host).match(/\./g);
+    let levels = 0;
+    if (match) {
+        levels = match.length;
+    }
+    return levels;
+}
+exports.default = dnsDomainLevels;
+//# sourceMappingURL=dnsDomainLevels.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/dnsResolve.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+/**
+ * Resolves the given DNS hostname into an IP address, and returns it in the dot
+ * separated format as a string.
+ *
+ * Example:
+ *
+ * ``` js
+ * dnsResolve("home.netscape.com")
+ *   // returns the string "198.95.249.79".
+ * ```
+ *
+ * @param {String} host hostname to resolve
+ * @return {String} resolved IP address
+ */
+async function dnsResolve(host) {
+    const family = 4;
+    try {
+        const r = await (0, util_1.dnsLookup)(host, { family });
+        if (typeof r === 'string') {
+            return r;
+        }
+    }
+    catch (err) {
+        // @ignore
+    }
+    return null;
+}
+exports.default = dnsResolve;
+//# sourceMappingURL=dnsResolve.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandbox = exports.createPacResolver = void 0;
+const degenerator_1 = require("degenerator");
+/**
+ * Built-in PAC functions.
+ */
+const dateRange_1 = __importDefault(require("./dateRange"));
+const dnsDomainIs_1 = __importDefault(require("./dnsDomainIs"));
+const dnsDomainLevels_1 = __importDefault(require("./dnsDomainLevels"));
+const dnsResolve_1 = __importDefault(require("./dnsResolve"));
+const isInNet_1 = __importDefault(require("./isInNet"));
+const isPlainHostName_1 = __importDefault(require("./isPlainHostName"));
+const isResolvable_1 = __importDefault(require("./isResolvable"));
+const localHostOrDomainIs_1 = __importDefault(require("./localHostOrDomainIs"));
+const myIpAddress_1 = __importDefault(require("./myIpAddress"));
+const shExpMatch_1 = __importDefault(require("./shExpMatch"));
+const timeRange_1 = __importDefault(require("./timeRange"));
+const weekdayRange_1 = __importDefault(require("./weekdayRange"));
+/**
+ * Returns an asynchronous `FindProxyForURL()` function
+ * from the given JS string (from a PAC file).
+ */
+function createPacResolver(qjs, _str, _opts = {}) {
+    const str = Buffer.isBuffer(_str) ? _str.toString('utf8') : _str;
+    // The sandbox to use for the `vm` context.
+    const context = {
+        ...exports.sandbox,
+        ..._opts.sandbox,
+    };
+    // Construct the array of async function names to add `await` calls to.
+    const names = Object.keys(context).filter((k) => isAsyncFunction(context[k]));
+    const opts = {
+        filename: 'proxy.pac',
+        names,
+        ..._opts,
+        sandbox: context,
+    };
+    // Compile the JS `FindProxyForURL()` function into an async function.
+    const resolver = (0, degenerator_1.compile)(qjs, str, 'FindProxyForURL', opts);
+    function FindProxyForURL(url, _host) {
+        const urlObj = typeof url === 'string' ? new URL(url) : url;
+        const host = _host || urlObj.hostname;
+        if (!host) {
+            throw new TypeError('Could not determine `host`');
+        }
+        return resolver(urlObj.href, host);
+    }
+    Object.defineProperty(FindProxyForURL, 'toString', {
+        value: () => resolver.toString(),
+        enumerable: false,
+    });
+    return FindProxyForURL;
+}
+exports.createPacResolver = createPacResolver;
+exports.sandbox = Object.freeze({
+    alert: (message = '') => console.log('%s', message),
+    dateRange: dateRange_1.default,
+    dnsDomainIs: dnsDomainIs_1.default,
+    dnsDomainLevels: dnsDomainLevels_1.default,
+    dnsResolve: dnsResolve_1.default,
+    isInNet: isInNet_1.default,
+    isPlainHostName: isPlainHostName_1.default,
+    isResolvable: isResolvable_1.default,
+    localHostOrDomainIs: localHostOrDomainIs_1.default,
+    myIpAddress: myIpAddress_1.default,
+    shExpMatch: shExpMatch_1.default,
+    timeRange: timeRange_1.default,
+    weekdayRange: weekdayRange_1.default,
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isAsyncFunction(v) {
+    if (typeof v !== 'function')
+        return false;
+    // Native `AsyncFunction`
+    if (v.constructor.name === 'AsyncFunction')
+        return true;
+    // TypeScript compiled
+    if (String(v).indexOf('__awaiter(') !== -1)
+        return true;
+    // Legacy behavior - set `async` property on the function
+    return Boolean(v.async);
+}
+//# sourceMappingURL=index.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/ip.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ip = void 0;
+const os_1 = __importDefault(require("os"));
+exports.ip = {
+    address() {
+        const interfaces = os_1.default.networkInterfaces();
+        // Default to `ipv4`
+        const family = normalizeFamily();
+        const all = Object.values(interfaces).map((addrs = []) => {
+            const addresses = addrs.filter((details) => {
+                const detailsFamily = normalizeFamily(details.family);
+                if (detailsFamily !== family || exports.ip.isLoopback(details.address)) {
+                    return false;
+                }
+                return true;
+            });
+            return addresses.length ? addresses[0].address : undefined;
+        }).filter(Boolean);
+        return !all.length ? exports.ip.loopback(family) : all[0];
+    },
+    isLoopback(addr) {
+        return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
+            .test(addr)
+            || /^fe80::1$/.test(addr)
+            || /^::1$/.test(addr)
+            || /^::$/.test(addr);
+    },
+    loopback(family) {
+        // Default to `ipv4`
+        family = normalizeFamily(family);
+        if (family !== 'ipv4' && family !== 'ipv6') {
+            throw new Error('family must be ipv4 or ipv6');
+        }
+        return family === 'ipv4' ? '127.0.0.1' : 'fe80::1';
+    }
+};
+function normalizeFamily(family) {
+    if (family === 4) {
+        return 'ipv4';
+    }
+    if (family === 6) {
+        return 'ipv6';
+    }
+    return family ? family.toLowerCase() : 'ipv4';
+}
+//# sourceMappingURL=ip.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/isInNet.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const netmask_1 = require("netmask");
+const util_1 = require("./util");
+/**
+ * True iff the IP address of the host matches the specified IP address pattern.
+ *
+ * Pattern and mask specification is done the same way as for SOCKS configuration.
+ *
+ * Examples:
+ *
+ * ``` js
+ * isInNet(host, "198.95.249.79", "255.255.255.255")
+ *   // is true iff the IP address of host matches exactly 198.95.249.79.
+ *
+ * isInNet(host, "198.95.0.0", "255.255.0.0")
+ *   // is true iff the IP address of the host matches 198.95.*.*.
+ * ```
+ *
+ * @param {String} host a DNS hostname, or IP address. If a hostname is passed,
+ *   it will be resoved into an IP address by this function.
+ * @param {String} pattern an IP address pattern in the dot-separated format mask.
+ * @param {String} mask for the IP address pattern informing which parts of the
+ *   IP address should be matched against. 0 means ignore, 255 means match.
+ * @return {Boolean}
+ */
+async function isInNet(host, pattern, mask) {
+    const family = 4;
+    try {
+        const ip = await (0, util_1.dnsLookup)(host, { family });
+        if (typeof ip === 'string') {
+            const netmask = new netmask_1.Netmask(pattern, mask);
+            return netmask.contains(ip);
+        }
+    }
+    catch (err) {
+        // ignore
+    }
+    return false;
+}
+exports.default = isInNet;
+//# sourceMappingURL=isInNet.js.map

package/web/.next/standalone/node_modules/pac-resolver/dist/isPlainHostName.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * True iff there is no domain name in the hostname (no dots).
+ *
+ * Examples:
+ *
+ * ``` js
+ * isPlainHostName("www")
+ *   // is true.
+ *
+ * isPlainHostName("www.netscape.com")
+ *   // is false.
+ * ```
+ *
+ * @param {String} host The hostname from the URL (excluding port number).
+ * @return {Boolean}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function isPlainHostName(host) {
+    return !/\./.test(host);
+}
+exports.default = isPlainHostName;
+//# sourceMappingURL=isPlainHostName.js.map