From 0bd83406936f49fc04cef048d433898f9f0b45fb Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Tue, 11 May 2021 02:29:53 +0530 Subject: [PATCH 1/9] fix: quickly Commenting on PRs hit api limit --- .../markPullRequestsAsDeployed.js | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js index 5f6b43dfc533..fe456c6c08cd 100644 --- a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js +++ b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js @@ -44,15 +44,26 @@ message += `\n\n platform | result \n ---|--- \nšŸ¤– android šŸ¤–|${androidResul message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; /** - * Create comment on each pull request + * Comment Single PR + * + * @param {Object} pr + * @returns {Promise} */ -prList.forEach((pr) => { - githubUtils.createComment(github.context.repo.repo, pr, message, octokit) +function commentPR(pr) { + return githubUtils.createComment(github.context.repo.repo, pr, message, octokit) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); + + // Sleep for 1 sec before making another request + return new Promise(res => setTimeout(res, 1000)); }) .catch((err) => { console.log(`Unable to write comment on #${pr} šŸ˜ž`); core.setFailed(err.message); }); -}); +} + +/** + * Create comment on each pull request + */ +prList.reduce((promise, pr) => promise.then(() => commentPR(pr)), Promise.resolve()); From 18e80f018b55aa76a97e0560575369b631367d91 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Tue, 11 May 2021 02:50:23 +0530 Subject: [PATCH 2/9] rebuild GH actions --- .../markPullRequestsAsDeployed/index.js | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/.github/actions/markPullRequestsAsDeployed/index.js b/.github/actions/markPullRequestsAsDeployed/index.js index bd86817652cf..e437751d12e2 100644 --- a/.github/actions/markPullRequestsAsDeployed/index.js +++ b/.github/actions/markPullRequestsAsDeployed/index.js @@ -54,18 +54,29 @@ message += `\n\n platform | result \n ---|--- \nšŸ¤– android šŸ¤–|${androidResul message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; /** - * Create comment on each pull request + * Comment Single PR + * + * @param {Object} pr + * @returns {Promise} */ -prList.forEach((pr) => { - githubUtils.createComment(github.context.repo.repo, pr, message, octokit) +function commentPR(pr) { + return githubUtils.createComment(github.context.repo.repo, pr, message, octokit) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); + + // Sleep for 1 sec before making another request + return new Promise(res => setTimeout(res, 1000)); }) .catch((err) => { console.log(`Unable to write comment on #${pr} šŸ˜ž`); core.setFailed(err.message); }); -}); +} + +/** + * Create comment on each pull request + */ +prList.reduce((promise, pr) => promise.then(() => commentPR(pr)), Promise.resolve()); /***/ }), From 346858e8b1c1c00c704bd3eedfda9d74200f27c4 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Wed, 12 May 2021 04:07:04 +0530 Subject: [PATCH 3/9] added throttlling --- .../markPullRequestsAsDeployed/index.js | 1903 ++++++++++++++++- .../markPullRequestsAsDeployed.js | 32 +- package-lock.json | 16 + package.json | 1 + 4 files changed, 1897 insertions(+), 55 deletions(-) diff --git a/.github/actions/markPullRequestsAsDeployed/index.js b/.github/actions/markPullRequestsAsDeployed/index.js index e437751d12e2..5e7bfb32cf64 100644 --- a/.github/actions/markPullRequestsAsDeployed/index.js +++ b/.github/actions/markPullRequestsAsDeployed/index.js @@ -9,16 +9,39 @@ module.exports = /***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require__) => { const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GithubUtils = __nccwpck_require__(7999); +const OctokitThrottled = GitHub.plugin(throttling); + const prList = JSON.parse(core.getInput('PR_LIST', {required: true})); const isProd = JSON.parse( core.getInput('IS_PRODUCTION_DEPLOY', {required: true}), ); const version = core.getInput('DEPLOY_VERSION', {required: true}); const token = core.getInput('GITHUB_TOKEN', {required: true}); -const octokit = github.getOctokit(token); +const octokit = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry twice after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, +})); const githubUtils = new GithubUtils(octokit); /** @@ -60,12 +83,9 @@ message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; * @returns {Promise} */ function commentPR(pr) { - return githubUtils.createComment(github.context.repo.repo, pr, message, octokit) + return githubUtils.createComment(GitHub.context.repo.repo, pr, message, octokit) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); - - // Sleep for 1 sec before making another request - return new Promise(res => setTimeout(res, 1000)); }) .catch((err) => { console.log(`Unable to write comment on #${pr} šŸ˜ž`); @@ -930,49 +950,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3811,6 +3788,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4253,6 +4528,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js index fe456c6c08cd..96eeedf38c5d 100644 --- a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js +++ b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js @@ -1,14 +1,37 @@ const core = require('@actions/core'); -const github = require('@actions/github'); +const {GitHub, getOctokitOptions} = require('@actions/github/lib/utils'); +const {throttling} = require('@octokit/plugin-throttling'); const GithubUtils = require('../../libs/GithubUtils'); +const OctokitThrottled = GitHub.plugin(throttling); + const prList = JSON.parse(core.getInput('PR_LIST', {required: true})); const isProd = JSON.parse( core.getInput('IS_PRODUCTION_DEPLOY', {required: true}), ); const version = core.getInput('DEPLOY_VERSION', {required: true}); const token = core.getInput('GITHUB_TOKEN', {required: true}); -const octokit = github.getOctokit(token); +const octokit = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry twice after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, +})); const githubUtils = new GithubUtils(octokit); /** @@ -50,12 +73,9 @@ message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; * @returns {Promise} */ function commentPR(pr) { - return githubUtils.createComment(github.context.repo.repo, pr, message, octokit) + return githubUtils.createComment(GitHub.context.repo.repo, pr, message, octokit) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); - - // Sleep for 1 sec before making another request - return new Promise(res => setTimeout(res, 1000)); }) .catch((err) => { console.log(`Unable to write comment on #${pr} šŸ˜ž`); diff --git a/package-lock.json b/package-lock.json index 60383a20735b..44834e17224d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -3619,6 +3619,16 @@ "deprecation": "^2.3.1" } }, + "@octokit/plugin-throttling": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.4.1.tgz", + "integrity": "sha512-qCQ+Z4AnL9OrXvV59EH3GzPxsB+WyqufoCjiCJXJxTbnt3W+leXbXw5vHrMp4NG9ltw00McFWIxIxNQAzLNoTA==", + "dev": true, + "requires": { + "@octokit/types": "^6.0.1", + "bottleneck": "^2.15.3" + } + }, "@octokit/request": { "version": "5.4.14", "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.4.14.tgz", @@ -6771,6 +6781,12 @@ "dev": true, "optional": true }, + "bottleneck": { + "version": "2.19.5", + "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz", + "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw==", + "dev": true + }, "boxen": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/boxen/-/boxen-4.2.0.tgz", diff --git a/package.json b/package.json index aa67c259893b..24eda9d64b21 100644 --- a/package.json +++ b/package.json @@ -102,6 +102,7 @@ "@babel/preset-react": "^7.10.4", "@babel/runtime": "^7.11.2", "@octokit/core": "^3.3.1", + "@octokit/plugin-throttling": "^3.4.1", "@octokit/rest": "^18.3.5", "@react-native-community/eslint-config": "^2.0.0", "@svgr/webpack": "^5.5.0", From 08f317de016fb435ea07829991c6873097bc033e Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Wed, 12 May 2021 04:13:50 +0530 Subject: [PATCH 4/9] typo --- .github/actions/markPullRequestsAsDeployed/index.js | 2 +- .../markPullRequestsAsDeployed/markPullRequestsAsDeployed.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/actions/markPullRequestsAsDeployed/index.js b/.github/actions/markPullRequestsAsDeployed/index.js index de3b04d935df..e2461d59e59b 100644 --- a/.github/actions/markPullRequestsAsDeployed/index.js +++ b/.github/actions/markPullRequestsAsDeployed/index.js @@ -27,7 +27,7 @@ const octokit = new OctokitThrottled(getOctokitOptions(token, { `Request quota exhausted for request ${options.method} ${options.url}`, ); - // Retry twice after hitting a rate limit error, then give up + // Retry once after hitting a rate limit error, then give up if (options.request.retryCount <= 1) { console.log(`Retrying after ${retryAfter} seconds!`); return true; diff --git a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js index 5c35a33a5cbe..53667bb2812b 100644 --- a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js +++ b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js @@ -17,7 +17,7 @@ const octokit = new OctokitThrottled(getOctokitOptions(token, { `Request quota exhausted for request ${options.method} ${options.url}`, ); - // Retry twice after hitting a rate limit error, then give up + // Retry once after hitting a rate limit error, then give up if (options.request.retryCount <= 1) { console.log(`Retrying after ${retryAfter} seconds!`); return true; From bbb8a86592e93bfa52aab5207896b877e190e887 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Thu, 13 May 2021 23:59:19 +0530 Subject: [PATCH 5/9] new: throttled octo default instance in GithubUtils --- .github/libs/GithubUtils.js | 58 +++++++++++++++++++++++++++++-------- 1 file changed, 46 insertions(+), 12 deletions(-) diff --git a/.github/libs/GithubUtils.js b/.github/libs/GithubUtils.js index 30aca6327ed5..8ddce952559f 100644 --- a/.github/libs/GithubUtils.js +++ b/.github/libs/GithubUtils.js @@ -1,5 +1,8 @@ const _ = require('underscore'); const lodashGet = require('lodash/get'); +const core = require('@actions/core'); +const {GitHub, getOctokitOptions} = require('@actions/github/lib/utils'); +const {throttling} = require('@octokit/plugin-throttling'); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -15,18 +18,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -56,7 +90,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -81,7 +115,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -119,7 +153,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -155,7 +189,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -176,7 +210,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -235,7 +269,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -302,7 +336,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -318,7 +352,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, From b1341ea3baad8f045fc54997ccf2a4468967f037 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Fri, 14 May 2021 00:00:44 +0530 Subject: [PATCH 6/9] move Throttling to GithubUtils --- .../markPullRequestsAsDeployed.js | 28 ++----------------- 1 file changed, 2 insertions(+), 26 deletions(-) diff --git a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js index 53667bb2812b..3512d08230b4 100644 --- a/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js +++ b/.github/actions/markPullRequestsAsDeployed/markPullRequestsAsDeployed.js @@ -1,37 +1,13 @@ const core = require('@actions/core'); -const {GitHub, getOctokitOptions} = require('@actions/github/lib/utils'); -const {throttling} = require('@octokit/plugin-throttling'); +const {GitHub} = require('@actions/github/lib/utils'); const ActionUtils = require('../../libs/ActionUtils'); const GithubUtils = require('../../libs/GithubUtils'); -const OctokitThrottled = GitHub.plugin(throttling); const prList = ActionUtils.getJSONInput('PR_LIST', {required: true}); const isProd = ActionUtils.getJSONInput('IS_PRODUCTION_DEPLOY', {required: true}); const version = core.getInput('DEPLOY_VERSION', {required: true}); -const token = core.getInput('GITHUB_TOKEN', {required: true}); -const octokit = new OctokitThrottled(getOctokitOptions(token, { - throttle: { - onRateLimit: (retryAfter, options) => { - console.warn( - `Request quota exhausted for request ${options.method} ${options.url}`, - ); - // Retry once after hitting a rate limit error, then give up - if (options.request.retryCount <= 1) { - console.log(`Retrying after ${retryAfter} seconds!`); - return true; - } - }, - onAbuseLimit: (retryAfter, options) => { - // does not retry, only logs a warning - console.warn( - `Abuse detected for request ${options.method} ${options.url}`, - ); - }, - }, -})); -const githubUtils = new GithubUtils(octokit); /** * Return a nicely formatted message for the table based on the result of the GitHub action job @@ -72,7 +48,7 @@ message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; * @returns {Promise} */ function commentPR(pr) { - return githubUtils.createComment(GitHub.context.repo.repo, pr, message, octokit) + return GithubUtils.createComment(GitHub.context.repo.repo, pr, message) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); }) From f115490f72821978e35a7a6413ac4203797b3ea9 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Fri, 14 May 2021 00:29:34 +0530 Subject: [PATCH 7/9] updated all github actions to use new throttled Octokit --- .../checkDeployBlockers.js | 16 +- .github/actions/checkDeployBlockers/index.js | 1945 ++- .../createOrUpdateStagingDeploy.js | 14 +- .../createOrUpdateStagingDeploy/index.js | 1943 ++- .github/actions/getReleaseBody/index.js | 12719 ++++++++++++++-- .../actions/isPullRequestMergeable/index.js | 1939 ++- .../isPullRequestMergeable.js | 10 +- .../actions/isStagingDeployLocked/index.js | 1935 ++- .../isStagingDeployLocked.js | 6 +- .../markPullRequestsAsDeployed/index.js | 88 +- .../actions/reopenIssueWithComment/index.js | 1945 ++- .../reopenIssueWithComment.js | 16 +- .../actions/triggerWorkflowAndWait/index.js | 1940 ++- .../triggerWorkflowAndWait.js | 11 +- tests/unit/GithubUtilsTest.js | 79 +- 15 files changed, 23020 insertions(+), 1586 deletions(-) diff --git a/.github/actions/checkDeployBlockers/checkDeployBlockers.js b/.github/actions/checkDeployBlockers/checkDeployBlockers.js index fec64a7e74a5..000ea410b94d 100644 --- a/.github/actions/checkDeployBlockers/checkDeployBlockers.js +++ b/.github/actions/checkDeployBlockers/checkDeployBlockers.js @@ -1,17 +1,15 @@ const _ = require('underscore'); const core = require('@actions/core'); -const github = require('@actions/github'); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = require('../../libs/GithubUtils'); +const GithubUtils = require('../../libs/GithubUtils'); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const issueNumber = Number(core.getInput('ISSUE_NUMBER', {required: true})); console.log(`Fetching issue number ${issueNumber}`); - return octokit.issues.get({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.get({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, }) .then(({data}) => { @@ -26,9 +24,9 @@ const run = function () { return; } - return octokit.issues.listComments({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.listComments({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, per_page: 100, }); diff --git a/.github/actions/checkDeployBlockers/index.js b/.github/actions/checkDeployBlockers/index.js index 31c898dbfb1e..cd2185f6f58d 100644 --- a/.github/actions/checkDeployBlockers/index.js +++ b/.github/actions/checkDeployBlockers/index.js @@ -10,18 +10,16 @@ module.exports = const _ = __nccwpck_require__(4987); const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = __nccwpck_require__(7999); +const GithubUtils = __nccwpck_require__(7999); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const issueNumber = Number(core.getInput('ISSUE_NUMBER', {required: true})); console.log(`Fetching issue number ${issueNumber}`); - return octokit.issues.get({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.get({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, }) .then(({data}) => { @@ -36,9 +34,9 @@ const run = function () { return; } - return octokit.issues.listComments({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.listComments({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, per_page: 100, }); @@ -90,6 +88,9 @@ module.exports = run; const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -105,18 +106,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -146,7 +178,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -171,7 +203,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -209,7 +241,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -245,7 +277,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -266,7 +298,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -325,7 +357,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -392,7 +424,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -408,7 +440,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -956,49 +988,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3837,6 +3826,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4279,6 +4566,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/createOrUpdateStagingDeploy/createOrUpdateStagingDeploy.js b/.github/actions/createOrUpdateStagingDeploy/createOrUpdateStagingDeploy.js index 3e96bd5a61c5..a0bfd322ec3a 100644 --- a/.github/actions/createOrUpdateStagingDeploy/createOrUpdateStagingDeploy.js +++ b/.github/actions/createOrUpdateStagingDeploy/createOrUpdateStagingDeploy.js @@ -1,16 +1,14 @@ const _ = require('underscore'); const core = require('@actions/core'); -const github = require('@actions/github'); const moment = require('moment'); const GithubUtils = require('../../libs/GithubUtils'); const GitUtils = require('../../libs/GitUtils'); const newVersion = core.getInput('NPM_VERSION'); -const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); -const githubUtils = new GithubUtils(octokit); -githubUtils.getStagingDeployCash() - .then(() => githubUtils.updateStagingDeployCash( + +GithubUtils.getStagingDeployCash() + .then(() => GithubUtils.updateStagingDeployCash( newVersion, _.filter( _.map(core.getInput('NEW_PULL_REQUESTS').split(','), PR => PR.trim()), @@ -31,7 +29,7 @@ githubUtils.getStagingDeployCash() console.log('No open StagingDeployCash found, creating a new one.'); // Fetch all the StagingDeployCash issues - return octokit.issues.listForRepo({ + return GithubUtils.octokit.issues.listForRepo({ log: console, owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, @@ -53,13 +51,13 @@ githubUtils.getStagingDeployCash() } // Parse the tag from the most recent StagingDeployCash - const lastTag = githubUtils.getStagingDeployCashData(githubResponse.data[0]).tag; + const lastTag = GithubUtils.getStagingDeployCashData(githubResponse.data[0]).tag; console.log('Found tag of previous StagingDeployCash:', lastTag); // Find the list of PRs merged between the last StagingDeployCash and the new version return GitUtils.getPullRequestsMergedBetween(lastTag, newVersion); }) - .then(PRNumbers => githubUtils.createNewStagingDeployCash( + .then(PRNumbers => GithubUtils.createNewStagingDeployCash( `Deploy Checklist: Expensify.cash ${moment().format('YYYY-MM-DD')}`, newVersion, _.map(PRNumbers, GithubUtils.getPullRequestURLFromNumber), diff --git a/.github/actions/createOrUpdateStagingDeploy/index.js b/.github/actions/createOrUpdateStagingDeploy/index.js index e8098a7ba360..07d222c65f55 100644 --- a/.github/actions/createOrUpdateStagingDeploy/index.js +++ b/.github/actions/createOrUpdateStagingDeploy/index.js @@ -10,17 +10,15 @@ module.exports = const _ = __nccwpck_require__(4987); const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); const moment = __nccwpck_require__(9623); const GithubUtils = __nccwpck_require__(7999); const GitUtils = __nccwpck_require__(669); const newVersion = core.getInput('NPM_VERSION'); -const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); -const githubUtils = new GithubUtils(octokit); -githubUtils.getStagingDeployCash() - .then(() => githubUtils.updateStagingDeployCash( + +GithubUtils.getStagingDeployCash() + .then(() => GithubUtils.updateStagingDeployCash( newVersion, _.filter( _.map(core.getInput('NEW_PULL_REQUESTS').split(','), PR => PR.trim()), @@ -41,7 +39,7 @@ githubUtils.getStagingDeployCash() console.log('No open StagingDeployCash found, creating a new one.'); // Fetch all the StagingDeployCash issues - return octokit.issues.listForRepo({ + return GithubUtils.octokit.issues.listForRepo({ log: console, owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, @@ -63,13 +61,13 @@ githubUtils.getStagingDeployCash() } // Parse the tag from the most recent StagingDeployCash - const lastTag = githubUtils.getStagingDeployCashData(githubResponse.data[0]).tag; + const lastTag = GithubUtils.getStagingDeployCashData(githubResponse.data[0]).tag; console.log('Found tag of previous StagingDeployCash:', lastTag); // Find the list of PRs merged between the last StagingDeployCash and the new version return GitUtils.getPullRequestsMergedBetween(lastTag, newVersion); }) - .then(PRNumbers => githubUtils.createNewStagingDeployCash( + .then(PRNumbers => GithubUtils.createNewStagingDeployCash( `Deploy Checklist: Expensify.cash ${moment().format('YYYY-MM-DD')}`, newVersion, _.map(PRNumbers, GithubUtils.getPullRequestURLFromNumber), @@ -116,6 +114,9 @@ module.exports = { const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -131,18 +132,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -172,7 +204,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -197,7 +229,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -235,7 +267,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -271,7 +303,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -292,7 +324,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -351,7 +383,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -418,7 +450,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -434,7 +466,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -982,49 +1014,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3863,6 +3852,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4305,6 +4592,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/getReleaseBody/index.js b/.github/actions/getReleaseBody/index.js index 4e6e1519baa8..eb87fbc96fe1 100644 --- a/.github/actions/getReleaseBody/index.js +++ b/.github/actions/getReleaseBody/index.js @@ -59,6 +59,9 @@ module.exports = { const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -74,18 +77,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -115,7 +149,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -140,7 +174,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -178,7 +212,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -214,7 +248,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -235,7 +269,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -294,7 +328,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -361,7 +395,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -377,7 +411,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -868,1612 +902,11913 @@ exports.toCommandValue = toCommandValue; /***/ }), -/***/ 5902: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var hashClear = __nccwpck_require__(1789), - hashDelete = __nccwpck_require__(712), - hashGet = __nccwpck_require__(5395), - hashHas = __nccwpck_require__(5232), - hashSet = __nccwpck_require__(7320); +/***/ 4087: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; +"use strict"; - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Context = void 0; +const fs_1 = __nccwpck_require__(5747); +const os_1 = __nccwpck_require__(2087); +class Context { + /** + * Hydrate the context from the environment + */ + constructor() { + this.payload = {}; + if (process.env.GITHUB_EVENT_PATH) { + if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) { + this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' })); + } + else { + const path = process.env.GITHUB_EVENT_PATH; + process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`); + } + } + this.eventName = process.env.GITHUB_EVENT_NAME; + this.sha = process.env.GITHUB_SHA; + this.ref = process.env.GITHUB_REF; + this.workflow = process.env.GITHUB_WORKFLOW; + this.action = process.env.GITHUB_ACTION; + this.actor = process.env.GITHUB_ACTOR; + this.job = process.env.GITHUB_JOB; + this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10); + this.runId = parseInt(process.env.GITHUB_RUN_ID, 10); + } + get issue() { + const payload = this.payload; + return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number }); + } + get repo() { + if (process.env.GITHUB_REPOSITORY) { + const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/'); + return { owner, repo }; + } + if (this.payload.repository) { + return { + owner: this.payload.repository.owner.login, + repo: this.payload.repository.name + }; + } + throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'"); + } } - -// Add methods to `Hash`. -Hash.prototype.clear = hashClear; -Hash.prototype['delete'] = hashDelete; -Hash.prototype.get = hashGet; -Hash.prototype.has = hashHas; -Hash.prototype.set = hashSet; - -module.exports = Hash; - +exports.Context = Context; +//# sourceMappingURL=context.js.map /***/ }), -/***/ 6608: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var listCacheClear = __nccwpck_require__(9792), - listCacheDelete = __nccwpck_require__(7716), - listCacheGet = __nccwpck_require__(5789), - listCacheHas = __nccwpck_require__(9386), - listCacheSet = __nccwpck_require__(7399); +/***/ 7914: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { -/** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; +"use strict"; - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0; +const httpClient = __importStar(__nccwpck_require__(9925)); +function getAuthString(token, options) { + if (!token && !options.auth) { + throw new Error('Parameter token or opts.auth is required'); + } + else if (token && options.auth) { + throw new Error('Parameters token and opts.auth may not both be specified'); + } + return typeof options.auth === 'string' ? options.auth : `token ${token}`; } - -// Add methods to `ListCache`. -ListCache.prototype.clear = listCacheClear; -ListCache.prototype['delete'] = listCacheDelete; -ListCache.prototype.get = listCacheGet; -ListCache.prototype.has = listCacheHas; -ListCache.prototype.set = listCacheSet; - -module.exports = ListCache; - - -/***/ }), - -/***/ 881: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var getNative = __nccwpck_require__(4479), - root = __nccwpck_require__(9882); - -/* Built-in method references that are verified to be native. */ -var Map = getNative(root, 'Map'); - -module.exports = Map; - - -/***/ }), - -/***/ 938: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var mapCacheClear = __nccwpck_require__(1610), - mapCacheDelete = __nccwpck_require__(6657), - mapCacheGet = __nccwpck_require__(1372), - mapCacheHas = __nccwpck_require__(609), - mapCacheSet = __nccwpck_require__(5582); - -/** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } +exports.getAuthString = getAuthString; +function getProxyAgent(destinationUrl) { + const hc = new httpClient.HttpClient(); + return hc.getAgent(destinationUrl); } - -// Add methods to `MapCache`. -MapCache.prototype.clear = mapCacheClear; -MapCache.prototype['delete'] = mapCacheDelete; -MapCache.prototype.get = mapCacheGet; -MapCache.prototype.has = mapCacheHas; -MapCache.prototype.set = mapCacheSet; - -module.exports = MapCache; - - -/***/ }), - -/***/ 9213: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var root = __nccwpck_require__(9882); - -/** Built-in value references. */ -var Symbol = root.Symbol; - -module.exports = Symbol; - - -/***/ }), - -/***/ 4356: -/***/ ((module) => { - -/** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ -function arrayMap(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length, - result = Array(length); - - while (++index < length) { - result[index] = iteratee(array[index], index, array); - } - return result; +exports.getProxyAgent = getProxyAgent; +function getApiBaseUrl() { + return process.env['GITHUB_API_URL'] || 'https://api.github.com'; } - -module.exports = arrayMap; - +exports.getApiBaseUrl = getApiBaseUrl; +//# sourceMappingURL=utils.js.map /***/ }), -/***/ 6752: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +/***/ 3030: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { -var eq = __nccwpck_require__(1901); +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getOctokitOptions = exports.GitHub = exports.context = void 0; +const Context = __importStar(__nccwpck_require__(4087)); +const Utils = __importStar(__nccwpck_require__(7914)); +// octokit + plugins +const core_1 = __nccwpck_require__(6762); +const plugin_rest_endpoint_methods_1 = __nccwpck_require__(3044); +const plugin_paginate_rest_1 = __nccwpck_require__(4193); +exports.context = new Context.Context(); +const baseUrl = Utils.getApiBaseUrl(); +const defaults = { + baseUrl, + request: { + agent: Utils.getProxyAgent(baseUrl) + } +}; +exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults); /** - * Gets the index at which the `key` is found in `array` of key-value pairs. + * Convience function to correctly format Octokit Options to pass into the constructor. * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. + * @param token the repo PAT or GITHUB_TOKEN + * @param options other options to set */ -function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; +function getOctokitOptions(token, options) { + const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller + // Auth + const auth = Utils.getAuthString(token, opts); + if (auth) { + opts.auth = auth; } - } - return -1; + return opts; } - -module.exports = assocIndexOf; - +exports.getOctokitOptions = getOctokitOptions; +//# sourceMappingURL=utils.js.map /***/ }), -/***/ 5758: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +/***/ 9925: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var castPath = __nccwpck_require__(2688), - toKey = __nccwpck_require__(9071); +"use strict"; +Object.defineProperty(exports, "__esModule", ({ value: true })); +const http = __nccwpck_require__(8605); +const https = __nccwpck_require__(7211); +const pm = __nccwpck_require__(6443); +let tunnel; +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers = exports.Headers || (exports.Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {})); /** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com */ -function baseGet(object, path) { - path = castPath(path, object); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; +function getProxyUrl(serverUrl) { + let proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; } - -module.exports = baseGet; - - -/***/ }), - -/***/ 7497: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var Symbol = __nccwpck_require__(9213), - getRawTag = __nccwpck_require__(923), - objectToString = __nccwpck_require__(4200); - -/** `Object#toString` result references. */ -var nullTag = '[object Null]', +exports.getProxyUrl = getProxyUrl; +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return new Promise(async (resolve, reject) => { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + let parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +exports.isHttps = isHttps; +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = userAgent; + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + } + get(requestUrl, additionalHeaders) { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + } + del(requestUrl, additionalHeaders) { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + } + post(requestUrl, data, additionalHeaders) { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + } + patch(requestUrl, data, additionalHeaders) { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + } + put(requestUrl, data, additionalHeaders) { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + } + head(requestUrl, additionalHeaders) { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return this.request(verb, requestUrl, stream, additionalHeaders); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + async getJson(requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + let res = await this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async postJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async putJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + async patchJson(requestUrl, obj, additionalHeaders = {}) { + let data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson); + let res = await this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + async request(verb, requestUrl, data, headers) { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + let parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1 + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + while (numTries < maxTries) { + response = await this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (let i = 0; i < this.handlers.length; i++) { + if (this.handlers[i].canHandleAuthentication(response)) { + authenticationHandler = this.handlers[i]; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + let parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol == 'https:' && + parsedUrl.protocol != parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + await response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (let header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = await this.requestRaw(info, data); + redirectsRemaining--; + } + if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + await response.readBody(); + await this._performExponentialBackoff(numTries); + } + } + return response; + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return new Promise((resolve, reject) => { + let callbackForResult = function (err, res) { + if (err) { + reject(err); + } + resolve(res); + }; + this.requestRawWithCallback(info, data, callbackForResult); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + let socket; + if (typeof data === 'string') { + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + let handleResult = (err, res) => { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + }; + let req = info.httpModule.request(info.options, (msg) => { + let res = new HttpClientResponse(msg); + handleResult(null, res); + }); + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error('Request timeout: ' + info.options.path), null); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err, null); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + let parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + this.handlers.forEach(handler => { + handler.prepareRequest(info.options); + }); + } + return info; + } + _mergeHeaders(headers) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers)); + } + return lowercaseKeys(headers || {}); + } + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + clientHeader = lowercaseKeys(this.requestOptions.headers)[header]; + } + return additionalHeaders[header] || clientHeader || _default; + } + _getAgent(parsedUrl) { + let agent; + let proxyUrl = pm.getProxyUrl(parsedUrl); + let useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (this._keepAlive && !useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (!!agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (!!this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + if (useProxy) { + // If using proxy, need tunnel + if (!tunnel) { + tunnel = __nccwpck_require__(4294); + } + const agentOptions = { + maxSockets: maxSockets, + keepAlive: this._keepAlive, + proxy: { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`, + host: proxyUrl.hostname, + port: proxyUrl.port + } + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if reusing agent across request and tunneling agent isn't assigned create a new agent + if (this._keepAlive && !agent) { + const options = { keepAlive: this._keepAlive, maxSockets: maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + // if not using private agent and tunnel agent isn't setup then use global agent + if (!agent) { + agent = usingSsl ? https.globalAgent : http.globalAgent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _performExponentialBackoff(retryNumber) { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + } + static dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + let a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + async _processResponse(res, options) { + return new Promise(async (resolve, reject) => { + const statusCode = res.message.statusCode; + const response = { + statusCode: statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode == HttpCodes.NotFound) { + resolve(response); + } + let obj; + let contents; + // get the result from the body + try { + contents = await res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, HttpClient.dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = 'Failed request: (' + statusCode + ')'; + } + let err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + }); + } +} +exports.HttpClient = HttpClient; + + +/***/ }), + +/***/ 6443: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +function getProxyUrl(reqUrl) { + let usingSsl = reqUrl.protocol === 'https:'; + let proxyUrl; + if (checkBypass(reqUrl)) { + return proxyUrl; + } + let proxyVar; + if (usingSsl) { + proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + if (proxyVar) { + proxyUrl = new URL(proxyVar); + } + return proxyUrl; +} +exports.getProxyUrl = getProxyUrl; +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; + } + let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + let upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (let upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperReqHosts.some(x => x === upperNoProxyItem)) { + return true; + } + } + return false; +} +exports.checkBypass = checkBypass; + + +/***/ }), + +/***/ 334: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +async function auth(token) { + const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth"; + return { + type: "token", + token: token, + tokenType + }; +} + +/** + * Prefix token for usage in the Authorization header + * + * @param token OAuth token or JSON Web Token + */ +function withAuthorizationPrefix(token) { + if (token.split(/\./).length === 3) { + return `bearer ${token}`; + } + + return `token ${token}`; +} + +async function hook(token, request, route, parameters) { + const endpoint = request.endpoint.merge(route, parameters); + endpoint.headers.authorization = withAuthorizationPrefix(token); + return request(endpoint); +} + +const createTokenAuth = function createTokenAuth(token) { + if (!token) { + throw new Error("[@octokit/auth-token] No token passed to createTokenAuth"); + } + + if (typeof token !== "string") { + throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string"); + } + + token = token.replace(/^(token|bearer) +/i, ""); + return Object.assign(auth.bind(null, token), { + hook: hook.bind(null, token) + }); +}; + +exports.createTokenAuth = createTokenAuth; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 6762: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var universalUserAgent = __nccwpck_require__(5030); +var beforeAfterHook = __nccwpck_require__(3682); +var request = __nccwpck_require__(6234); +var graphql = __nccwpck_require__(8467); +var authToken = __nccwpck_require__(334); + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +const VERSION = "3.3.1"; + +class Octokit { + constructor(options = {}) { + const hook = new beforeAfterHook.Collection(); + const requestDefaults = { + baseUrl: request.request.endpoint.DEFAULTS.baseUrl, + headers: {}, + request: Object.assign({}, options.request, { + // @ts-ignore internal usage only, no need to type + hook: hook.bind(null, "request") + }), + mediaType: { + previews: [], + format: "" + } + }; // prepend default user agent with `options.userAgent` if set + + requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" "); + + if (options.baseUrl) { + requestDefaults.baseUrl = options.baseUrl; + } + + if (options.previews) { + requestDefaults.mediaType.previews = options.previews; + } + + if (options.timeZone) { + requestDefaults.headers["time-zone"] = options.timeZone; + } + + this.request = request.request.defaults(requestDefaults); + this.graphql = graphql.withCustomRequest(this.request).defaults(requestDefaults); + this.log = Object.assign({ + debug: () => {}, + info: () => {}, + warn: console.warn.bind(console), + error: console.error.bind(console) + }, options.log); + this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance + // is unauthenticated. The `this.auth()` method is a no-op and no request hook is registered. + // (2) If only `options.auth` is set, use the default token authentication strategy. + // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance. + // TODO: type `options.auth` based on `options.authStrategy`. + + if (!options.authStrategy) { + if (!options.auth) { + // (1) + this.auth = async () => ({ + type: "unauthenticated" + }); + } else { + // (2) + const auth = authToken.createTokenAuth(options.auth); // @ts-ignore ĀÆ\_(惄)_/ĀÆ + + hook.wrap("request", auth.hook); + this.auth = auth; + } + } else { + const { + authStrategy + } = options, + otherOptions = _objectWithoutProperties(options, ["authStrategy"]); + + const auth = authStrategy(Object.assign({ + request: this.request, + log: this.log, + // we pass the current octokit instance as well as its constructor options + // to allow for authentication strategies that return a new octokit instance + // that shares the same internal state as the current one. The original + // requirement for this was the "event-octokit" authentication strategy + // of https://github.com/probot/octokit-auth-probot. + octokit: this, + octokitOptions: otherOptions + }, options.auth)); // @ts-ignore ĀÆ\_(惄)_/ĀÆ + + hook.wrap("request", auth.hook); + this.auth = auth; + } // apply plugins + // https://stackoverflow.com/a/16345172 + + + const classConstructor = this.constructor; + classConstructor.plugins.forEach(plugin => { + Object.assign(this, plugin(this, options)); + }); + } + + static defaults(defaults) { + const OctokitWithDefaults = class extends this { + constructor(...args) { + const options = args[0] || {}; + + if (typeof defaults === "function") { + super(defaults(options)); + return; + } + + super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? { + userAgent: `${options.userAgent} ${defaults.userAgent}` + } : null)); + } + + }; + return OctokitWithDefaults; + } + /** + * Attach a plugin (or many) to your Octokit instance. + * + * @example + * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...) + */ + + + static plugin(...newPlugins) { + var _a; + + const currentPlugins = this.plugins; + const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a); + return NewOctokit; + } + +} +Octokit.VERSION = VERSION; +Octokit.plugins = []; + +exports.Octokit = Octokit; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9440: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var isPlainObject = __nccwpck_require__(558); +var universalUserAgent = __nccwpck_require__(5030); + +function lowercaseKeys(object) { + if (!object) { + return {}; + } + + return Object.keys(object).reduce((newObj, key) => { + newObj[key.toLowerCase()] = object[key]; + return newObj; + }, {}); +} + +function mergeDeep(defaults, options) { + const result = Object.assign({}, defaults); + Object.keys(options).forEach(key => { + if (isPlainObject.isPlainObject(options[key])) { + if (!(key in defaults)) Object.assign(result, { + [key]: options[key] + });else result[key] = mergeDeep(defaults[key], options[key]); + } else { + Object.assign(result, { + [key]: options[key] + }); + } + }); + return result; +} + +function removeUndefinedProperties(obj) { + for (const key in obj) { + if (obj[key] === undefined) { + delete obj[key]; + } + } + + return obj; +} + +function merge(defaults, route, options) { + if (typeof route === "string") { + let [method, url] = route.split(" "); + options = Object.assign(url ? { + method, + url + } : { + url: method + }, options); + } else { + options = Object.assign({}, route); + } // lowercase header names before merging with defaults to avoid duplicates + + + options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging + + removeUndefinedProperties(options); + removeUndefinedProperties(options.headers); + const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten + + if (defaults && defaults.mediaType.previews.length) { + mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews); + } + + mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, "")); + return mergedOptions; +} + +function addQueryParameters(url, parameters) { + const separator = /\?/.test(url) ? "&" : "?"; + const names = Object.keys(parameters); + + if (names.length === 0) { + return url; + } + + return url + separator + names.map(name => { + if (name === "q") { + return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+"); + } + + return `${name}=${encodeURIComponent(parameters[name])}`; + }).join("&"); +} + +const urlVariableRegex = /\{[^}]+\}/g; + +function removeNonChars(variableName) { + return variableName.replace(/^\W+|\W+$/g, "").split(/,/); +} + +function extractUrlVariableNames(url) { + const matches = url.match(urlVariableRegex); + + if (!matches) { + return []; + } + + return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []); +} + +function omit(object, keysToOmit) { + return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => { + obj[key] = object[key]; + return obj; + }, {}); +} + +// Based on https://github.com/bramstein/url-template, licensed under BSD +// TODO: create separate package. +// +// Copyright (c) 2012-2014, Bram Stein +// 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. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 OWNER 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. + +/* istanbul ignore file */ +function encodeReserved(str) { + return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { + if (!/%[0-9A-Fa-f]/.test(part)) { + part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]"); + } + + return part; + }).join(""); +} + +function encodeUnreserved(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} + +function encodeValue(operator, value, key) { + value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value); + + if (key) { + return encodeUnreserved(key) + "=" + value; + } else { + return value; + } +} + +function isDefined(value) { + return value !== undefined && value !== null; +} + +function isKeyOperator(operator) { + return operator === ";" || operator === "&" || operator === "?"; +} + +function getValues(context, operator, key, modifier) { + var value = context[key], + result = []; + + if (isDefined(value) && value !== "") { + if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") { + value = value.toString(); + + if (modifier && modifier !== "*") { + value = value.substring(0, parseInt(modifier, 10)); + } + + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + } else { + if (modifier === "*") { + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : "")); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + result.push(encodeValue(operator, value[k], k)); + } + }); + } + } else { + const tmp = []; + + if (Array.isArray(value)) { + value.filter(isDefined).forEach(function (value) { + tmp.push(encodeValue(operator, value)); + }); + } else { + Object.keys(value).forEach(function (k) { + if (isDefined(value[k])) { + tmp.push(encodeUnreserved(k)); + tmp.push(encodeValue(operator, value[k].toString())); + } + }); + } + + if (isKeyOperator(operator)) { + result.push(encodeUnreserved(key) + "=" + tmp.join(",")); + } else if (tmp.length !== 0) { + result.push(tmp.join(",")); + } + } + } + } else { + if (operator === ";") { + if (isDefined(value)) { + result.push(encodeUnreserved(key)); + } + } else if (value === "" && (operator === "&" || operator === "?")) { + result.push(encodeUnreserved(key) + "="); + } else if (value === "") { + result.push(""); + } + } + + return result; +} + +function parseUrl(template) { + return { + expand: expand.bind(null, template) + }; +} + +function expand(template, context) { + var operators = ["+", "#", ".", "/", ";", "?", "&"]; + return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) { + if (expression) { + let operator = ""; + const values = []; + + if (operators.indexOf(expression.charAt(0)) !== -1) { + operator = expression.charAt(0); + expression = expression.substr(1); + } + + expression.split(/,/g).forEach(function (variable) { + var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable); + values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3])); + }); + + if (operator && operator !== "+") { + var separator = ","; + + if (operator === "?") { + separator = "&"; + } else if (operator !== "#") { + separator = operator; + } + + return (values.length !== 0 ? operator : "") + values.join(separator); + } else { + return values.join(","); + } + } else { + return encodeReserved(literal); + } + }); +} + +function parse(options) { + // https://fetch.spec.whatwg.org/#methods + let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible + + let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}"); + let headers = Object.assign({}, options.headers); + let body; + let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later + + const urlVariableNames = extractUrlVariableNames(url); + url = parseUrl(url).expand(parameters); + + if (!/^http/.test(url)) { + url = options.baseUrl + url; + } + + const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl"); + const remainingParameters = omit(parameters, omittedParameters); + const isBinaryRequest = /application\/octet-stream/i.test(headers.accept); + + if (!isBinaryRequest) { + if (options.mediaType.format) { + // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw + headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(","); + } + + if (options.mediaType.previews.length) { + const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || []; + headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => { + const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json"; + return `application/vnd.github.${preview}-preview${format}`; + }).join(","); + } + } // for GET/HEAD requests, set URL query parameters from remaining parameters + // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters + + + if (["GET", "HEAD"].includes(method)) { + url = addQueryParameters(url, remainingParameters); + } else { + if ("data" in remainingParameters) { + body = remainingParameters.data; + } else { + if (Object.keys(remainingParameters).length) { + body = remainingParameters; + } else { + headers["content-length"] = 0; + } + } + } // default content-type for JSON if body is set + + + if (!headers["content-type"] && typeof body !== "undefined") { + headers["content-type"] = "application/json; charset=utf-8"; + } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body. + // fetch does not allow to set `content-length` header, but we can set body to an empty string + + + if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") { + body = ""; + } // Only return body/request keys if present + + + return Object.assign({ + method, + url, + headers + }, typeof body !== "undefined" ? { + body + } : null, options.request ? { + request: options.request + } : null); +} + +function endpointWithDefaults(defaults, route, options) { + return parse(merge(defaults, route, options)); +} + +function withDefaults(oldDefaults, newDefaults) { + const DEFAULTS = merge(oldDefaults, newDefaults); + const endpoint = endpointWithDefaults.bind(null, DEFAULTS); + return Object.assign(endpoint, { + DEFAULTS, + defaults: withDefaults.bind(null, DEFAULTS), + merge: merge.bind(null, DEFAULTS), + parse + }); +} + +const VERSION = "6.0.11"; + +const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url. +// So we use RequestParameters and add method as additional required property. + +const DEFAULTS = { + method: "GET", + baseUrl: "https://api.github.com", + headers: { + accept: "application/vnd.github.v3+json", + "user-agent": userAgent + }, + mediaType: { + format: "", + previews: [] + } +}; + +const endpoint = withDefaults(null, DEFAULTS); + +exports.endpoint = endpoint; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 558: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +/*! + * is-plain-object + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +function isObject(o) { + return Object.prototype.toString.call(o) === '[object Object]'; +} + +function isPlainObject(o) { + var ctor,prot; + + if (isObject(o) === false) return false; + + // If has modified constructor + ctor = o.constructor; + if (ctor === undefined) return true; + + // If has modified prototype + prot = ctor.prototype; + if (isObject(prot) === false) return false; + + // If constructor does not have an Object-specific method + if (prot.hasOwnProperty('isPrototypeOf') === false) { + return false; + } + + // Most likely a plain Object + return true; +} + +exports.isPlainObject = isPlainObject; + + +/***/ }), + +/***/ 8467: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +var request = __nccwpck_require__(6234); +var universalUserAgent = __nccwpck_require__(5030); + +const VERSION = "4.6.1"; + +class GraphqlError extends Error { + constructor(request, response) { + const message = response.data.errors[0].message; + super(message); + Object.assign(this, response.data); + Object.assign(this, { + headers: response.headers + }); + this.name = "GraphqlError"; + this.request = request; // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + } + +} + +const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"]; +const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"]; +const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/; +function graphql(request, query, options) { + if (options) { + if (typeof query === "string" && "query" in options) { + return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`)); + } + + for (const key in options) { + if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue; + return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`)); + } + } + + const parsedOptions = typeof query === "string" ? Object.assign({ + query + }, options) : query; + const requestOptions = Object.keys(parsedOptions).reduce((result, key) => { + if (NON_VARIABLE_OPTIONS.includes(key)) { + result[key] = parsedOptions[key]; + return result; + } + + if (!result.variables) { + result.variables = {}; + } + + result.variables[key] = parsedOptions[key]; + return result; + }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix + // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451 + + const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl; + + if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) { + requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql"); + } + + return request(requestOptions).then(response => { + if (response.data.errors) { + const headers = {}; + + for (const key of Object.keys(response.headers)) { + headers[key] = response.headers[key]; + } + + throw new GraphqlError(requestOptions, { + headers, + data: response.data + }); + } + + return response.data.data; + }); +} + +function withDefaults(request$1, newDefaults) { + const newRequest = request$1.defaults(newDefaults); + + const newApi = (query, options) => { + return graphql(newRequest, query, options); + }; + + return Object.assign(newApi, { + defaults: withDefaults.bind(null, newRequest), + endpoint: request.request.endpoint + }); +} + +const graphql$1 = withDefaults(request.request, { + headers: { + "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}` + }, + method: "POST", + url: "/graphql" +}); +function withCustomRequest(customRequest) { + return withDefaults(customRequest, { + method: "POST", + url: "/graphql" + }); +} + +exports.graphql = graphql$1; +exports.withCustomRequest = withCustomRequest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 4193: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const VERSION = "2.7.0"; + +/** + * Some ā€œlistā€ response that can be paginated have a different response structure + * + * They have a `total_count` key in the response (search also has `incomplete_results`, + * /installation/repositories also has `repository_selection`), as well as a key with + * the list of the items which name varies from endpoint to endpoint. + * + * Octokit normalizes these responses so that paginated results are always returned following + * the same structure. One challenge is that if the list response has only one page, no Link + * header is provided, so this header alone is not sufficient to check wether a response is + * paginated or not. + * + * We check if a "total_count" key is present in the response data, but also make sure that + * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would + * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref + */ +function normalizePaginatedListResponse(response) { + const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data); + if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way + // to retrieve the same information. + + const incompleteResults = response.data.incomplete_results; + const repositorySelection = response.data.repository_selection; + const totalCount = response.data.total_count; + delete response.data.incomplete_results; + delete response.data.repository_selection; + delete response.data.total_count; + const namespaceKey = Object.keys(response.data)[0]; + const data = response.data[namespaceKey]; + response.data = data; + + if (typeof incompleteResults !== "undefined") { + response.data.incomplete_results = incompleteResults; + } + + if (typeof repositorySelection !== "undefined") { + response.data.repository_selection = repositorySelection; + } + + response.data.total_count = totalCount; + return response; +} + +function iterator(octokit, route, parameters) { + const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters); + const requestMethod = typeof route === "function" ? route : octokit.request; + const method = options.method; + const headers = options.headers; + let url = options.url; + return { + [Symbol.asyncIterator]: () => ({ + async next() { + if (!url) return { + done: true + }; + const response = await requestMethod({ + method, + url, + headers + }); + const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format: + // '; rel="next", ; rel="last"' + // sets `url` to undefined if "next" URL is not present or `link` header is not set + + url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1]; + return { + value: normalizedResponse + }; + } + + }) + }; +} + +function paginate(octokit, route, parameters, mapFn) { + if (typeof parameters === "function") { + mapFn = parameters; + parameters = undefined; + } + + return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn); +} + +function gather(octokit, results, iterator, mapFn) { + return iterator.next().then(result => { + if (result.done) { + return results; + } + + let earlyExit = false; + + function done() { + earlyExit = true; + } + + results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data); + + if (earlyExit) { + return results; + } + + return gather(octokit, results, iterator, mapFn); + }); +} + +const composePaginateRest = Object.assign(paginate, { + iterator +}); + +/** + * @param octokit Octokit instance + * @param options Options passed to Octokit constructor + */ + +function paginateRest(octokit) { + return { + paginate: Object.assign(paginate.bind(null, octokit), { + iterator: iterator.bind(null, octokit) + }) + }; +} +paginateRest.VERSION = VERSION; + +exports.composePaginateRest = composePaginateRest; +exports.paginateRest = paginateRest; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 3044: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +const Endpoints = { + actions: { + addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"], + createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"], + createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"], + createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"], + createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"], + createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"], + createWorkflowDispatch: ["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"], + deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"], + deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"], + deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"], + deleteWorkflowRun: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"], + deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + disableSelectedRepositoryGithubActionsOrganization: ["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"], + disableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"], + downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"], + downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"], + downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"], + enableSelectedRepositoryGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"], + enableWorkflow: ["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"], + getAllowedActionsOrganization: ["GET /orgs/{org}/actions/permissions/selected-actions"], + getAllowedActionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"], + getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"], + getGithubActionsPermissionsOrganization: ["GET /orgs/{org}/actions/permissions"], + getGithubActionsPermissionsRepository: ["GET /repos/{owner}/{repo}/actions/permissions"], + getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"], + getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"], + getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"], + getRepoPermissions: ["GET /repos/{owner}/{repo}/actions/permissions", {}, { + renamed: ["actions", "getGithubActionsPermissionsRepository"] + }], + getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"], + getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"], + getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"], + getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"], + getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"], + getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"], + getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"], + getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"], + listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"], + listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"], + listOrgSecrets: ["GET /orgs/{org}/actions/secrets"], + listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"], + listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"], + listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"], + listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"], + listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"], + listSelectedRepositoriesEnabledGithubActionsOrganization: ["GET /orgs/{org}/actions/permissions/repositories"], + listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"], + listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"], + listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"], + listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"], + listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"], + reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"], + removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"], + setAllowedActionsOrganization: ["PUT /orgs/{org}/actions/permissions/selected-actions"], + setAllowedActionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"], + setGithubActionsPermissionsOrganization: ["PUT /orgs/{org}/actions/permissions"], + setGithubActionsPermissionsRepository: ["PUT /repos/{owner}/{repo}/actions/permissions"], + setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"], + setSelectedRepositoriesEnabledGithubActionsOrganization: ["PUT /orgs/{org}/actions/permissions/repositories"] + }, + activity: { + checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"], + deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"], + deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"], + getFeeds: ["GET /feeds"], + getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"], + getThread: ["GET /notifications/threads/{thread_id}"], + getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"], + listEventsForAuthenticatedUser: ["GET /users/{username}/events"], + listNotificationsForAuthenticatedUser: ["GET /notifications"], + listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"], + listPublicEvents: ["GET /events"], + listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"], + listPublicEventsForUser: ["GET /users/{username}/events/public"], + listPublicOrgEvents: ["GET /orgs/{org}/events"], + listReceivedEventsForUser: ["GET /users/{username}/received_events"], + listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"], + listRepoEvents: ["GET /repos/{owner}/{repo}/events"], + listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"], + listReposStarredByAuthenticatedUser: ["GET /user/starred"], + listReposStarredByUser: ["GET /users/{username}/starred"], + listReposWatchedByUser: ["GET /users/{username}/subscriptions"], + listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"], + listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"], + listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"], + markNotificationsAsRead: ["PUT /notifications"], + markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"], + markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"], + setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"], + setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"], + starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"], + unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"] + }, + apps: { + addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}"], + checkToken: ["POST /applications/{client_id}/token"], + createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", { + mediaType: { + previews: ["corsair"] + } + }], + createFromManifest: ["POST /app-manifests/{code}/conversions"], + createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens"], + deleteAuthorization: ["DELETE /applications/{client_id}/grant"], + deleteInstallation: ["DELETE /app/installations/{installation_id}"], + deleteToken: ["DELETE /applications/{client_id}/token"], + getAuthenticated: ["GET /app"], + getBySlug: ["GET /apps/{app_slug}"], + getInstallation: ["GET /app/installations/{installation_id}"], + getOrgInstallation: ["GET /orgs/{org}/installation"], + getRepoInstallation: ["GET /repos/{owner}/{repo}/installation"], + getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"], + getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"], + getUserInstallation: ["GET /users/{username}/installation"], + getWebhookConfigForApp: ["GET /app/hook/config"], + listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"], + listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"], + listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories"], + listInstallations: ["GET /app/installations"], + listInstallationsForAuthenticatedUser: ["GET /user/installations"], + listPlans: ["GET /marketplace_listing/plans"], + listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"], + listReposAccessibleToInstallation: ["GET /installation/repositories"], + listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"], + listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"], + removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}"], + resetToken: ["PATCH /applications/{client_id}/token"], + revokeInstallationAccessToken: ["DELETE /installation/token"], + suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"], + unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"], + updateWebhookConfigForApp: ["PATCH /app/hook/config"] + }, + billing: { + getGithubActionsBillingOrg: ["GET /orgs/{org}/settings/billing/actions"], + getGithubActionsBillingUser: ["GET /users/{username}/settings/billing/actions"], + getGithubPackagesBillingOrg: ["GET /orgs/{org}/settings/billing/packages"], + getGithubPackagesBillingUser: ["GET /users/{username}/settings/billing/packages"], + getSharedStorageBillingOrg: ["GET /orgs/{org}/settings/billing/shared-storage"], + getSharedStorageBillingUser: ["GET /users/{username}/settings/billing/shared-storage"] + }, + checks: { + create: ["POST /repos/{owner}/{repo}/check-runs"], + createSuite: ["POST /repos/{owner}/{repo}/check-suites"], + get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"], + getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"], + listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"], + listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"], + listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"], + listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"], + rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"], + setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences"], + update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"] + }, + codeScanning: { + getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}", {}, { + renamedParameters: { + alert_id: "alert_number" + } + }], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"], + listRecentAnalyses: ["GET /repos/{owner}/{repo}/code-scanning/analyses"], + updateAlert: ["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"], + uploadSarif: ["POST /repos/{owner}/{repo}/code-scanning/sarifs"] + }, + codesOfConduct: { + getAllCodesOfConduct: ["GET /codes_of_conduct", { + mediaType: { + previews: ["scarlet-witch"] + } + }], + getConductCode: ["GET /codes_of_conduct/{key}", { + mediaType: { + previews: ["scarlet-witch"] + } + }], + getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", { + mediaType: { + previews: ["scarlet-witch"] + } + }] + }, + emojis: { + get: ["GET /emojis"] + }, + enterpriseAdmin: { + disableSelectedOrganizationGithubActionsEnterprise: ["DELETE /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"], + enableSelectedOrganizationGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}"], + getAllowedActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/selected-actions"], + getGithubActionsPermissionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions"], + listSelectedOrganizationsEnabledGithubActionsEnterprise: ["GET /enterprises/{enterprise}/actions/permissions/organizations"], + setAllowedActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/selected-actions"], + setGithubActionsPermissionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions"], + setSelectedOrganizationsEnabledGithubActionsEnterprise: ["PUT /enterprises/{enterprise}/actions/permissions/organizations"] + }, + gists: { + checkIsStarred: ["GET /gists/{gist_id}/star"], + create: ["POST /gists"], + createComment: ["POST /gists/{gist_id}/comments"], + delete: ["DELETE /gists/{gist_id}"], + deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"], + fork: ["POST /gists/{gist_id}/forks"], + get: ["GET /gists/{gist_id}"], + getComment: ["GET /gists/{gist_id}/comments/{comment_id}"], + getRevision: ["GET /gists/{gist_id}/{sha}"], + list: ["GET /gists"], + listComments: ["GET /gists/{gist_id}/comments"], + listCommits: ["GET /gists/{gist_id}/commits"], + listForUser: ["GET /users/{username}/gists"], + listForks: ["GET /gists/{gist_id}/forks"], + listPublic: ["GET /gists/public"], + listStarred: ["GET /gists/starred"], + star: ["PUT /gists/{gist_id}/star"], + unstar: ["DELETE /gists/{gist_id}/star"], + update: ["PATCH /gists/{gist_id}"], + updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"] + }, + git: { + createBlob: ["POST /repos/{owner}/{repo}/git/blobs"], + createCommit: ["POST /repos/{owner}/{repo}/git/commits"], + createRef: ["POST /repos/{owner}/{repo}/git/refs"], + createTag: ["POST /repos/{owner}/{repo}/git/tags"], + createTree: ["POST /repos/{owner}/{repo}/git/trees"], + deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"], + getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"], + getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"], + getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"], + getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"], + getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"], + listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"], + updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"] + }, + gitignore: { + getAllTemplates: ["GET /gitignore/templates"], + getTemplate: ["GET /gitignore/templates/{name}"] + }, + interactions: { + getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits"], + getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits"], + getRestrictionsForYourPublicRepos: ["GET /user/interaction-limits"], + removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits"], + removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits"], + removeRestrictionsForYourPublicRepos: ["DELETE /user/interaction-limits"], + setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits"], + setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits"], + setRestrictionsForYourPublicRepos: ["PUT /user/interaction-limits"] + }, + issues: { + addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"], + checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"], + create: ["POST /repos/{owner}/{repo}/issues"], + createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"], + createLabel: ["POST /repos/{owner}/{repo}/labels"], + createMilestone: ["POST /repos/{owner}/{repo}/milestones"], + deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"], + deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"], + deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"], + get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"], + getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"], + getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"], + getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"], + getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"], + list: ["GET /issues"], + listAssignees: ["GET /repos/{owner}/{repo}/assignees"], + listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"], + listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"], + listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"], + listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"], + listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", { + mediaType: { + previews: ["mockingbird"] + } + }], + listForAuthenticatedUser: ["GET /user/issues"], + listForOrg: ["GET /orgs/{org}/issues"], + listForRepo: ["GET /repos/{owner}/{repo}/issues"], + listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"], + listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"], + listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"], + listMilestones: ["GET /repos/{owner}/{repo}/milestones"], + lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"], + removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"], + removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"], + removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"], + setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"], + unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"], + update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"], + updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"], + updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"], + updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"] + }, + licenses: { + get: ["GET /licenses/{license}"], + getAllCommonlyUsed: ["GET /licenses"], + getForRepo: ["GET /repos/{owner}/{repo}/license"] + }, + markdown: { + render: ["POST /markdown"], + renderRaw: ["POST /markdown/raw", { + headers: { + "content-type": "text/plain; charset=utf-8" + } + }] + }, + meta: { + get: ["GET /meta"], + getOctocat: ["GET /octocat"], + getZen: ["GET /zen"], + root: ["GET /"] + }, + migrations: { + cancelImport: ["DELETE /repos/{owner}/{repo}/import"], + deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", { + mediaType: { + previews: ["wyandotte"] + } + }], + getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"], + getImportStatus: ["GET /repos/{owner}/{repo}/import"], + getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"], + getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", { + mediaType: { + previews: ["wyandotte"] + } + }], + getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", { + mediaType: { + previews: ["wyandotte"] + } + }], + listForAuthenticatedUser: ["GET /user/migrations", { + mediaType: { + previews: ["wyandotte"] + } + }], + listForOrg: ["GET /orgs/{org}/migrations", { + mediaType: { + previews: ["wyandotte"] + } + }], + listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", { + mediaType: { + previews: ["wyandotte"] + } + }], + listReposForUser: ["GET /user/migrations/{migration_id}/repositories", { + mediaType: { + previews: ["wyandotte"] + } + }], + mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"], + setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"], + startForAuthenticatedUser: ["POST /user/migrations"], + startForOrg: ["POST /orgs/{org}/migrations"], + startImport: ["PUT /repos/{owner}/{repo}/import"], + unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", { + mediaType: { + previews: ["wyandotte"] + } + }], + unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", { + mediaType: { + previews: ["wyandotte"] + } + }], + updateImport: ["PATCH /repos/{owner}/{repo}/import"] + }, + orgs: { + blockUser: ["PUT /orgs/{org}/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + checkBlockedUser: ["GET /orgs/{org}/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + checkMembershipForUser: ["GET /orgs/{org}/members/{username}"], + checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"], + convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"], + createInvitation: ["POST /orgs/{org}/invitations"], + createWebhook: ["POST /orgs/{org}/hooks"], + deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"], + get: ["GET /orgs/{org}"], + getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"], + getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"], + getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"], + getWebhookConfigForOrg: ["GET /orgs/{org}/hooks/{hook_id}/config"], + list: ["GET /organizations"], + listAppInstallations: ["GET /orgs/{org}/installations"], + listBlockedUsers: ["GET /orgs/{org}/blocks", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + listForAuthenticatedUser: ["GET /user/orgs"], + listForUser: ["GET /users/{username}/orgs"], + listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"], + listMembers: ["GET /orgs/{org}/members"], + listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"], + listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"], + listPendingInvitations: ["GET /orgs/{org}/invitations"], + listPublicMembers: ["GET /orgs/{org}/public_members"], + listWebhooks: ["GET /orgs/{org}/hooks"], + pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"], + removeMember: ["DELETE /orgs/{org}/members/{username}"], + removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"], + removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"], + removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"], + setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"], + setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"], + unblockUser: ["DELETE /orgs/{org}/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + update: ["PATCH /orgs/{org}"], + updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"], + updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"], + updateWebhookConfigForOrg: ["PATCH /orgs/{org}/hooks/{hook_id}/config"] + }, + projects: { + addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", { + mediaType: { + previews: ["inertia"] + } + }], + createCard: ["POST /projects/columns/{column_id}/cards", { + mediaType: { + previews: ["inertia"] + } + }], + createColumn: ["POST /projects/{project_id}/columns", { + mediaType: { + previews: ["inertia"] + } + }], + createForAuthenticatedUser: ["POST /user/projects", { + mediaType: { + previews: ["inertia"] + } + }], + createForOrg: ["POST /orgs/{org}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + createForRepo: ["POST /repos/{owner}/{repo}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + delete: ["DELETE /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + deleteCard: ["DELETE /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + deleteColumn: ["DELETE /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }], + get: ["GET /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getCard: ["GET /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getColumn: ["GET /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }], + getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", { + mediaType: { + previews: ["inertia"] + } + }], + listCards: ["GET /projects/columns/{column_id}/cards", { + mediaType: { + previews: ["inertia"] + } + }], + listCollaborators: ["GET /projects/{project_id}/collaborators", { + mediaType: { + previews: ["inertia"] + } + }], + listColumns: ["GET /projects/{project_id}/columns", { + mediaType: { + previews: ["inertia"] + } + }], + listForOrg: ["GET /orgs/{org}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listForRepo: ["GET /repos/{owner}/{repo}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listForUser: ["GET /users/{username}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + moveCard: ["POST /projects/columns/cards/{card_id}/moves", { + mediaType: { + previews: ["inertia"] + } + }], + moveColumn: ["POST /projects/columns/{column_id}/moves", { + mediaType: { + previews: ["inertia"] + } + }], + removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", { + mediaType: { + previews: ["inertia"] + } + }], + update: ["PATCH /projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + updateCard: ["PATCH /projects/columns/cards/{card_id}", { + mediaType: { + previews: ["inertia"] + } + }], + updateColumn: ["PATCH /projects/columns/{column_id}", { + mediaType: { + previews: ["inertia"] + } + }] + }, + pulls: { + checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + create: ["POST /repos/{owner}/{repo}/pulls"], + createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"], + createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"], + get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"], + getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"], + list: ["GET /repos/{owner}/{repo}/pulls"], + listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"], + listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"], + listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"], + listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"], + listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"], + listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"], + merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"], + removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"], + submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"], + update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"], + updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", { + mediaType: { + previews: ["lydian"] + } + }], + updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"], + updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"] + }, + rateLimit: { + get: ["GET /rate_limit"] + }, + reactions: { + createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + deleteLegacy: ["DELETE /reactions/{reaction_id}", { + mediaType: { + previews: ["squirrel-girl"] + } + }, { + deprecated: "octokit.reactions.deleteLegacy() is deprecated, see https://docs.github.com/v3/reactions/#delete-a-reaction-legacy" + }], + listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }], + listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", { + mediaType: { + previews: ["squirrel-girl"] + } + }] + }, + repos: { + acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"], + addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"], + addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"], + checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"], + createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { + mediaType: { + previews: ["zzzax"] + } + }], + createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"], + createDeployKey: ["POST /repos/{owner}/{repo}/keys"], + createDeployment: ["POST /repos/{owner}/{repo}/deployments"], + createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"], + createForAuthenticatedUser: ["POST /user/repos"], + createFork: ["POST /repos/{owner}/{repo}/forks"], + createInOrg: ["POST /orgs/{org}/repos"], + createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"], + createPagesSite: ["POST /repos/{owner}/{repo}/pages", { + mediaType: { + previews: ["switcheroo"] + } + }], + createRelease: ["POST /repos/{owner}/{repo}/releases"], + createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", { + mediaType: { + previews: ["baptiste"] + } + }], + createWebhook: ["POST /repos/{owner}/{repo}/hooks"], + declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"], + delete: ["DELETE /repos/{owner}/{repo}"], + deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"], + deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"], + deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { + mediaType: { + previews: ["zzzax"] + } + }], + deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"], + deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"], + deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"], + deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"], + deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages", { + mediaType: { + previews: ["switcheroo"] + } + }], + deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"], + deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"], + deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"], + disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", { + mediaType: { + previews: ["london"] + } + }], + disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + downloadArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}", {}, { + renamed: ["repos", "downloadZipballArchive"] + }], + downloadTarballArchive: ["GET /repos/{owner}/{repo}/tarball/{ref}"], + downloadZipballArchive: ["GET /repos/{owner}/{repo}/zipball/{ref}"], + enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes", { + mediaType: { + previews: ["london"] + } + }], + enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", { + mediaType: { + previews: ["dorian"] + } + }], + get: ["GET /repos/{owner}/{repo}"], + getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"], + getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"], + getAllTopics: ["GET /repos/{owner}/{repo}/topics", { + mediaType: { + previews: ["mercy"] + } + }], + getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"], + getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"], + getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"], + getClones: ["GET /repos/{owner}/{repo}/traffic/clones"], + getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"], + getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"], + getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"], + getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"], + getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"], + getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"], + getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", { + mediaType: { + previews: ["zzzax"] + } + }], + getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"], + getContent: ["GET /repos/{owner}/{repo}/contents/{path}"], + getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"], + getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"], + getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"], + getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"], + getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"], + getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"], + getPages: ["GET /repos/{owner}/{repo}/pages"], + getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"], + getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"], + getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"], + getReadme: ["GET /repos/{owner}/{repo}/readme"], + getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"], + getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"], + getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"], + getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"], + getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"], + getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"], + getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"], + getViews: ["GET /repos/{owner}/{repo}/traffic/views"], + getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"], + getWebhookConfigForRepo: ["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"], + listBranches: ["GET /repos/{owner}/{repo}/branches"], + listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", { + mediaType: { + previews: ["groot"] + } + }], + listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"], + listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"], + listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"], + listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"], + listCommits: ["GET /repos/{owner}/{repo}/commits"], + listContributors: ["GET /repos/{owner}/{repo}/contributors"], + listDeployKeys: ["GET /repos/{owner}/{repo}/keys"], + listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"], + listDeployments: ["GET /repos/{owner}/{repo}/deployments"], + listForAuthenticatedUser: ["GET /user/repos"], + listForOrg: ["GET /orgs/{org}/repos"], + listForUser: ["GET /users/{username}/repos"], + listForks: ["GET /repos/{owner}/{repo}/forks"], + listInvitations: ["GET /repos/{owner}/{repo}/invitations"], + listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"], + listLanguages: ["GET /repos/{owner}/{repo}/languages"], + listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"], + listPublic: ["GET /repositories"], + listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", { + mediaType: { + previews: ["groot"] + } + }], + listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"], + listReleases: ["GET /repos/{owner}/{repo}/releases"], + listTags: ["GET /repos/{owner}/{repo}/tags"], + listTeams: ["GET /repos/{owner}/{repo}/teams"], + listWebhooks: ["GET /repos/{owner}/{repo}/hooks"], + merge: ["POST /repos/{owner}/{repo}/merges"], + pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"], + removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"], + removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics", { + mediaType: { + previews: ["mercy"] + } + }], + requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"], + setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"], + setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, { + mapToData: "apps" + }], + setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, { + mapToData: "contexts" + }], + setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, { + mapToData: "teams" + }], + setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, { + mapToData: "users" + }], + testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"], + transfer: ["POST /repos/{owner}/{repo}/transfer"], + update: ["PATCH /repos/{owner}/{repo}"], + updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"], + updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"], + updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"], + updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"], + updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"], + updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"], + updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"], + updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, { + renamed: ["repos", "updateStatusCheckProtection"] + }], + updateStatusCheckProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"], + updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"], + updateWebhookConfigForRepo: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"], + uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", { + baseUrl: "https://uploads.github.com" + }] + }, + search: { + code: ["GET /search/code"], + commits: ["GET /search/commits", { + mediaType: { + previews: ["cloak"] + } + }], + issuesAndPullRequests: ["GET /search/issues"], + labels: ["GET /search/labels"], + repos: ["GET /search/repositories"], + topics: ["GET /search/topics", { + mediaType: { + previews: ["mercy"] + } + }], + users: ["GET /search/users"] + }, + secretScanning: { + getAlert: ["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"], + listAlertsForRepo: ["GET /repos/{owner}/{repo}/secret-scanning/alerts"], + updateAlert: ["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"] + }, + teams: { + addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"], + addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", { + mediaType: { + previews: ["inertia"] + } + }], + checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + create: ["POST /orgs/{org}/teams"], + createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"], + deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"], + getByName: ["GET /orgs/{org}/teams/{team_slug}"], + getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"], + list: ["GET /orgs/{org}/teams"], + listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"], + listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"], + listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"], + listForAuthenticatedUser: ["GET /user/teams"], + listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"], + listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"], + listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", { + mediaType: { + previews: ["inertia"] + } + }], + listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"], + removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"], + removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"], + removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"], + updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"], + updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"], + updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"] + }, + users: { + addEmailForAuthenticated: ["POST /user/emails"], + block: ["PUT /user/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + checkBlocked: ["GET /user/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + checkFollowingForUser: ["GET /users/{username}/following/{target_user}"], + checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"], + createGpgKeyForAuthenticated: ["POST /user/gpg_keys"], + createPublicSshKeyForAuthenticated: ["POST /user/keys"], + deleteEmailForAuthenticated: ["DELETE /user/emails"], + deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"], + deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}"], + follow: ["PUT /user/following/{username}"], + getAuthenticated: ["GET /user"], + getByUsername: ["GET /users/{username}"], + getContextForUser: ["GET /users/{username}/hovercard"], + getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}"], + getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"], + list: ["GET /users"], + listBlockedByAuthenticated: ["GET /user/blocks", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + listEmailsForAuthenticated: ["GET /user/emails"], + listFollowedByAuthenticated: ["GET /user/following"], + listFollowersForAuthenticatedUser: ["GET /user/followers"], + listFollowersForUser: ["GET /users/{username}/followers"], + listFollowingForUser: ["GET /users/{username}/following"], + listGpgKeysForAuthenticated: ["GET /user/gpg_keys"], + listGpgKeysForUser: ["GET /users/{username}/gpg_keys"], + listPublicEmailsForAuthenticated: ["GET /user/public_emails"], + listPublicKeysForUser: ["GET /users/{username}/keys"], + listPublicSshKeysForAuthenticated: ["GET /user/keys"], + setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"], + unblock: ["DELETE /user/blocks/{username}", { + mediaType: { + previews: ["giant-sentry-fist"] + } + }], + unfollow: ["DELETE /user/following/{username}"], + updateAuthenticated: ["PATCH /user"] + } +}; + +const VERSION = "4.4.3"; + +function endpointsToMethods(octokit, endpointsMap) { + const newMethods = {}; + + for (const [scope, endpoints] of Object.entries(endpointsMap)) { + for (const [methodName, endpoint] of Object.entries(endpoints)) { + const [route, defaults, decorations] = endpoint; + const [method, url] = route.split(/ /); + const endpointDefaults = Object.assign({ + method, + url + }, defaults); + + if (!newMethods[scope]) { + newMethods[scope] = {}; + } + + const scopeMethods = newMethods[scope]; + + if (decorations) { + scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations); + continue; + } + + scopeMethods[methodName] = octokit.request.defaults(endpointDefaults); + } + } + + return newMethods; +} + +function decorate(octokit, scope, methodName, defaults, decorations) { + const requestWithDefaults = octokit.request.defaults(defaults); + /* istanbul ignore next */ + + function withDecorations(...args) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData` + + if (decorations.mapToData) { + options = Object.assign({}, options, { + data: options[decorations.mapToData], + [decorations.mapToData]: undefined + }); + return requestWithDefaults(options); + } + + if (decorations.renamed) { + const [newScope, newMethodName] = decorations.renamed; + octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`); + } + + if (decorations.deprecated) { + octokit.log.warn(decorations.deprecated); + } + + if (decorations.renamedParameters) { + // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + const options = requestWithDefaults.endpoint.merge(...args); + + for (const [name, alias] of Object.entries(decorations.renamedParameters)) { + if (name in options) { + octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`); + + if (!(alias in options)) { + options[alias] = options[name]; + } + + delete options[name]; + } + } + + return requestWithDefaults(options); + } // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488 + + + return requestWithDefaults(...args); + } + + return Object.assign(withDecorations, requestWithDefaults); +} + +/** + * This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary + * goal is to rebuild @octokit/rest on top of @octokit/core. Once that is + * done, we will remove the registerEndpoints methods and return the methods + * directly as with the other plugins. At that point we will also remove the + * legacy workarounds and deprecations. + * + * See the plan at + * https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1 + */ + +function restEndpointMethods(octokit) { + return endpointsToMethods(octokit, Endpoints); +} +restEndpointMethods.VERSION = VERSION; + +exports.restEndpointMethods = restEndpointMethods; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 537: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var deprecation = __nccwpck_require__(8932); +var once = _interopDefault(__nccwpck_require__(1223)); + +const logOnce = once(deprecation => console.warn(deprecation)); +/** + * Error with extra properties to help with debugging + */ + +class RequestError extends Error { + constructor(message, statusCode, options) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = "HttpError"; + this.status = statusCode; + Object.defineProperty(this, "code", { + get() { + logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`.")); + return statusCode; + } + + }); + this.headers = options.headers || {}; // redact request credentials without mutating original request options + + const requestCopy = Object.assign({}, options.request); + + if (options.request.headers.authorization) { + requestCopy.headers = Object.assign({}, options.request.headers, { + authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]") + }); + } + + requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit + // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications + .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended + // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header + .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]"); + this.request = requestCopy; + } + +} + +exports.RequestError = RequestError; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 6234: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var endpoint = __nccwpck_require__(9440); +var universalUserAgent = __nccwpck_require__(5030); +var isPlainObject = __nccwpck_require__(9062); +var nodeFetch = _interopDefault(__nccwpck_require__(467)); +var requestError = __nccwpck_require__(537); + +const VERSION = "5.4.14"; + +function getBufferResponse(response) { + return response.arrayBuffer(); +} + +function fetchWrapper(requestOptions) { + if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { + requestOptions.body = JSON.stringify(requestOptions.body); + } + + let headers = {}; + let status; + let url; + const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch; + return fetch(requestOptions.url, Object.assign({ + method: requestOptions.method, + body: requestOptions.body, + headers: requestOptions.headers, + redirect: requestOptions.redirect + }, requestOptions.request)).then(response => { + url = response.url; + status = response.status; + + for (const keyAndValue of response.headers) { + headers[keyAndValue[0]] = keyAndValue[1]; + } + + if (status === 204 || status === 205) { + return; + } // GitHub API returns 200 for HEAD requests + + + if (requestOptions.method === "HEAD") { + if (status < 400) { + return; + } + + throw new requestError.RequestError(response.statusText, status, { + headers, + request: requestOptions + }); + } + + if (status === 304) { + throw new requestError.RequestError("Not modified", status, { + headers, + request: requestOptions + }); + } + + if (status >= 400) { + return response.text().then(message => { + const error = new requestError.RequestError(message, status, { + headers, + request: requestOptions + }); + + try { + let responseBody = JSON.parse(error.message); + Object.assign(error, responseBody); + let errors = responseBody.errors; // Assumption `errors` would always be in Array format + + error.message = error.message + ": " + errors.map(JSON.stringify).join(", "); + } catch (e) {// ignore, see octokit/rest.js#684 + } + + throw error; + }); + } + + const contentType = response.headers.get("content-type"); + + if (/application\/json/.test(contentType)) { + return response.json(); + } + + if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { + return response.text(); + } + + return getBufferResponse(response); + }).then(data => { + return { + status, + url, + headers, + data + }; + }).catch(error => { + if (error instanceof requestError.RequestError) { + throw error; + } + + throw new requestError.RequestError(error.message, 500, { + headers, + request: requestOptions + }); + }); +} + +function withDefaults(oldEndpoint, newDefaults) { + const endpoint = oldEndpoint.defaults(newDefaults); + + const newApi = function (route, parameters) { + const endpointOptions = endpoint.merge(route, parameters); + + if (!endpointOptions.request || !endpointOptions.request.hook) { + return fetchWrapper(endpoint.parse(endpointOptions)); + } + + const request = (route, parameters) => { + return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters))); + }; + + Object.assign(request, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); + return endpointOptions.request.hook(request, endpointOptions); + }; + + return Object.assign(newApi, { + endpoint, + defaults: withDefaults.bind(null, endpoint) + }); +} + +const request = withDefaults(endpoint.endpoint, { + headers: { + "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}` + } +}); + +exports.request = request; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 9062: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +/*! + * is-plain-object + * + * Copyright (c) 2014-2017, Jon Schlinkert. + * Released under the MIT License. + */ + +function isObject(o) { + return Object.prototype.toString.call(o) === '[object Object]'; +} + +function isPlainObject(o) { + var ctor,prot; + + if (isObject(o) === false) return false; + + // If has modified constructor + ctor = o.constructor; + if (ctor === undefined) return true; + + // If has modified prototype + prot = ctor.prototype; + if (isObject(prot) === false) return false; + + // If constructor does not have an Object-specific method + if (prot.hasOwnProperty('isPrototypeOf') === false) { + return false; + } + + // Most likely a plain Object + return true; +} + +exports.isPlainObject = isPlainObject; + + +/***/ }), + +/***/ 3682: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var register = __nccwpck_require__(4670) +var addHook = __nccwpck_require__(5549) +var removeHook = __nccwpck_require__(6819) + +// bind with array of arguments: https://stackoverflow.com/a/21792913 +var bind = Function.bind +var bindable = bind.bind(bind) + +function bindApi (hook, state, name) { + var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state]) + hook.api = { remove: removeHookRef } + hook.remove = removeHookRef + + ;['before', 'error', 'after', 'wrap'].forEach(function (kind) { + var args = name ? [state, kind, name] : [state, kind] + hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args) + }) +} + +function HookSingular () { + var singularHookName = 'h' + var singularHookState = { + registry: {} + } + var singularHook = register.bind(null, singularHookState, singularHookName) + bindApi(singularHook, singularHookState, singularHookName) + return singularHook +} + +function HookCollection () { + var state = { + registry: {} + } + + var hook = register.bind(null, state) + bindApi(hook, state) + + return hook +} + +var collectionHookDeprecationMessageDisplayed = false +function Hook () { + if (!collectionHookDeprecationMessageDisplayed) { + console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4') + collectionHookDeprecationMessageDisplayed = true + } + return HookCollection() +} + +Hook.Singular = HookSingular.bind() +Hook.Collection = HookCollection.bind() + +module.exports = Hook +// expose constructors as a named property for TypeScript +module.exports.Hook = Hook +module.exports.Singular = Hook.Singular +module.exports.Collection = Hook.Collection + + +/***/ }), + +/***/ 5549: +/***/ ((module) => { + +module.exports = addHook; + +function addHook(state, kind, name, hook) { + var orig = hook; + if (!state.registry[name]) { + state.registry[name] = []; + } + + if (kind === "before") { + hook = function (method, options) { + return Promise.resolve() + .then(orig.bind(null, options)) + .then(method.bind(null, options)); + }; + } + + if (kind === "after") { + hook = function (method, options) { + var result; + return Promise.resolve() + .then(method.bind(null, options)) + .then(function (result_) { + result = result_; + return orig(result, options); + }) + .then(function () { + return result; + }); + }; + } + + if (kind === "error") { + hook = function (method, options) { + return Promise.resolve() + .then(method.bind(null, options)) + .catch(function (error) { + return orig(error, options); + }); + }; + } + + state.registry[name].push({ + hook: hook, + orig: orig, + }); +} + + +/***/ }), + +/***/ 4670: +/***/ ((module) => { + +module.exports = register; + +function register(state, name, method, options) { + if (typeof method !== "function") { + throw new Error("method for before hook must be a function"); + } + + if (!options) { + options = {}; + } + + if (Array.isArray(name)) { + return name.reverse().reduce(function (callback, name) { + return register.bind(null, state, name, callback, options); + }, method)(); + } + + return Promise.resolve().then(function () { + if (!state.registry[name]) { + return method(options); + } + + return state.registry[name].reduce(function (method, registered) { + return registered.hook.bind(null, method, options); + }, method)(); + }); +} + + +/***/ }), + +/***/ 6819: +/***/ ((module) => { + +module.exports = removeHook; + +function removeHook(state, name, method) { + if (!state.registry[name]) { + return; + } + + var index = state.registry[name] + .map(function (registered) { + return registered.orig; + }) + .indexOf(method); + + if (index === -1) { + return; + } + + state.registry[name].splice(index, 1); +} + + +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + +/***/ }), + +/***/ 8932: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +class Deprecation extends Error { + constructor(message) { + super(message); // Maintains proper stack trace (only available on V8) + + /* istanbul ignore next */ + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + this.name = 'Deprecation'; + } + +} + +exports.Deprecation = Deprecation; + + +/***/ }), + +/***/ 8685: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var iconvLite = __nccwpck_require__(7813); + +// Expose to the world +module.exports.O = convert; + +/** + * Convert encoding of an UTF-8 string or a buffer + * + * @param {String|Buffer} str String to be converted + * @param {String} to Encoding to be converted to + * @param {String} [from='UTF-8'] Encoding to be converted from + * @return {Buffer} Encoded string + */ +function convert(str, to, from) { + from = checkEncoding(from || 'UTF-8'); + to = checkEncoding(to || 'UTF-8'); + str = str || ''; + + var result; + + if (from !== 'UTF-8' && typeof str === 'string') { + str = Buffer.from(str, 'binary'); + } + + if (from === to) { + if (typeof str === 'string') { + result = Buffer.from(str); + } else { + result = str; + } + } else { + try { + result = convertIconvLite(str, to, from); + } catch (E) { + console.error(E); + result = str; + } + } + + if (typeof result === 'string') { + result = Buffer.from(result, 'utf-8'); + } + + return result; +} + +/** + * Convert encoding of astring with iconv-lite + * + * @param {String|Buffer} str String to be converted + * @param {String} to Encoding to be converted to + * @param {String} [from='UTF-8'] Encoding to be converted from + * @return {Buffer} Encoded string + */ +function convertIconvLite(str, to, from) { + if (to === 'UTF-8') { + return iconvLite.decode(str, from); + } else if (from === 'UTF-8') { + return iconvLite.encode(str, to); + } else { + return iconvLite.encode(iconvLite.decode(str, from), to); + } +} + +/** + * Converts charset name if needed + * + * @param {String} name Character set + * @return {String} Character set name + */ +function checkEncoding(name) { + return (name || '') + .toString() + .trim() + .replace(/^latin[\-_]?(\d+)$/i, 'ISO-8859-$1') + .replace(/^win(?:dows)?[\-_]?(\d+)$/i, 'WINDOWS-$1') + .replace(/^utf[\-_]?(\d+)$/i, 'UTF-$1') + .replace(/^ks_c_5601\-1987$/i, 'CP949') + .replace(/^us[\-_]?ascii$/i, 'ASCII') + .toUpperCase(); +} + + +/***/ }), + +/***/ 8810: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +var Buffer = __nccwpck_require__(5118).Buffer; + +// Multibyte codec. In this scheme, a character is represented by 1 or more bytes. +// Our codec supports UTF-16 surrogates, extensions for GB18030 and unicode sequences. +// To save memory and loading time, we read table files only when requested. + +exports._dbcs = DBCSCodec; + +var UNASSIGNED = -1, + GB18030_CODE = -2, + SEQ_START = -10, + NODE_START = -1000, + UNASSIGNED_NODE = new Array(0x100), + DEF_CHAR = -1; + +for (var i = 0; i < 0x100; i++) + UNASSIGNED_NODE[i] = UNASSIGNED; + + +// Class DBCSCodec reads and initializes mapping tables. +function DBCSCodec(codecOptions, iconv) { + this.encodingName = codecOptions.encodingName; + if (!codecOptions) + throw new Error("DBCS codec is called without the data.") + if (!codecOptions.table) + throw new Error("Encoding '" + this.encodingName + "' has no data."); + + // Load tables. + var mappingTable = codecOptions.table(); + + + // Decode tables: MBCS -> Unicode. + + // decodeTables is a trie, encoded as an array of arrays of integers. Internal arrays are trie nodes and all have len = 256. + // Trie root is decodeTables[0]. + // Values: >= 0 -> unicode character code. can be > 0xFFFF + // == UNASSIGNED -> unknown/unassigned sequence. + // == GB18030_CODE -> this is the end of a GB18030 4-byte sequence. + // <= NODE_START -> index of the next node in our trie to process next byte. + // <= SEQ_START -> index of the start of a character code sequence, in decodeTableSeq. + this.decodeTables = []; + this.decodeTables[0] = UNASSIGNED_NODE.slice(0); // Create root node. + + // Sometimes a MBCS char corresponds to a sequence of unicode chars. We store them as arrays of integers here. + this.decodeTableSeq = []; + + // Actual mapping tables consist of chunks. Use them to fill up decode tables. + for (var i = 0; i < mappingTable.length; i++) + this._addDecodeChunk(mappingTable[i]); + + // Load & create GB18030 tables when needed. + if (typeof codecOptions.gb18030 === 'function') { + this.gb18030 = codecOptions.gb18030(); // Load GB18030 ranges. + + // Add GB18030 common decode nodes. + var commonThirdByteNodeIdx = this.decodeTables.length; + this.decodeTables.push(UNASSIGNED_NODE.slice(0)); + + var commonFourthByteNodeIdx = this.decodeTables.length; + this.decodeTables.push(UNASSIGNED_NODE.slice(0)); + + // Fill out the tree + var firstByteNode = this.decodeTables[0]; + for (var i = 0x81; i <= 0xFE; i++) { + var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i]]; + for (var j = 0x30; j <= 0x39; j++) { + if (secondByteNode[j] === UNASSIGNED) { + secondByteNode[j] = NODE_START - commonThirdByteNodeIdx; + } else if (secondByteNode[j] > NODE_START) { + throw new Error("gb18030 decode tables conflict at byte 2"); + } + + var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]]; + for (var k = 0x81; k <= 0xFE; k++) { + if (thirdByteNode[k] === UNASSIGNED) { + thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx; + } else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) { + continue; + } else if (thirdByteNode[k] > NODE_START) { + throw new Error("gb18030 decode tables conflict at byte 3"); + } + + var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]]; + for (var l = 0x30; l <= 0x39; l++) { + if (fourthByteNode[l] === UNASSIGNED) + fourthByteNode[l] = GB18030_CODE; + } + } + } + } + } + + this.defaultCharUnicode = iconv.defaultCharUnicode; + + + // Encode tables: Unicode -> DBCS. + + // `encodeTable` is array mapping from unicode char to encoded char. All its values are integers for performance. + // Because it can be sparse, it is represented as array of buckets by 256 chars each. Bucket can be null. + // Values: >= 0 -> it is a normal char. Write the value (if <=256 then 1 byte, if <=65536 then 2 bytes, etc.). + // == UNASSIGNED -> no conversion found. Output a default char. + // <= SEQ_START -> it's an index in encodeTableSeq, see below. The character starts a sequence. + this.encodeTable = []; + + // `encodeTableSeq` is used when a sequence of unicode characters is encoded as a single code. We use a tree of + // objects where keys correspond to characters in sequence and leafs are the encoded dbcs values. A special DEF_CHAR key + // means end of sequence (needed when one sequence is a strict subsequence of another). + // Objects are kept separately from encodeTable to increase performance. + this.encodeTableSeq = []; + + // Some chars can be decoded, but need not be encoded. + var skipEncodeChars = {}; + if (codecOptions.encodeSkipVals) + for (var i = 0; i < codecOptions.encodeSkipVals.length; i++) { + var val = codecOptions.encodeSkipVals[i]; + if (typeof val === 'number') + skipEncodeChars[val] = true; + else + for (var j = val.from; j <= val.to; j++) + skipEncodeChars[j] = true; + } + + // Use decode trie to recursively fill out encode tables. + this._fillEncodeTable(0, 0, skipEncodeChars); + + // Add more encoding pairs when needed. + if (codecOptions.encodeAdd) { + for (var uChar in codecOptions.encodeAdd) + if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) + this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]); + } + + this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)]; + if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]['?']; + if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0); +} + +DBCSCodec.prototype.encoder = DBCSEncoder; +DBCSCodec.prototype.decoder = DBCSDecoder; + +// Decoder helpers +DBCSCodec.prototype._getDecodeTrieNode = function(addr) { + var bytes = []; + for (; addr > 0; addr >>>= 8) + bytes.push(addr & 0xFF); + if (bytes.length == 0) + bytes.push(0); + + var node = this.decodeTables[0]; + for (var i = bytes.length-1; i > 0; i--) { // Traverse nodes deeper into the trie. + var val = node[bytes[i]]; + + if (val == UNASSIGNED) { // Create new node. + node[bytes[i]] = NODE_START - this.decodeTables.length; + this.decodeTables.push(node = UNASSIGNED_NODE.slice(0)); + } + else if (val <= NODE_START) { // Existing node. + node = this.decodeTables[NODE_START - val]; + } + else + throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16)); + } + return node; +} + + +DBCSCodec.prototype._addDecodeChunk = function(chunk) { + // First element of chunk is the hex mbcs code where we start. + var curAddr = parseInt(chunk[0], 16); + + // Choose the decoding node where we'll write our chars. + var writeTable = this._getDecodeTrieNode(curAddr); + curAddr = curAddr & 0xFF; + + // Write all other elements of the chunk to the table. + for (var k = 1; k < chunk.length; k++) { + var part = chunk[k]; + if (typeof part === "string") { // String, write as-is. + for (var l = 0; l < part.length;) { + var code = part.charCodeAt(l++); + if (0xD800 <= code && code < 0xDC00) { // Decode surrogate + var codeTrail = part.charCodeAt(l++); + if (0xDC00 <= codeTrail && codeTrail < 0xE000) + writeTable[curAddr++] = 0x10000 + (code - 0xD800) * 0x400 + (codeTrail - 0xDC00); + else + throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]); + } + else if (0x0FF0 < code && code <= 0x0FFF) { // Character sequence (our own encoding used) + var len = 0xFFF - code + 2; + var seq = []; + for (var m = 0; m < len; m++) + seq.push(part.charCodeAt(l++)); // Simple variation: don't support surrogates or subsequences in seq. + + writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length; + this.decodeTableSeq.push(seq); + } + else + writeTable[curAddr++] = code; // Basic char + } + } + else if (typeof part === "number") { // Integer, meaning increasing sequence starting with prev character. + var charCode = writeTable[curAddr - 1] + 1; + for (var l = 0; l < part; l++) + writeTable[curAddr++] = charCode++; + } + else + throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]); + } + if (curAddr > 0xFF) + throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr); +} + +// Encoder helpers +DBCSCodec.prototype._getEncodeBucket = function(uCode) { + var high = uCode >> 8; // This could be > 0xFF because of astral characters. + if (this.encodeTable[high] === undefined) + this.encodeTable[high] = UNASSIGNED_NODE.slice(0); // Create bucket on demand. + return this.encodeTable[high]; +} + +DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) { + var bucket = this._getEncodeBucket(uCode); + var low = uCode & 0xFF; + if (bucket[low] <= SEQ_START) + this.encodeTableSeq[SEQ_START-bucket[low]][DEF_CHAR] = dbcsCode; // There's already a sequence, set a single-char subsequence of it. + else if (bucket[low] == UNASSIGNED) + bucket[low] = dbcsCode; +} + +DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) { + + // Get the root of character tree according to first character of the sequence. + var uCode = seq[0]; + var bucket = this._getEncodeBucket(uCode); + var low = uCode & 0xFF; + + var node; + if (bucket[low] <= SEQ_START) { + // There's already a sequence with - use it. + node = this.encodeTableSeq[SEQ_START-bucket[low]]; + } + else { + // There was no sequence object - allocate a new one. + node = {}; + if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low]; // If a char was set before - make it a single-char subsequence. + bucket[low] = SEQ_START - this.encodeTableSeq.length; + this.encodeTableSeq.push(node); + } + + // Traverse the character tree, allocating new nodes as needed. + for (var j = 1; j < seq.length-1; j++) { + var oldVal = node[uCode]; + if (typeof oldVal === 'object') + node = oldVal; + else { + node = node[uCode] = {} + if (oldVal !== undefined) + node[DEF_CHAR] = oldVal + } + } + + // Set the leaf to given dbcsCode. + uCode = seq[seq.length-1]; + node[uCode] = dbcsCode; +} + +DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) { + var node = this.decodeTables[nodeIdx]; + var hasValues = false; + var subNodeEmpty = {}; + for (var i = 0; i < 0x100; i++) { + var uCode = node[i]; + var mbCode = prefix + i; + if (skipEncodeChars[mbCode]) + continue; + + if (uCode >= 0) { + this._setEncodeChar(uCode, mbCode); + hasValues = true; + } else if (uCode <= NODE_START) { + var subNodeIdx = NODE_START - uCode; + if (!subNodeEmpty[subNodeIdx]) { // Skip empty subtrees (they are too large in gb18030). + var newPrefix = (mbCode << 8) >>> 0; // NOTE: '>>> 0' keeps 32-bit num positive. + if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars)) + hasValues = true; + else + subNodeEmpty[subNodeIdx] = true; + } + } else if (uCode <= SEQ_START) { + this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode); + hasValues = true; + } + } + return hasValues; +} + + + +// == Encoder ================================================================== + +function DBCSEncoder(options, codec) { + // Encoder state + this.leadSurrogate = -1; + this.seqObj = undefined; + + // Static data + this.encodeTable = codec.encodeTable; + this.encodeTableSeq = codec.encodeTableSeq; + this.defaultCharSingleByte = codec.defCharSB; + this.gb18030 = codec.gb18030; +} + +DBCSEncoder.prototype.write = function(str) { + var newBuf = Buffer.alloc(str.length * (this.gb18030 ? 4 : 3)), + leadSurrogate = this.leadSurrogate, + seqObj = this.seqObj, nextChar = -1, + i = 0, j = 0; + + while (true) { + // 0. Get next character. + if (nextChar === -1) { + if (i == str.length) break; + var uCode = str.charCodeAt(i++); + } + else { + var uCode = nextChar; + nextChar = -1; + } + + // 1. Handle surrogates. + if (0xD800 <= uCode && uCode < 0xE000) { // Char is one of surrogates. + if (uCode < 0xDC00) { // We've got lead surrogate. + if (leadSurrogate === -1) { + leadSurrogate = uCode; + continue; + } else { + leadSurrogate = uCode; + // Double lead surrogate found. + uCode = UNASSIGNED; + } + } else { // We've got trail surrogate. + if (leadSurrogate !== -1) { + uCode = 0x10000 + (leadSurrogate - 0xD800) * 0x400 + (uCode - 0xDC00); + leadSurrogate = -1; + } else { + // Incomplete surrogate pair - only trail surrogate found. + uCode = UNASSIGNED; + } + + } + } + else if (leadSurrogate !== -1) { + // Incomplete surrogate pair - only lead surrogate found. + nextChar = uCode; uCode = UNASSIGNED; // Write an error, then current char. + leadSurrogate = -1; + } + + // 2. Convert uCode character. + var dbcsCode = UNASSIGNED; + if (seqObj !== undefined && uCode != UNASSIGNED) { // We are in the middle of the sequence + var resCode = seqObj[uCode]; + if (typeof resCode === 'object') { // Sequence continues. + seqObj = resCode; + continue; + + } else if (typeof resCode == 'number') { // Sequence finished. Write it. + dbcsCode = resCode; + + } else if (resCode == undefined) { // Current character is not part of the sequence. + + // Try default character for this sequence + resCode = seqObj[DEF_CHAR]; + if (resCode !== undefined) { + dbcsCode = resCode; // Found. Write it. + nextChar = uCode; // Current character will be written too in the next iteration. + + } else { + // TODO: What if we have no default? (resCode == undefined) + // Then, we should write first char of the sequence as-is and try the rest recursively. + // Didn't do it for now because no encoding has this situation yet. + // Currently, just skip the sequence and write current char. + } + } + seqObj = undefined; + } + else if (uCode >= 0) { // Regular character + var subtable = this.encodeTable[uCode >> 8]; + if (subtable !== undefined) + dbcsCode = subtable[uCode & 0xFF]; + + if (dbcsCode <= SEQ_START) { // Sequence start + seqObj = this.encodeTableSeq[SEQ_START-dbcsCode]; + continue; + } + + if (dbcsCode == UNASSIGNED && this.gb18030) { + // Use GB18030 algorithm to find character(s) to write. + var idx = findIdx(this.gb18030.uChars, uCode); + if (idx != -1) { + var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]); + newBuf[j++] = 0x81 + Math.floor(dbcsCode / 12600); dbcsCode = dbcsCode % 12600; + newBuf[j++] = 0x30 + Math.floor(dbcsCode / 1260); dbcsCode = dbcsCode % 1260; + newBuf[j++] = 0x81 + Math.floor(dbcsCode / 10); dbcsCode = dbcsCode % 10; + newBuf[j++] = 0x30 + dbcsCode; + continue; + } + } + } + + // 3. Write dbcsCode character. + if (dbcsCode === UNASSIGNED) + dbcsCode = this.defaultCharSingleByte; + + if (dbcsCode < 0x100) { + newBuf[j++] = dbcsCode; + } + else if (dbcsCode < 0x10000) { + newBuf[j++] = dbcsCode >> 8; // high byte + newBuf[j++] = dbcsCode & 0xFF; // low byte + } + else if (dbcsCode < 0x1000000) { + newBuf[j++] = dbcsCode >> 16; + newBuf[j++] = (dbcsCode >> 8) & 0xFF; + newBuf[j++] = dbcsCode & 0xFF; + } else { + newBuf[j++] = dbcsCode >>> 24; + newBuf[j++] = (dbcsCode >>> 16) & 0xFF; + newBuf[j++] = (dbcsCode >>> 8) & 0xFF; + newBuf[j++] = dbcsCode & 0xFF; + } + } + + this.seqObj = seqObj; + this.leadSurrogate = leadSurrogate; + return newBuf.slice(0, j); +} + +DBCSEncoder.prototype.end = function() { + if (this.leadSurrogate === -1 && this.seqObj === undefined) + return; // All clean. Most often case. + + var newBuf = Buffer.alloc(10), j = 0; + + if (this.seqObj) { // We're in the sequence. + var dbcsCode = this.seqObj[DEF_CHAR]; + if (dbcsCode !== undefined) { // Write beginning of the sequence. + if (dbcsCode < 0x100) { + newBuf[j++] = dbcsCode; + } + else { + newBuf[j++] = dbcsCode >> 8; // high byte + newBuf[j++] = dbcsCode & 0xFF; // low byte + } + } else { + // See todo above. + } + this.seqObj = undefined; + } + + if (this.leadSurrogate !== -1) { + // Incomplete surrogate pair - only lead surrogate found. + newBuf[j++] = this.defaultCharSingleByte; + this.leadSurrogate = -1; + } + + return newBuf.slice(0, j); +} + +// Export for testing +DBCSEncoder.prototype.findIdx = findIdx; + + +// == Decoder ================================================================== + +function DBCSDecoder(options, codec) { + // Decoder state + this.nodeIdx = 0; + this.prevBytes = []; + + // Static data + this.decodeTables = codec.decodeTables; + this.decodeTableSeq = codec.decodeTableSeq; + this.defaultCharUnicode = codec.defaultCharUnicode; + this.gb18030 = codec.gb18030; +} + +DBCSDecoder.prototype.write = function(buf) { + var newBuf = Buffer.alloc(buf.length*2), + nodeIdx = this.nodeIdx, + prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, + seqStart = -this.prevBytes.length, // idx of the start of current parsed sequence. + uCode; + + for (var i = 0, j = 0; i < buf.length; i++) { + var curByte = (i >= 0) ? buf[i] : prevBytes[i + prevOffset]; + + // Lookup in current trie node. + var uCode = this.decodeTables[nodeIdx][curByte]; + + if (uCode >= 0) { + // Normal character, just use it. + } + else if (uCode === UNASSIGNED) { // Unknown char. + // TODO: Callback with seq. + uCode = this.defaultCharUnicode.charCodeAt(0); + i = seqStart; // Skip one byte ('i' will be incremented by the for loop) and try to parse again. + } + else if (uCode === GB18030_CODE) { + if (i >= 3) { + var ptr = (buf[i-3]-0x81)*12600 + (buf[i-2]-0x30)*1260 + (buf[i-1]-0x81)*10 + (curByte-0x30); + } else { + var ptr = (prevBytes[i-3+prevOffset]-0x81)*12600 + + (((i-2 >= 0) ? buf[i-2] : prevBytes[i-2+prevOffset])-0x30)*1260 + + (((i-1 >= 0) ? buf[i-1] : prevBytes[i-1+prevOffset])-0x81)*10 + + (curByte-0x30); + } + var idx = findIdx(this.gb18030.gbChars, ptr); + uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx]; + } + else if (uCode <= NODE_START) { // Go to next trie node. + nodeIdx = NODE_START - uCode; + continue; + } + else if (uCode <= SEQ_START) { // Output a sequence of chars. + var seq = this.decodeTableSeq[SEQ_START - uCode]; + for (var k = 0; k < seq.length - 1; k++) { + uCode = seq[k]; + newBuf[j++] = uCode & 0xFF; + newBuf[j++] = uCode >> 8; + } + uCode = seq[seq.length-1]; + } + else + throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte); + + // Write the character to buffer, handling higher planes using surrogate pair. + if (uCode >= 0x10000) { + uCode -= 0x10000; + var uCodeLead = 0xD800 | (uCode >> 10); + newBuf[j++] = uCodeLead & 0xFF; + newBuf[j++] = uCodeLead >> 8; + + uCode = 0xDC00 | (uCode & 0x3FF); + } + newBuf[j++] = uCode & 0xFF; + newBuf[j++] = uCode >> 8; + + // Reset trie node. + nodeIdx = 0; seqStart = i+1; + } + + this.nodeIdx = nodeIdx; + this.prevBytes = (seqStart >= 0) + ? Array.prototype.slice.call(buf, seqStart) + : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf)); + + return newBuf.slice(0, j).toString('ucs2'); +} + +DBCSDecoder.prototype.end = function() { + var ret = ''; + + // Try to parse all remaining chars. + while (this.prevBytes.length > 0) { + // Skip 1 character in the buffer. + ret += this.defaultCharUnicode; + var bytesArr = this.prevBytes.slice(1); + + // Parse remaining as usual. + this.prevBytes = []; + this.nodeIdx = 0; + if (bytesArr.length > 0) + ret += this.write(bytesArr); + } + + this.prevBytes = []; + this.nodeIdx = 0; + return ret; +} + +// Binary search for GB18030. Returns largest i such that table[i] <= val. +function findIdx(table, val) { + if (table[0] > val) + return -1; + + var l = 0, r = table.length; + while (l < r-1) { // always table[l] <= val < table[r] + var mid = l + ((r-l+1) >> 1); + if (table[mid] <= val) + l = mid; + else + r = mid; + } + return l; +} + + + +/***/ }), + +/***/ 6: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +// Description of supported double byte encodings and aliases. +// Tables are not require()-d until they are needed to speed up library load. +// require()-s are direct to support Browserify. + +module.exports = { + + // == Japanese/ShiftJIS ==================================================== + // All japanese encodings are based on JIS X set of standards: + // JIS X 0201 - Single-byte encoding of ASCII + Ā„ + Kana chars at 0xA1-0xDF. + // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. + // Has several variations in 1978, 1983, 1990 and 1997. + // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead. + // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233. + // 2 planes, first is superset of 0208, second - revised 0212. + // Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx) + + // Byte encodings are: + // * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte + // encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC. + // Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI. + // * EUC-JP: Up to 3 bytes per character. Used mostly on *nixes. + // 0x00-0x7F - lower part of 0201 + // 0x8E, 0xA1-0xDF - upper part of 0201 + // (0xA1-0xFE)x2 - 0208 plane (94x94). + // 0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94). + // * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon. + // Used as-is in ISO2022 family. + // * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, + // 0201-1976 Roman, 0208-1978, 0208-1983. + // * ISO2022-JP-1: Adds esc seq for 0212-1990. + // * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7. + // * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2. + // * ISO2022-JP-2004: Adds 0213-2004 Plane 1. + // + // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes. + // + // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html + + 'shiftjis': { + type: '_dbcs', + table: function() { return __nccwpck_require__(7566) }, + encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E}, + encodeSkipVals: [{from: 0xED40, to: 0xF940}], + }, + 'csshiftjis': 'shiftjis', + 'mskanji': 'shiftjis', + 'sjis': 'shiftjis', + 'windows31j': 'shiftjis', + 'ms31j': 'shiftjis', + 'xsjis': 'shiftjis', + 'windows932': 'shiftjis', + 'ms932': 'shiftjis', + '932': 'shiftjis', + 'cp932': 'shiftjis', + + 'eucjp': { + type: '_dbcs', + table: function() { return __nccwpck_require__(4957) }, + encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E}, + }, + + // TODO: KDDI extension to Shift_JIS + // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes. + // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars. + + + // == Chinese/GBK ========================================================== + // http://en.wikipedia.org/wiki/GBK + // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder + + // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936 + 'gb2312': 'cp936', + 'gb231280': 'cp936', + 'gb23121980': 'cp936', + 'csgb2312': 'cp936', + 'csiso58gb231280': 'cp936', + 'euccn': 'cp936', + + // Microsoft's CP936 is a subset and approximation of GBK. + 'windows936': 'cp936', + 'ms936': 'cp936', + '936': 'cp936', + 'cp936': { + type: '_dbcs', + table: function() { return __nccwpck_require__(9040) }, + }, + + // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other. + 'gbk': { + type: '_dbcs', + table: function() { return __nccwpck_require__(9040).concat(__nccwpck_require__(4152)) }, + }, + 'xgbk': 'gbk', + 'isoir58': 'gbk', + + // GB18030 is an algorithmic extension of GBK. + // Main source: https://www.w3.org/TR/encoding/#gbk-encoder + // http://icu-project.org/docs/papers/gb18030.html + // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml + // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0 + 'gb18030': { + type: '_dbcs', + table: function() { return __nccwpck_require__(9040).concat(__nccwpck_require__(4152)) }, + gb18030: function() { return __nccwpck_require__(2297) }, + encodeSkipVals: [0x80], + encodeAdd: {'ā‚¬': 0xA2E3}, + }, + + 'chinese': 'gb18030', + + + // == Korean =============================================================== + // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same. + 'windows949': 'cp949', + 'ms949': 'cp949', + '949': 'cp949', + 'cp949': { + type: '_dbcs', + table: function() { return __nccwpck_require__(1333) }, + }, + + 'cseuckr': 'cp949', + 'csksc56011987': 'cp949', + 'euckr': 'cp949', + 'isoir149': 'cp949', + 'korean': 'cp949', + 'ksc56011987': 'cp949', + 'ksc56011989': 'cp949', + 'ksc5601': 'cp949', + + + // == Big5/Taiwan/Hong Kong ================================================ + // There are lots of tables for Big5 and cp950. Please see the following links for history: + // http://moztw.org/docs/big5/ http://www.haible.de/bruno/charsets/conversion-tables/Big5.html + // Variations, in roughly number of defined chars: + // * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT + // * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/ + // * Big5-2003 (Taiwan standard) almost superset of cp950. + // * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers. + // * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. + // many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years. + // Plus, it has 4 combining sequences. + // Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299 + // because big5-hkscs is the only encoding to include astral characters in non-algorithmic way. + // Implementations are not consistent within browsers; sometimes labeled as just big5. + // MS Internet Explorer switches from big5 to big5-hkscs when a patch applied. + // Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31 + // In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s. + // Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt + // http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt + // + // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder + // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong. + + 'windows950': 'cp950', + 'ms950': 'cp950', + '950': 'cp950', + 'cp950': { + type: '_dbcs', + table: function() { return __nccwpck_require__(7231) }, + }, + + // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus. + 'big5': 'big5hkscs', + 'big5hkscs': { + type: '_dbcs', + table: function() { return __nccwpck_require__(7231).concat(__nccwpck_require__(1254)) }, + encodeSkipVals: [0xa2cc], + }, + + 'cnbig5': 'big5hkscs', + 'csbig5': 'big5hkscs', + 'xxbig5': 'big5hkscs', +}; + + +/***/ }), + +/***/ 9541: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +// Update this array if you add/rename/remove files in this directory. +// We support Browserify by skipping automatic module discovery and requiring modules directly. +var modules = [ + __nccwpck_require__(934), + __nccwpck_require__(4927), + __nccwpck_require__(8787), + __nccwpck_require__(6208), + __nccwpck_require__(4899), + __nccwpck_require__(9320), + __nccwpck_require__(1664), + __nccwpck_require__(8810), + __nccwpck_require__(6), +]; + +// Put all encoding/alias/codec definitions to single object and export it. +for (var i = 0; i < modules.length; i++) { + var module = modules[i]; + for (var enc in module) + if (Object.prototype.hasOwnProperty.call(module, enc)) + exports[enc] = module[enc]; +} + + +/***/ }), + +/***/ 934: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + +var Buffer = __nccwpck_require__(5118).Buffer; + +// Export Node.js internal encodings. + +module.exports = { + // Encodings + utf8: { type: "_internal", bomAware: true}, + cesu8: { type: "_internal", bomAware: true}, + unicode11utf8: "utf8", + + ucs2: { type: "_internal", bomAware: true}, + utf16le: "ucs2", + + binary: { type: "_internal" }, + base64: { type: "_internal" }, + hex: { type: "_internal" }, + + // Codec. + _internal: InternalCodec, +}; + +//------------------------------------------------------------------------------ + +function InternalCodec(codecOptions, iconv) { + this.enc = codecOptions.encodingName; + this.bomAware = codecOptions.bomAware; + + if (this.enc === "base64") + this.encoder = InternalEncoderBase64; + else if (this.enc === "cesu8") { + this.enc = "utf8"; // Use utf8 for decoding. + this.encoder = InternalEncoderCesu8; + + // Add decoder for versions of Node not supporting CESU-8 + if (Buffer.from('eda0bdedb2a9', 'hex').toString() !== 'šŸ’©') { + this.decoder = InternalDecoderCesu8; + this.defaultCharUnicode = iconv.defaultCharUnicode; + } + } +} + +InternalCodec.prototype.encoder = InternalEncoder; +InternalCodec.prototype.decoder = InternalDecoder; + +//------------------------------------------------------------------------------ + +// We use node.js internal decoder. Its signature is the same as ours. +var StringDecoder = __nccwpck_require__(4304).StringDecoder; + +if (!StringDecoder.prototype.end) // Node v0.8 doesn't have this method. + StringDecoder.prototype.end = function() {}; + + +function InternalDecoder(options, codec) { + this.decoder = new StringDecoder(codec.enc); +} + +InternalDecoder.prototype.write = function(buf) { + if (!Buffer.isBuffer(buf)) { + buf = Buffer.from(buf); + } + + return this.decoder.write(buf); +} + +InternalDecoder.prototype.end = function() { + return this.decoder.end(); +} + + +//------------------------------------------------------------------------------ +// Encoder is mostly trivial + +function InternalEncoder(options, codec) { + this.enc = codec.enc; +} + +InternalEncoder.prototype.write = function(str) { + return Buffer.from(str, this.enc); +} + +InternalEncoder.prototype.end = function() { +} + + +//------------------------------------------------------------------------------ +// Except base64 encoder, which must keep its state. + +function InternalEncoderBase64(options, codec) { + this.prevStr = ''; +} + +InternalEncoderBase64.prototype.write = function(str) { + str = this.prevStr + str; + var completeQuads = str.length - (str.length % 4); + this.prevStr = str.slice(completeQuads); + str = str.slice(0, completeQuads); + + return Buffer.from(str, "base64"); +} + +InternalEncoderBase64.prototype.end = function() { + return Buffer.from(this.prevStr, "base64"); +} + + +//------------------------------------------------------------------------------ +// CESU-8 encoder is also special. + +function InternalEncoderCesu8(options, codec) { +} + +InternalEncoderCesu8.prototype.write = function(str) { + var buf = Buffer.alloc(str.length * 3), bufIdx = 0; + for (var i = 0; i < str.length; i++) { + var charCode = str.charCodeAt(i); + // Naive implementation, but it works because CESU-8 is especially easy + // to convert from UTF-16 (which all JS strings are encoded in). + if (charCode < 0x80) + buf[bufIdx++] = charCode; + else if (charCode < 0x800) { + buf[bufIdx++] = 0xC0 + (charCode >>> 6); + buf[bufIdx++] = 0x80 + (charCode & 0x3f); + } + else { // charCode will always be < 0x10000 in javascript. + buf[bufIdx++] = 0xE0 + (charCode >>> 12); + buf[bufIdx++] = 0x80 + ((charCode >>> 6) & 0x3f); + buf[bufIdx++] = 0x80 + (charCode & 0x3f); + } + } + return buf.slice(0, bufIdx); +} + +InternalEncoderCesu8.prototype.end = function() { +} + +//------------------------------------------------------------------------------ +// CESU-8 decoder is not implemented in Node v4.0+ + +function InternalDecoderCesu8(options, codec) { + this.acc = 0; + this.contBytes = 0; + this.accBytes = 0; + this.defaultCharUnicode = codec.defaultCharUnicode; +} + +InternalDecoderCesu8.prototype.write = function(buf) { + var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, + res = ''; + for (var i = 0; i < buf.length; i++) { + var curByte = buf[i]; + if ((curByte & 0xC0) !== 0x80) { // Leading byte + if (contBytes > 0) { // Previous code is invalid + res += this.defaultCharUnicode; + contBytes = 0; + } + + if (curByte < 0x80) { // Single-byte code + res += String.fromCharCode(curByte); + } else if (curByte < 0xE0) { // Two-byte code + acc = curByte & 0x1F; + contBytes = 1; accBytes = 1; + } else if (curByte < 0xF0) { // Three-byte code + acc = curByte & 0x0F; + contBytes = 2; accBytes = 1; + } else { // Four or more are not supported for CESU-8. + res += this.defaultCharUnicode; + } + } else { // Continuation byte + if (contBytes > 0) { // We're waiting for it. + acc = (acc << 6) | (curByte & 0x3f); + contBytes--; accBytes++; + if (contBytes === 0) { + // Check for overlong encoding, but support Modified UTF-8 (encoding NULL as C0 80) + if (accBytes === 2 && acc < 0x80 && acc > 0) + res += this.defaultCharUnicode; + else if (accBytes === 3 && acc < 0x800) + res += this.defaultCharUnicode; + else + // Actually add character. + res += String.fromCharCode(acc); + } + } else { // Unexpected continuation byte + res += this.defaultCharUnicode; + } + } + } + this.acc = acc; this.contBytes = contBytes; this.accBytes = accBytes; + return res; +} + +InternalDecoderCesu8.prototype.end = function() { + var res = 0; + if (this.contBytes > 0) + res += this.defaultCharUnicode; + return res; +} + + +/***/ }), + +/***/ 4899: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +var Buffer = __nccwpck_require__(5118).Buffer; + +// Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that +// correspond to encoded bytes (if 128 - then lower half is ASCII). + +exports._sbcs = SBCSCodec; +function SBCSCodec(codecOptions, iconv) { + if (!codecOptions) + throw new Error("SBCS codec is called without the data.") + + // Prepare char buffer for decoding. + if (!codecOptions.chars || (codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)) + throw new Error("Encoding '"+codecOptions.type+"' has incorrect 'chars' (must be of len 128 or 256)"); + + if (codecOptions.chars.length === 128) { + var asciiString = ""; + for (var i = 0; i < 128; i++) + asciiString += String.fromCharCode(i); + codecOptions.chars = asciiString + codecOptions.chars; + } + + this.decodeBuf = Buffer.from(codecOptions.chars, 'ucs2'); + + // Encoding buffer. + var encodeBuf = Buffer.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0)); + + for (var i = 0; i < codecOptions.chars.length; i++) + encodeBuf[codecOptions.chars.charCodeAt(i)] = i; + + this.encodeBuf = encodeBuf; +} + +SBCSCodec.prototype.encoder = SBCSEncoder; +SBCSCodec.prototype.decoder = SBCSDecoder; + + +function SBCSEncoder(options, codec) { + this.encodeBuf = codec.encodeBuf; +} + +SBCSEncoder.prototype.write = function(str) { + var buf = Buffer.alloc(str.length); + for (var i = 0; i < str.length; i++) + buf[i] = this.encodeBuf[str.charCodeAt(i)]; + + return buf; +} + +SBCSEncoder.prototype.end = function() { +} + + +function SBCSDecoder(options, codec) { + this.decodeBuf = codec.decodeBuf; +} + +SBCSDecoder.prototype.write = function(buf) { + // Strings are immutable in JS -> we use ucs2 buffer to speed up computations. + var decodeBuf = this.decodeBuf; + var newBuf = Buffer.alloc(buf.length*2); + var idx1 = 0, idx2 = 0; + for (var i = 0; i < buf.length; i++) { + idx1 = buf[i]*2; idx2 = i*2; + newBuf[idx2] = decodeBuf[idx1]; + newBuf[idx2+1] = decodeBuf[idx1+1]; + } + return newBuf.toString('ucs2'); +} + +SBCSDecoder.prototype.end = function() { +} + + +/***/ }), + +/***/ 1664: +/***/ ((module) => { + +"use strict"; + + +// Generated data for sbcs codec. Don't edit manually. Regenerate using generation/gen-sbcs.js script. +module.exports = { + "437": "cp437", + "737": "cp737", + "775": "cp775", + "850": "cp850", + "852": "cp852", + "855": "cp855", + "856": "cp856", + "857": "cp857", + "858": "cp858", + "860": "cp860", + "861": "cp861", + "862": "cp862", + "863": "cp863", + "864": "cp864", + "865": "cp865", + "866": "cp866", + "869": "cp869", + "874": "windows874", + "922": "cp922", + "1046": "cp1046", + "1124": "cp1124", + "1125": "cp1125", + "1129": "cp1129", + "1133": "cp1133", + "1161": "cp1161", + "1162": "cp1162", + "1163": "cp1163", + "1250": "windows1250", + "1251": "windows1251", + "1252": "windows1252", + "1253": "windows1253", + "1254": "windows1254", + "1255": "windows1255", + "1256": "windows1256", + "1257": "windows1257", + "1258": "windows1258", + "28591": "iso88591", + "28592": "iso88592", + "28593": "iso88593", + "28594": "iso88594", + "28595": "iso88595", + "28596": "iso88596", + "28597": "iso88597", + "28598": "iso88598", + "28599": "iso88599", + "28600": "iso885910", + "28601": "iso885911", + "28603": "iso885913", + "28604": "iso885914", + "28605": "iso885915", + "28606": "iso885916", + "windows874": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ļæ½ļæ½ļæ½ā€¦ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½Ā ąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗļæ½ļæ½ļæ½ļæ½ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ą¹Žą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™ą¹šą¹›ļæ½ļæ½ļæ½ļæ½" + }, + "win874": "windows874", + "cp874": "windows874", + "windows1250": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šļæ½ā€žā€¦ā€ ā€”ļæ½ā€°Å ā€¹ÅšÅ¤Å½Å¹ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢Å”ā€ŗśńžÅŗĀ Ė‡Ė˜ÅĀ¤Ä„Ā¦Ā§ĀØĀ©ÅžĀ«Ā¬Ā­Ā®Å»Ā°Ā±Ė›Å‚Ā“ĀµĀ¶Ā·ĀøąşĀ»Ä½ĖÄ¾Å¼Å”ĆĆ‚Ä‚Ć„Ä¹Ä†Ć‡ÄŒĆ‰Ä˜Ć‹ÄšĆĆŽÄŽÄÅƒÅ‡Ć“Ć”ÅĆ–Ć—Å˜Å®ĆšÅ°ĆœĆÅ¢ĆŸÅ•Ć”Ć¢ÄƒĆ¤ÄŗÄ‡Ć§ÄĆ©Ä™Ć«Ä›Ć­Ć®ÄÄ‘Å„ÅˆĆ³Ć“Å‘Ć¶Ć·Å™ÅÆĆŗÅ±Ć¼Ć½Å£Ė™" + }, + "win1250": "windows1250", + "cp1250": "windows1250", + "windows1251": { + "type": "_sbcs", + "chars": "Š‚Šƒā€šŃ“ā€žā€¦ā€ ā€”ā‚¬ā€°Š‰ā€¹ŠŠŠŒŠ‹ŠŃ’ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢Ń™ā€ŗњќћџĀ ŠŽŃžŠˆĀ¤ŅĀ¦Ā§ŠĀ©Š„Ā«Ā¬Ā­Ā®Š‡Ā°Ā±Š†Ń–Ņ‘ĀµĀ¶Ā·Ń‘ā„–Ń”Ā»Ń˜Š…Ń•Ń—ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюя" + }, + "win1251": "windows1251", + "cp1251": "windows1251", + "windows1252": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°Å ā€¹Å’ļæ½Å½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢Å”ā€ŗœļæ½Å¾ÅøĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆĆĆ‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĆĆžĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆĆ°Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Ć¾Ćæ" + }, + "win1252": "windows1252", + "cp1252": "windows1252", + "windows1253": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šĘ’ā€žā€¦ā€ ā€”ļæ½ā€°ļæ½ā€¹ļæ½ļæ½ļæ½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢ļæ½ā€ŗļæ½ļæ½ļæ½ļæ½Ā Ī…Ī†Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ļæ½Ā«Ā¬Ā­Ā®ā€•Ā°Ā±Ā²Ā³Ī„ĀµĀ¶Ā·ĪˆĪ‰ĪŠĀ»ĪŒĀ½ĪŽĪĪĪ‘Ī’Ī“Ī”Ī•Ī–Ī—Ī˜Ī™ĪšĪ›ĪœĪĪžĪŸĪ Ī”ļæ½Ī£Ī¤Ī„Ī¦Ī§ĪØĪ©ĪŖĪ«Ī¬Ī­Ī®ĪÆĪ°Ī±Ī²Ī³Ī“ĪµĪ¶Ī·ĪøĪ¹ĪŗĪ»Ī¼Ī½Ī¾ĪæĻ€ĻĻ‚ĻƒĻ„Ļ…Ļ†Ļ‡ĻˆĻ‰ĻŠĻ‹ĻŒĻĻŽļæ½" + }, + "win1253": "windows1253", + "cp1253": "windows1253", + "windows1254": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°Å ā€¹Å’ļæ½ļæ½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢Å”ā€ŗœļæ½ļæ½ÅøĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆÄžĆ‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœÄ°ÅžĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆÄŸĆ±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ä±ÅŸĆæ" + }, + "win1254": "windows1254", + "cp1254": "windows1254", + "windows1255": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°ļæ½ā€¹ļæ½ļæ½ļæ½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢ļæ½ā€ŗļæ½ļæ½ļæ½ļæ½Ā Ā”Ā¢Ā£ā‚ŖĀ„Ā¦Ā§ĀØĀ©Ć—Ā«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹Ć·Ā»Ā¼Ā½Ā¾ĀæÖ°Ö±Ö²Ö³Ö“ÖµÖ¶Ö·ÖøÖ¹ÖŗÖ»Ö¼Ö½Ö¾Öæ׀ׁׂ׃װױײ׳דļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½××‘גדהוזחטיךכלםמןנהעףפׄצק×Øש×Ŗļæ½ļæ½ā€Žā€ļæ½" + }, + "win1255": "windows1255", + "cp1255": "windows1255", + "windows1256": { + "type": "_sbcs", + "chars": "ā‚¬Ł¾ā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°Ł¹ā€¹Å’Ś†Ś˜ŚˆŚÆā€˜ā€™ā€œā€ā€¢ā€“ā€”Ś©ā„¢Ś‘ā€ŗœā€Œā€ŚŗĀ ŲŒĀ¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©Ś¾Ā«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹Ų›Ā»Ā¼Ā½Ā¾ŲŸŪŲ”Ų¢Ų£Ų¤Ų„Ų¦Ų§ŲØŲ©ŲŖŲ«Ų¬Ų­Ų®ŲÆŲ°Ų±Ų²Ų³Ų“ŲµŲ¶Ć—Ų·ŲøŲ¹ŲŗŁ€ŁŁ‚ŁƒĆ Ł„Ć¢Ł…Ł†Ł‡ŁˆĆ§ĆØĆ©ĆŖĆ«Ł‰ŁŠĆ®ĆÆŁ‹ŁŒŁŁŽĆ“ŁŁĆ·Ł‘Ć¹Ł’Ć»Ć¼ā€Žā€Ū’" + }, + "win1256": "windows1256", + "cp1256": "windows1256", + "windows1257": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šļæ½ā€žā€¦ā€ ā€”ļæ½ā€°ļæ½ā€¹ļæ½ĀØĖ‡Āøļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢ļæ½ā€ŗļæ½ĀÆĖ›ļæ½Ā ļæ½Ā¢Ā£Ā¤ļæ½Ā¦Ā§Ć˜Ā©Å–Ā«Ā¬Ā­Ā®Ć†Ā°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĆøĀ¹Å—Ā»Ā¼Ā½Ā¾Ć¦Ä„Ä®Ä€Ä†Ć„Ć…Ä˜Ä’ÄŒĆ‰Å¹Ä–Ä¢Ä¶ÄŖÄ»Å ÅƒÅ…Ć“ÅŒĆ•Ć–Ć—Å²ÅÅšÅŖĆœÅ»Å½ĆŸÄ…ÄÆÄÄ‡Ć¤Ć„Ä™Ä“ÄĆ©ÅŗÄ—Ä£Ä·Ä«Ä¼Å”Å„Å†Ć³ÅĆµĆ¶Ć·Å³Å‚Å›Å«Ć¼Å¼Å¾Ė™" + }, + "win1257": "windows1257", + "cp1257": "windows1257", + "windows1258": { + "type": "_sbcs", + "chars": "ā‚¬ļæ½ā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°ļæ½ā€¹Å’ļæ½ļæ½ļæ½ļæ½ā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢ļæ½ā€ŗœļæ½ļæ½ÅøĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæƀƁƂĂƄƅƆƇƈƉƊƋĢ€ĆĆŽĆÄĆ‘Ģ‰Ć“Ć”Ę Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĘÆĢƒĆŸĆ Ć”Ć¢ÄƒĆ¤Ć„Ć¦Ć§ĆØĆ©ĆŖĆ«ĢĆ­Ć®ĆÆđƱĢ£Ć³Ć“ʔƶƷĆøĆ¹ĆŗĆ»Ć¼Ę°ā‚«Ćæ" + }, + "win1258": "windows1258", + "cp1258": "windows1258", + "iso88591": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆĆĆ‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĆĆžĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆĆ°Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Ć¾Ćæ" + }, + "cp28591": "iso88591", + "iso88592": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ä„Ė˜ÅĀ¤Ä½ÅšĀ§ĀØŠŞŤŹĀ­Å½Å»Ā°Ä…Ė›Å‚Ā“ľśĖ‡ĀøŔşńÅŗĖÅ¾Å¼Å”ĆĆ‚Ä‚Ć„Ä¹Ä†Ć‡ÄŒĆ‰Ä˜Ć‹ÄšĆĆŽÄŽÄÅƒÅ‡Ć“Ć”ÅĆ–Ć—Å˜Å®ĆšÅ°ĆœĆÅ¢ĆŸÅ•Ć”Ć¢ÄƒĆ¤ÄŗÄ‡Ć§ÄĆ©Ä™Ć«Ä›Ć­Ć®ÄÄ‘Å„ÅˆĆ³Ć“Å‘Ć¶Ć·Å™ÅÆĆŗÅ±Ć¼Ć½Å£Ė™" + }, + "cp28592": "iso88592", + "iso88593": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ä¦Ė˜Ā£Ā¤ļæ½Ä¤Ā§ĀØİŞĞēĀ­ļæ½Å»Ā°Ä§Ā²Ā³Ā“ĀµÄ„Ā·ĀøışğĵĀ½ļæ½Å¼Ć€ĆĆ‚ļæ½Ć„ÄŠÄˆĆ‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆļæ½Ć‘Ć’Ć“Ć”Ä Ć–Ć—ÄœĆ™ĆšĆ›ĆœÅ¬ÅœĆŸĆ Ć”Ć¢ļæ½Ć¤Ä‹Ä‰Ć§ĆØĆ©ĆŖƫƬƭƮĆÆļæ½Ć±Ć²Ć³Ć“Ä”Ć¶Ć·ÄĆ¹ĆŗĆ»Ć¼Å­ÅĖ™" + }, + "cp28593": "iso88593", + "iso88594": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ä„ÄøŖĀ¤ÄØÄ»Ā§ĀØŠĒĢŦĀ­Å½ĀÆĀ°Ä…Ė›Å—Ā“ĩļĖ‡ĀøÅ”Ä“Ä£Å§ÅŠÅ¾Å‹Ä€ĆĆ‚ĆƒĆ„Ć…Ć†Ä®ÄŒĆ‰Ä˜Ć‹Ä–ĆĆŽÄŖÄÅ…ÅŒÄ¶Ć”Ć•Ć–Ć—Ć˜Å²ĆšĆ›ĆœÅØÅŖĆŸÄĆ”Ć¢Ć£Ć¤Ć„Ć¦ÄÆÄĆ©Ä™Ć«Ä—Ć­Ć®Ä«Ä‘Å†ÅÄ·Ć“ĆµĆ¶Ć·ĆøųĆŗĆ»Ć¼Å©Å«Ė™" + }, + "cp28594": "iso88594", + "iso88595": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ŠŠ‚ŠƒŠ„Š…Š†Š‡ŠˆŠ‰ŠŠŠ‹ŠŒĀ­ŠŽŠŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюяā„–Ń‘Ń’Ń“Ń”Ń•Ń–Ń—Ń˜Ń™ŃšŃ›ŃœĀ§ŃžŃŸ" + }, + "cp28595": "iso88595", + "iso88596": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ļæ½ļæ½ļæ½Ā¤ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ŲŒĀ­ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½Ų›ļæ½ļæ½ļæ½ŲŸļæ½Ų”Ų¢Ų£Ų¤Ų„Ų¦Ų§ŲØŲ©ŲŖŲ«Ų¬Ų­Ų®ŲÆŲ°Ų±Ų²Ų³Ų“ŲµŲ¶Ų·ŲøŲ¹Ųŗļæ½ļæ½ļæ½ļæ½ļæ½Ł€ŁŁ‚ŁƒŁ„Ł…Ł†Ł‡ŁˆŁ‰ŁŠŁ‹ŁŒŁŁŽŁŁŁ‘Ł’ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½" + }, + "cp28596": "iso88596", + "iso88597": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ā€˜ā€™Ā£ā‚¬ā‚ÆĀ¦Ā§ĀØĀ©ĶŗĀ«Ā¬Ā­ļæ½ā€•Ā°Ā±Ā²Ā³Ī„Ī…Ī†Ā·ĪˆĪ‰ĪŠĀ»ĪŒĀ½ĪŽĪĪĪ‘Ī’Ī“Ī”Ī•Ī–Ī—Ī˜Ī™ĪšĪ›ĪœĪĪžĪŸĪ Ī”ļæ½Ī£Ī¤Ī„Ī¦Ī§ĪØĪ©ĪŖĪ«Ī¬Ī­Ī®ĪÆĪ°Ī±Ī²Ī³Ī“ĪµĪ¶Ī·ĪøĪ¹ĪŗĪ»Ī¼Ī½Ī¾ĪæĻ€ĻĻ‚ĻƒĻ„Ļ…Ļ†Ļ‡ĻˆĻ‰ĻŠĻ‹ĻŒĻĻŽļæ½" + }, + "cp28597": "iso88597", + "iso88598": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ļæ½Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©Ć—Ā«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹Ć·Ā»Ā¼Ā½Ā¾ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ā€—אבגדהוזחטיךכלםמןנהעףפׄצק×Øש×Ŗļæ½ļæ½ā€Žā€ļæ½" + }, + "cp28598": "iso88598", + "iso88599": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆÄžĆ‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœÄ°ÅžĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆÄŸĆ±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ä±ÅŸĆæ" + }, + "cp28599": "iso88599", + "iso885910": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ä„Ä’Ä¢ÄŖÄØĶĀ§Ä»ÄÅ Å¦Å½Ā­ÅŖŊĀ°Ä…ēģīĩķĀ·Ä¼Ä‘Å”ŧžā€•Å«Å‹Ä€ĆĆ‚ĆƒĆ„Ć…Ć†Ä®ÄŒĆ‰Ä˜Ć‹Ä–ĆĆŽĆĆÅ…ÅŒĆ“Ć”Ć•Ć–ÅØĆ˜Å²ĆšĆ›ĆœĆĆžĆŸÄĆ”Ć¢Ć£Ć¤Ć„Ć¦ÄÆÄĆ©Ä™Ć«Ä—Ć­Ć®ĆÆĆ°Å†ÅĆ³Ć“ĆµĆ¶Å©ĆøųĆŗĆ»Ć¼Ć½Ć¾Äø" + }, + "cp28600": "iso885910", + "iso885911": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗļæ½ļæ½ļæ½ļæ½ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ą¹Žą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™ą¹šą¹›ļæ½ļæ½ļæ½ļæ½" + }, + "cp28601": "iso885911", + "iso885913": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ā€Ā¢Ā£Ā¤ā€žĀ¦Ā§Ć˜Ā©Å–Ā«Ā¬Ā­Ā®Ć†Ā°Ā±Ā²Ā³ā€œĀµĀ¶Ā·ĆøĀ¹Å—Ā»Ā¼Ā½Ā¾Ć¦Ä„Ä®Ä€Ä†Ć„Ć…Ä˜Ä’ÄŒĆ‰Å¹Ä–Ä¢Ä¶ÄŖÄ»Å ÅƒÅ…Ć“ÅŒĆ•Ć–Ć—Å²ÅÅšÅŖĆœÅ»Å½ĆŸÄ…ÄÆÄÄ‡Ć¤Ć„Ä™Ä“ÄĆ©ÅŗÄ—Ä£Ä·Ä«Ä¼Å”Å„Å†Ć³ÅĆµĆ¶Ć·Å³Å‚Å›Å«Ć¼Å¼Å¾ā€™" + }, + "cp28603": "iso885913", + "iso885914": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ įø‚įøƒĀ£ÄŠÄ‹įøŠĀ§įŗ€Ā©įŗ‚įø‹į»²Ā­Ā®ÅøįøžįøŸÄ Ä”į¹€į¹Ā¶į¹–įŗį¹—įŗƒį¹ į»³įŗ„įŗ…į¹”Ć€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆÅ“Ć‘Ć’Ć“Ć”Ć•Ć–į¹ŖĆ˜Ć™ĆšĆ›ĆœĆÅ¶ĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆÅµĆ±Ć²Ć³Ć“ĆµĆ¶į¹«ĆøĆ¹ĆŗĆ»Ć¼Ć½Å·Ćæ" + }, + "cp28604": "iso885914", + "iso885915": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£ā‚¬Ā„Å Ā§Å”Ā©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Å½ĀµĀ¶Ā·Å¾Ā¹ĀŗĀ»Å’Å“ÅøĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆĆĆ‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĆĆžĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆĆ°Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Ć¾Ćæ" + }, + "cp28605": "iso885915", + "iso885916": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ä„ąŁā‚¬ā€žÅ Ā§Å”Ā©Č˜Ā«Å¹Ā­ÅŗÅ»Ā°Ā±ÄŒÅ‚Žā€Ā¶Ā·Å¾ÄČ™Ā»Å’Å“ÅøÅ¼Ć€ĆĆ‚Ä‚Ć„Ä†Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆÄÅƒĆ’Ć“Ć”ÅĆ–ÅšÅ°Ć™ĆšĆ›ĆœÄ˜ČšĆŸĆ Ć”Ć¢ÄƒĆ¤Ä‡Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆÄ‘Å„Ć²Ć³Ć“Å‘Ć¶Å›Å±Ć¹ĆŗĆ»Ć¼Ä™Č›Ćæ" + }, + "cp28606": "iso885916", + "cp437": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆÆĆ®Ć¬Ć„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć²Ć»Ć¹ĆæƖƜĀ¢Ā£Ā„ā‚§Ę’Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæāŒĀ¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm437": "cp437", + "csibm437": "cp437", + "cp737": { + "type": "_sbcs", + "chars": "Ī‘Ī’Ī“Ī”Ī•Ī–Ī—Ī˜Ī™ĪšĪ›ĪœĪĪžĪŸĪ Ī”Ī£Ī¤Ī„Ī¦Ī§ĪØĪ©Ī±Ī²Ī³Ī“ĪµĪ¶Ī·ĪøĪ¹ĪŗĪ»Ī¼Ī½Ī¾ĪæĻ€ĻĻƒĻ‚Ļ„Ļ…Ļ†Ļ‡Ļˆā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ļ‰Ī¬Ī­Ī®ĻŠĪÆĻŒĻĻ‹ĻŽĪ†ĪˆĪ‰ĪŠĪŒĪŽĪĀ±ā‰„ā‰¤ĪŖĪ«Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm737": "cp737", + "csibm737": "cp737", + "cp775": { + "type": "_sbcs", + "chars": "Ä†Ć¼Ć©ÄĆ¤Ä£Ć„Ä‡Å‚Ä“Å–Å—Ä«Å¹Ć„Ć…Ć‰Ć¦Ć†ÅĆ¶Ä¢Ā¢ÅšÅ›Ć–ĆœĆøĀ£Ć˜Ć—Ā¤Ä€ÄŖĆ³Å»Å¼Åŗā€Ā¦Ā©Ā®Ā¬Ā½Ā¼ÅĀ«Ā»ā–‘ā–’ā–“ā”‚ā”¤Ä„ČĘĖā•£ā•‘ā•—ā•Ä®Å ā”ā””ā”“ā”¬ā”œā”€ā”¼Å²ÅŖā•šā•”ā•©ā•¦ā• ā•ā•¬Å½Ä…čęėÄÆŔųūžā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ć“ĆŸÅŒÅƒĆµĆ•ĀµÅ„ĶķĻļņĒŅā€™Ā­Ā±ā€œĀ¾Ā¶Ā§Ć·ā€žĀ°āˆ™Ā·Ā¹Ā³Ā²ā– Ā " + }, + "ibm775": "cp775", + "csibm775": "cp775", + "cp850": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆÆĆ®Ć¬Ć„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć²Ć»Ć¹ĆæƖƜĆøĀ£Ć˜Ć—Ę’Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæĀ®Ā¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ĆĆ‚Ć€Ā©ā•£ā•‘ā•—ā•Ā¢Ā„ā”ā””ā”“ā”¬ā”œā”€ā”¼Ć£Ćƒā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤Ć°ĆĆŠĆ‹ĆˆÄ±ĆĆŽĆā”˜ā”Œā–ˆā–„Ā¦ĆŒā–€Ć“ĆŸĆ”Ć’ĆµĆ•ĀµĆ¾ĆžĆšĆ›Ć™Ć½ĆĀÆĀ“Ā­Ā±ā€—Ā¾Ā¶Ā§Ć·ĀøĀ°ĀØĀ·Ā¹Ā³Ā²ā– Ā " + }, + "ibm850": "cp850", + "csibm850": "cp850", + "cp852": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤ÅÆÄ‡Ć§Å‚Ć«ÅÅ‘Ć®Å¹Ć„Ä†Ć‰Ä¹ÄŗĆ“Ć¶Ä½Ä¾ÅšÅ›Ć–ĆœÅ¤Å„ÅĆ—ÄĆ”Ć­Ć³ĆŗĄąŽžĘęĀ¬ÅŗČşĀ«Ā»ā–‘ā–’ā–“ā”‚ā”¤ĆĆ‚ĚŞā•£ā•‘ā•—ā•Å»Å¼ā”ā””ā”“ā”¬ā”œā”€ā”¼Ä‚ăā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤Ä‘ÄÄŽĆ‹ÄÅ‡ĆĆŽÄ›ā”˜ā”Œā–ˆā–„ŢŮā–€Ć“ĆŸĆ”ÅƒÅ„ÅˆÅ Å”Å”ĆšÅ•Å°Ć½ĆÅ£Ā“Ā­ĖĖ›Ė‡Ė˜Ā§Ć·ĀøĀ°ĀØĖ™Å±Å˜Å™ā– Ā " + }, + "ibm852": "cp852", + "csibm852": "cp852", + "cp855": { + "type": "_sbcs", + "chars": "ђŠ‚Ń“ŠƒŃ‘ŠŃ”Š„Ń•Š…Ń–Š†Ń—Š‡Ń˜ŠˆŃ™Š‰ŃšŠŠŃ›Š‹ŃœŠŒŃžŠŽŃŸŠŃŽŠ®ŃŠŠŖŠ°ŠŠ±Š‘цŠ¦Š“Š”ŠµŠ•Ń„Š¤Š³Š“Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤Ń…Š„ŠøŠ˜ā•£ā•‘ā•—ā•Š¹Š™ā”ā””ā”“ā”¬ā”œā”€ā”¼ŠŗŠšā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤Š»Š›Š¼ŠœŠ½ŠŠ¾ŠžŠæā”˜ā”Œā–ˆā–„ŠŸŃā–€ŠÆрŠ ŃŠ”тŠ¢ŃƒŠ£Š¶Š–Š²Š’ŃŒŠ¬ā„–Ā­Ń‹Š«Š·Š—ŃˆŠØэŠ­Ń‰Š©Ń‡Š§Ā§ā– Ā " + }, + "ibm855": "cp855", + "csibm855": "cp855", + "cp856": { + "type": "_sbcs", + "chars": "אבגדהוזחטיךכלםמןנהעףפׄצק×Øש×Ŗļæ½Ā£ļæ½Ć—ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½Ā®Ā¬Ā½Ā¼ļæ½Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ļæ½ļæ½ļæ½Ā©ā•£ā•‘ā•—ā•Ā¢Ā„ā”ā””ā”“ā”¬ā”œā”€ā”¼ļæ½ļæ½ā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ā”˜ā”Œā–ˆā–„Ā¦ļæ½ā–€ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½Āµļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ĀÆĀ“Ā­Ā±ā€—Ā¾Ā¶Ā§Ć·ĀøĀ°ĀØĀ·Ā¹Ā³Ā²ā– Ā " + }, + "ibm856": "cp856", + "csibm856": "cp856", + "cp857": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆÆĆ®Ä±Ć„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć²Ć»Ć¹Ä°Ć–ĆœĆøĀ£Ć˜ÅžÅŸĆ”Ć­Ć³ĆŗĆ±Ć‘ÄžÄŸĀæĀ®Ā¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ĆĆ‚Ć€Ā©ā•£ā•‘ā•—ā•Ā¢Ā„ā”ā””ā”“ā”¬ā”œā”€ā”¼Ć£Ćƒā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤ĀŗĀŖƊƋƈļæ½ĆĆŽĆā”˜ā”Œā–ˆā–„Ā¦ĆŒā–€Ć“ĆŸĆ”Ć’ĆµĆ•Āµļæ½Ć—ƚƛƙƬĆæĀÆĀ“Ā­Ā±ļæ½Ā¾Ā¶Ā§Ć·ĀøĀ°ĀØĀ·Ā¹Ā³Ā²ā– Ā " + }, + "ibm857": "cp857", + "csibm857": "cp857", + "cp858": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆÆĆ®Ć¬Ć„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć²Ć»Ć¹ĆæƖƜĆøĀ£Ć˜Ć—Ę’Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæĀ®Ā¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ĆĆ‚Ć€Ā©ā•£ā•‘ā•—ā•Ā¢Ā„ā”ā””ā”“ā”¬ā”œā”€ā”¼Ć£Ćƒā•šā•”ā•©ā•¦ā• ā•ā•¬Ā¤Ć°ĆĆŠĆ‹Ćˆā‚¬ĆĆŽĆā”˜ā”Œā–ˆā–„Ā¦ĆŒā–€Ć“ĆŸĆ”Ć’ĆµĆ•ĀµĆ¾ĆžĆšĆ›Ć™Ć½ĆĀÆĀ“Ā­Ā±ā€—Ā¾Ā¶Ā§Ć·ĀøĀ°ĀØĀ·Ā¹Ā³Ā²ā– Ā " + }, + "ibm858": "cp858", + "csibm858": "cp858", + "cp860": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć£Ć ĆĆ§ĆŖƊĆØĆĆ”Ć¬ĆƒĆ‚Ć‰Ć€ĆˆĆ“ĆµĆ²ĆšĆ¹ĆŒĆ•ĆœĀ¢Ā£Ć™ā‚§Ć“Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæƒĀ¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm860": "cp860", + "csibm860": "cp860", + "cp861": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆĆ°ĆžĆ„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć¾Ć»ĆĆ½Ć–ĆœĆøĀ£Ć˜ā‚§Ę’Ć”Ć­Ć³ĆŗƁƍƓƚĀæāŒĀ¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm861": "cp861", + "csibm861": "cp861", + "cp862": { + "type": "_sbcs", + "chars": "אבגדהוזחטיךכלםמןנהעףפׄצק×Øש×ŖĀ¢Ā£Ā„ā‚§Ę’Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæāŒĀ¬Ā½Ā¼Ā”Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm862": "cp862", + "csibm862": "cp862", + "cp863": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć‚Ć Ā¶Ć§ĆŖĆ«ĆØĆÆĆ®ā€—Ć€Ā§Ć‰ĆˆĆŠĆ“Ć‹ĆĆ»Ć¹Ā¤Ć”ĆœĀ¢Ā£Ć™Ć›Ę’Ā¦Ā“Ć³ĆŗĀØĀøĀ³ĀÆƎāŒĀ¬Ā½Ā¼Ā¾Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm863": "cp863", + "csibm863": "cp863", + "cp864": { + "type": "_sbcs", + "chars": "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#$ŁŖ&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ā°Ā·āˆ™āˆšā–’ā”€ā”‚ā”¼ā”¤ā”¬ā”œā”“ā”ā”Œā””ā”˜Ī²āˆžĻ†Ā±Ā½Ā¼ā‰ˆĀ«Ā»ļ»·ļ»øļæ½ļæ½ļ»»ļ»¼ļæ½Ā Ā­ļŗ‚Ā£Ā¤ļŗ„ļæ½ļæ½ļŗŽļŗļŗ•ļŗ™ŲŒļŗļŗ”ļŗ„Ł Ł”Ł¢Ł£Ł¤Ł„Ł¦Ł§ŁØŁ©ļ»‘Ų›ļŗ±ļŗµļŗ¹ŲŸĀ¢ļŗ€ļŗļŗƒļŗ…ļ»Šļŗ‹ļŗļŗ‘ļŗ“ļŗ—ļŗ›ļŗŸļŗ£ļŗ§ļŗ©ļŗ«ļŗ­ļŗÆļŗ³ļŗ·ļŗ»ļŗæļ»ļ»…ļ»‹ļ»Ā¦Ā¬Ć·Ć—ļ»‰Ł€ļ»“ļ»—ļ»›ļ»Ÿļ»£ļ»§ļ»«ļ»­ļ»Æļ»³ļŗ½ļ»Œļ»Žļ»ļ»”ļ¹½Ł‘ļ»„ļ»©ļ»¬ļ»°ļ»²ļ»ļ»•ļ»µļ»¶ļ»ļ»™ļ»±ā– ļæ½" + }, + "ibm864": "cp864", + "csibm864": "cp864", + "cp865": { + "type": "_sbcs", + "chars": "Ć‡Ć¼Ć©Ć¢Ć¤Ć Ć„Ć§ĆŖĆ«ĆØĆÆĆ®Ć¬Ć„Ć…Ć‰Ć¦Ć†Ć“Ć¶Ć²Ć»Ć¹ĆæƖƜĆøĀ£Ć˜ā‚§Ę’Ć”Ć­Ć³ĆŗƱƑĀŖĀŗĀæāŒĀ¬Ā½Ā¼Ā”Ā«Ā¤ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + "ibm865": "cp865", + "csibm865": "cp865", + "cp866": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ń€ŃŃ‚ŃƒŃ„Ń…Ń†Ń‡ŃˆŃ‰ŃŠŃ‹ŃŒŃŃŽŃŠŃ‘Š„Ń”Š‡Ń—ŠŽŃžĀ°āˆ™Ā·āˆšā„–Ā¤ā– Ā " + }, + "ibm866": "cp866", + "csibm866": "cp866", + "cp869": { + "type": "_sbcs", + "chars": "ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½Ī†ļæ½Ā·Ā¬Ā¦ā€˜ā€™Īˆā€•Ī‰ĪŠĪŖĪŒļæ½ļæ½ĪŽĪ«Ā©ĪĀ²Ā³Ī¬Ā£Ī­Ī®ĪÆĻŠĪĻŒĻĪ‘Ī’Ī“Ī”Ī•Ī–Ī—Ā½Ī˜Ī™Ā«Ā»ā–‘ā–’ā–“ā”‚ā”¤ĪšĪ›ĪœĪā•£ā•‘ā•—ā•ĪžĪŸā”ā””ā”“ā”¬ā”œā”€ā”¼Ī Ī”ā•šā•”ā•©ā•¦ā• ā•ā•¬Ī£Ī¤Ī„Ī¦Ī§ĪØĪ©Ī±Ī²Ī³ā”˜ā”Œā–ˆā–„Ī“Īµā–€Ī¶Ī·ĪøĪ¹ĪŗĪ»Ī¼Ī½Ī¾ĪæĻ€ĻĻƒĻ‚Ļ„Ī„Ā­Ā±Ļ…Ļ†Ļ‡Ā§ĻˆĪ…Ā°ĀØĻ‰Ļ‹Ī°ĻŽā– Ā " + }, + "ibm869": "cp869", + "csibm869": "cp869", + "cp922": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ā€¾Ā°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾ĀæĆ€ĆĆ‚ĆƒĆ„Ć…Ć†Ć‡ĆˆĆ‰ĆŠĆ‹ĆŒĆĆŽĆÅ Ć‘Ć’Ć“Ć”Ć•Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĆÅ½ĆŸĆ Ć”Ć¢Ć£Ć¤Ć„Ć¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆÅ”Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Å¾Ćæ" + }, + "ibm922": "cp922", + "csibm922": "cp922", + "cp1046": { + "type": "_sbcs", + "chars": "ļŗˆĆ—Ć·ļ£¶ļ£µļ£“ļ£·ļ¹±Āˆā– ā”‚ā”€ā”ā”Œā””ā”˜ļ¹¹ļ¹»ļ¹½ļ¹æļ¹·ļŗŠļ»°ļ»³ļ»²ļ»Žļ»ļ»ļ»¶ļ»øļ»ŗļ»¼Ā ļ£ŗļ£¹ļ£øĀ¤ļ£»ļŗ‹ļŗ‘ļŗ—ļŗ›ļŗŸļŗ£ŲŒĀ­ļŗ§ļŗ³Ł Ł”Ł¢Ł£Ł¤Ł„Ł¦Ł§ŁØŁ©ļŗ·Ų›ļŗ»ļŗæļ»ŠŲŸļ»‹Ų”Ų¢Ų£Ų¤Ų„Ų¦Ų§ŲØŲ©ŲŖŲ«Ų¬Ų­Ų®ŲÆŲ°Ų±Ų²Ų³Ų“ŲµŲ¶Ų·ļ»‡Ų¹Ųŗļ»Œļŗ‚ļŗ„ļŗŽļ»“Ł€ŁŁ‚ŁƒŁ„Ł…Ł†Ł‡ŁˆŁ‰ŁŠŁ‹ŁŒŁŁŽŁŁŁ‘Ł’ļ»—ļ»›ļ»Ÿļ£¼ļ»µļ»·ļ»¹ļ»»ļ»£ļ»§ļ»¬ļ»©ļæ½" + }, + "ibm1046": "cp1046", + "csibm1046": "cp1046", + "cp1124": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ŠŠ‚ŅŠ„Š…Š†Š‡ŠˆŠ‰ŠŠŠ‹ŠŒĀ­ŠŽŠŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюяā„–Ń‘Ń’Ņ‘Ń”Ń•Ń–Ń—Ń˜Ń™ŃšŃ›ŃœĀ§ŃžŃŸ" + }, + "ibm1124": "cp1124", + "csibm1124": "cp1124", + "cp1125": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ń€ŃŃ‚ŃƒŃ„Ń…Ń†Ń‡ŃˆŃ‰ŃŠŃ‹ŃŒŃŃŽŃŠŃ‘ŅŅ‘Š„Ń”Š†Ń–Š‡Ń—Ā·āˆšā„–Ā¤ā– Ā " + }, + "ibm1125": "cp1125", + "csibm1125": "cp1125", + "cp1129": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§Å“Ā©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³ÅøĀµĀ¶Ā·Å’Ā¹ĀŗĀ»Ā¼Ā½Ā¾ĀæƀƁƂĂƄƅƆƇƈƉƊƋĢ€ĆĆŽĆÄĆ‘Ģ‰Ć“Ć”Ę Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĘÆĢƒĆŸĆ Ć”Ć¢ÄƒĆ¤Ć„Ć¦Ć§ĆØĆ©ĆŖĆ«ĢĆ­Ć®ĆÆđƱĢ£Ć³Ć“ʔƶƷĆøĆ¹ĆŗĆ»Ć¼Ę°ā‚«Ćæ" + }, + "ibm1129": "cp1129", + "csibm1129": "cp1129", + "cp1133": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ąŗąŗ‚ąŗ„ąŗ‡ąŗˆąŗŖąŗŠąŗąŗ”ąŗ•ąŗ–ąŗ—ąŗ™ąŗšąŗ›ąŗœąŗąŗžąŗŸąŗ”ąŗ¢ąŗ£ąŗ„ąŗ§ąŗ«ąŗ­ąŗ®ļæ½ļæ½ļæ½ąŗÆąŗ°ąŗ²ąŗ³ąŗ“ąŗµąŗ¶ąŗ·ąŗøąŗ¹ąŗ¼ąŗ±ąŗ»ąŗ½ļæ½ļæ½ļæ½ą»€ą»ą»‚ą»ƒą»„ą»ˆą»‰ą»Šą»‹ą»Œą»ą»†ļæ½ą»œą»ā‚­ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ą»ą»‘ą»’ą»“ą»”ą»•ą»–ą»—ą»˜ą»™ļæ½ļæ½Ā¢Ā¬Ā¦ļæ½" + }, + "ibm1133": "cp1133", + "csibm1133": "cp1133", + "cp1161": { + "type": "_sbcs", + "chars": "ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ą¹ˆąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗą¹‰ą¹Šą¹‹ā‚¬ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ą¹Žą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™ą¹šą¹›Ā¢Ā¬Ā¦Ā " + }, + "ibm1161": "cp1161", + "csibm1161": "cp1161", + "cp1162": { + "type": "_sbcs", + "chars": "ā‚¬ĀĀ‚ĀƒĀ„ā€¦Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀā€˜ā€™ā€œā€ā€¢ā€“ā€”Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗļæ½ļæ½ļæ½ļæ½ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ą¹Žą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™ą¹šą¹›ļæ½ļæ½ļæ½ļæ½" + }, + "ibm1162": "cp1162", + "csibm1162": "cp1162", + "cp1163": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ā”Ā¢Ā£ā‚¬Ā„Ā¦Ā§Å“Ā©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³ÅøĀµĀ¶Ā·Å’Ā¹ĀŗĀ»Ā¼Ā½Ā¾ĀæƀƁƂĂƄƅƆƇƈƉƊƋĢ€ĆĆŽĆÄĆ‘Ģ‰Ć“Ć”Ę Ć–Ć—Ć˜Ć™ĆšĆ›ĆœĘÆĢƒĆŸĆ Ć”Ć¢ÄƒĆ¤Ć„Ć¦Ć§ĆØĆ©ĆŖĆ«ĢĆ­Ć®ĆÆđƱĢ£Ć³Ć“ʔƶƷĆøĆ¹ĆŗĆ»Ć¼Ę°ā‚«Ćæ" + }, + "ibm1163": "cp1163", + "csibm1163": "cp1163", + "maccroatian": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Å ā„¢Ā“ĀØā‰ Å½Ć˜āˆžĀ±ā‰¤ā‰„āˆ†Āµāˆ‚āˆ‘āˆÅ”āˆ«ĀŖĀŗā„¦Å¾ĆøĀæĀ”Ā¬āˆšĘ’ā‰ˆÄ†Ā«ÄŒā€¦Ā Ć€ĆƒĆ•Å’œĐā€”ā€œā€ā€˜ā€™Ć·ā—Šļæ½Ā©ā„Ā¤ā€¹ā€ŗƆĀ»ā€“Ā·ā€šā€žā€°Ć‚Ä‡ĆÄĆˆĆĆŽĆĆŒĆ“Ć”Ä‘Ć’ĆšĆ›Ć™Ä±Ė†ĖœĀÆĻ€Ć‹ĖšĀøƊƦĖ‡" + }, + "maccyrillic": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶Š†Ā®Ā©ā„¢Š‚Ń’ā‰ ŠƒŃ“āˆžĀ±ā‰¤ā‰„іĀµāˆ‚ŠˆŠ„Ń”Š‡Ń—Š‰Ń™ŠŠŃšŃ˜Š…Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Š‹Ń›ŠŒŃœŃ•ā€“ā€”ā€œā€ā€˜ā€™Ć·ā€žŠŽŃžŠŃŸā„–ŠŃ‘яŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæрстуфхцчшщъыьэюĀ¤" + }, + "macgreek": { + "type": "_sbcs", + "chars": "ƄĀ¹Ā²Ć‰Ā³Ć–ĆœĪ…Ć Ć¢Ć¤Ī„ĀØƧƩĆØĆŖĆ«Ā£ā„¢Ć®ĆÆā€¢Ā½ā€°Ć“ƶĀ¦Ā­Ć¹Ć»Ć¼ā€ Ī“Ī”Ī˜Ī›ĪžĪ ĆŸĀ®Ā©Ī£ĪŖĀ§ā‰ Ā°Ī‡Ī‘Ā±ā‰¤ā‰„Ā„Ī’Ī•Ī–Ī—Ī™ĪšĪœĪ¦Ī«ĪØĪ©Ī¬ĪĀ¬ĪŸĪ”ā‰ˆĪ¤Ā«Ā»ā€¦Ā Ī„Ī§Ī†ĪˆÅ“ā€“ā€•ā€œā€ā€˜ā€™Ć·Ī‰ĪŠĪŒĪŽĪ­Ī®ĪÆĻŒĪĻĪ±Ī²ĻˆĪ“ĪµĻ†Ī³Ī·Ī¹Ī¾ĪŗĪ»Ī¼Ī½ĪæĻ€ĻŽĻĻƒĻ„ĪøĻ‰Ļ‚Ļ‡Ļ…Ī¶ĻŠĻ‹ĪĪ°ļæ½" + }, + "maciceland": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ĆĀ°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ā“ĀØā‰ Ć†Ć˜āˆžĀ±ā‰¤ā‰„Ā„Āµāˆ‚āˆ‘āˆĻ€āˆ«ĀŖĀŗā„¦Ć¦ĆøĀæĀ”Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Ć€ĆƒĆ•Å’Å“ā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠĆæÅøā„Ā¤ĆĆ°ĆžĆ¾Ć½Ā·ā€šā€žā€°Ć‚ĆŠĆĆ‹ĆˆĆĆŽĆĆŒĆ“Ć”ļæ½Ć’ƚƛƙıĖ†ĖœĀÆĖ˜Ė™ĖšĀøĖĖ›Ė‡" + }, + "macroman": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ā“ĀØā‰ Ć†Ć˜āˆžĀ±ā‰¤ā‰„Ā„Āµāˆ‚āˆ‘āˆĻ€āˆ«ĀŖĀŗā„¦Ć¦ĆøĀæĀ”Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Ć€ĆƒĆ•Å’Å“ā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠĆæÅøā„Ā¤ā€¹ā€ŗļ¬ļ¬‚ā€”Ā·ā€šā€žā€°Ć‚ĆŠĆĆ‹ĆˆĆĆŽĆĆŒĆ“Ć”ļæ½Ć’ƚƛƙıĖ†ĖœĀÆĖ˜Ė™ĖšĀøĖĖ›Ė‡" + }, + "macromania": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ā“ĀØā‰ Ä‚ÅžāˆžĀ±ā‰¤ā‰„Ā„Āµāˆ‚āˆ‘āˆĻ€āˆ«ĀŖĀŗā„¦ÄƒÅŸĀæĀ”Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Ć€ĆƒĆ•Å’Å“ā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠĆæÅøā„Ā¤ā€¹ā€ŗŢţā€”Ā·ā€šā€žā€°Ć‚ĆŠĆĆ‹ĆˆĆĆŽĆĆŒĆ“Ć”ļæ½Ć’ƚƛƙıĖ†ĖœĀÆĖ˜Ė™ĖšĀøĖĖ›Ė‡" + }, + "macthai": { + "type": "_sbcs", + "chars": "Ā«Ā»ā€¦ļ¢Œļ¢ļ¢’ļ¢•ļ¢˜ļ¢‹ļ¢Žļ¢‘ļ¢”ļ¢—ā€œā€ļ¢™ļæ½ā€¢ļ¢„ļ¢‰ļ¢…ļ¢†ļ¢‡ļ¢ˆļ¢Šļ¢ļ¢ļ¢“ļ¢–ā€˜ā€™ļæ½Ā ąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗļ»æā€‹ā€“ā€”ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ā„¢ą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™Ā®Ā©ļæ½ļæ½ļæ½ļæ½" + }, + "macturkish": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ā“ĀØā‰ Ć†Ć˜āˆžĀ±ā‰¤ā‰„Ā„Āµāˆ‚āˆ‘āˆĻ€āˆ«ĀŖĀŗā„¦Ć¦ĆøĀæĀ”Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Ć€ĆƒĆ•Å’Å“ā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠĆæÅøĞğİıŞşā€”Ā·ā€šā€žā€°Ć‚ĆŠĆĆ‹ĆˆĆĆŽĆĆŒĆ“Ć”ļæ½Ć’ƚƛƙļæ½Ė†ĖœĀÆĖ˜Ė™ĖšĀøĖĖ›Ė‡" + }, + "macukraine": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆā€ Ā°ŅĀ£Ā§ā€¢Ā¶Š†Ā®Ā©ā„¢Š‚Ń’ā‰ ŠƒŃ“āˆžĀ±ā‰¤ā‰„іĀµŅ‘ŠˆŠ„Ń”Š‡Ń—Š‰Ń™ŠŠŃšŃ˜Š…Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Š‹Ń›ŠŒŃœŃ•ā€“ā€”ā€œā€ā€˜ā€™Ć·ā€žŠŽŃžŠŃŸā„–ŠŃ‘яŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæрстуфхцчшщъыьэюĀ¤" + }, + "koi8r": { + "type": "_sbcs", + "chars": "ā”€ā”‚ā”Œā”ā””ā”˜ā”œā”¤ā”¬ā”“ā”¼ā–€ā–„ā–ˆā–Œā–ā–‘ā–’ā–“āŒ ā– āˆ™āˆšā‰ˆā‰¤ā‰„Ā āŒ”Ā°Ā²Ā·Ć·ā•ā•‘ā•’Ń‘ā•“ā•”ā••ā•–ā•—ā•˜ā•™ā•šā•›ā•œā•ā•žā•Ÿā• ā•”Šā•¢ā•£ā•¤ā•„ā•¦ā•§ā•Øā•©ā•Ŗā•«ā•¬Ā©ŃŽŠ°Š±Ń†Š“ŠµŃ„Š³Ń…ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæярстуŠ¶Š²ŃŒŃ‹Š·ŃˆŃŃ‰Ń‡ŃŠŠ®ŠŠ‘Š¦Š”Š•Š¤Š“Š„Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠÆŠ Š”Š¢Š£Š–Š’Š¬Š«Š—ŠØŠ­Š©Š§ŠŖ" + }, + "koi8u": { + "type": "_sbcs", + "chars": "ā”€ā”‚ā”Œā”ā””ā”˜ā”œā”¤ā”¬ā”“ā”¼ā–€ā–„ā–ˆā–Œā–ā–‘ā–’ā–“āŒ ā– āˆ™āˆšā‰ˆā‰¤ā‰„Ā āŒ”Ā°Ā²Ā·Ć·ā•ā•‘ā•’Ń‘Ń”ā•”Ń–Ń—ā•—ā•˜ā•™ā•šā•›Ņ‘ā•ā•žā•Ÿā• ā•”ŠŠ„ā•£Š†Š‡ā•¦ā•§ā•Øā•©ā•ŖŅā•¬Ā©ŃŽŠ°Š±Ń†Š“ŠµŃ„Š³Ń…ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæярстуŠ¶Š²ŃŒŃ‹Š·ŃˆŃŃ‰Ń‡ŃŠŠ®ŠŠ‘Š¦Š”Š•Š¤Š“Š„Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠÆŠ Š”Š¢Š£Š–Š’Š¬Š«Š—ŠØŠ­Š©Š§ŠŖ" + }, + "koi8ru": { + "type": "_sbcs", + "chars": "ā”€ā”‚ā”Œā”ā””ā”˜ā”œā”¤ā”¬ā”“ā”¼ā–€ā–„ā–ˆā–Œā–ā–‘ā–’ā–“āŒ ā– āˆ™āˆšā‰ˆā‰¤ā‰„Ā āŒ”Ā°Ā²Ā·Ć·ā•ā•‘ā•’Ń‘Ń”ā•”Ń–Ń—ā•—ā•˜ā•™ā•šā•›Ņ‘Ńžā•žā•Ÿā• ā•”ŠŠ„ā•£Š†Š‡ā•¦ā•§ā•Øā•©ā•ŖŅŠŽĀ©ŃŽŠ°Š±Ń†Š“ŠµŃ„Š³Ń…ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæярстуŠ¶Š²ŃŒŃ‹Š·ŃˆŃŃ‰Ń‡ŃŠŠ®ŠŠ‘Š¦Š”Š•Š¤Š“Š„Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠÆŠ Š”Š¢Š£Š–Š’Š¬Š«Š—ŠØŠ­Š©Š§ŠŖ" + }, + "koi8t": { + "type": "_sbcs", + "chars": "Ņ›Ņ“ā€šŅ’ā€žā€¦ā€ ā€”ļæ½ā€°Ņ³ā€¹Ņ²Ņ·Ņ¶ļæ½Ņšā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢ļæ½ā€ŗļæ½ļæ½ļæ½ļæ½ļæ½ÓÆӮёĀ¤Ó£Ā¦Ā§ļæ½ļæ½ļæ½Ā«Ā¬Ā­Ā®ļæ½Ā°Ā±Ā²Šļæ½Ó¢Ā¶Ā·ļæ½ā„–ļæ½Ā»ļæ½ļæ½ļæ½Ā©ŃŽŠ°Š±Ń†Š“ŠµŃ„Š³Ń…ŠøŠ¹ŠŗŠ»Š¼Š½Š¾ŠæярстуŠ¶Š²ŃŒŃ‹Š·ŃˆŃŃ‰Ń‡ŃŠŠ®ŠŠ‘Š¦Š”Š•Š¤Š“Š„Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠÆŠ Š”Š¢Š£Š–Š’Š¬Š«Š—ŠØŠ­Š©Š§ŠŖ" + }, + "armscii8": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ ļæ½Ö‡Ö‰)(Ā»Ā«ā€”.՝,-֊ā€¦ÕœÕ›ÕžŌ±Õ”Ō²Õ¢Ō³Õ£Ō“Õ¤ŌµÕ„Ō¶Õ¦Ō·Õ§ŌøÕØŌ¹Õ©ŌŗÕŖŌ»Õ«Ō¼Õ¬Ō½Õ­Ō¾Õ®ŌæÕÆՀհՁձՂղՃճՄՓՅյՆնՇշՈÕøՉչՊÕŗՋջՌռՍսՎվՏÕæՐրՑցՒւՓփՔքՕօՖֆ՚ļæ½" + }, + "rk1048": { + "type": "_sbcs", + "chars": "Š‚Šƒā€šŃ“ā€žā€¦ā€ ā€”ā‚¬ā€°Š‰ā€¹ŠŠŅšŅŗŠŃ’ā€˜ā€™ā€œā€ā€¢ā€“ā€”ļæ½ā„¢Ń™ā€ŗњŅ›Ņ»ŃŸĀ Ņ°Ņ±Ó˜Ā¤ÓØĀ¦Ā§ŠĀ©Ņ’Ā«Ā¬Ā­Ā®Ņ®Ā°Ā±Š†Ń–Ó©ĀµĀ¶Ā·Ń‘ā„–Ņ“Ā»Ó™Ņ¢Ņ£ŅÆŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюя" + }, + "tcvn": { + "type": "_sbcs", + "chars": "\u0000ƚį»¤\u0003į»Ŗį»¬į»®\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010į»Øį»°į»²į»¶į»øƝį»“\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ƀįŗ¢ĆƒĆįŗ įŗ¶įŗ¬Ćˆįŗŗįŗ¼Ć‰įŗøį»†ĆŒį»ˆÄØƍį»ŠĆ’į»ŽĆ•Ć“į»Œį»˜į»œį»žį» į»šį»¢Ć™į»¦ÅØĀ Ä‚ƂƊƔʠĘÆÄÄƒĆ¢ĆŖƓʔʰđįŗ°Ģ€Ģ‰ĢƒĢĢ£Ć įŗ£Ć£Ć”įŗ”įŗ²įŗ±įŗ³įŗµįŗÆįŗ“įŗ®įŗ¦įŗØįŗŖįŗ¤į»€įŗ·įŗ§įŗ©įŗ«įŗ„įŗ­ĆØį»‚įŗ»įŗ½Ć©įŗ¹į»į»ƒį»…įŗæį»‡Ć¬į»‰į»„įŗ¾į»’Ä©Ć­į»‹Ć²į»”į»ĆµĆ³į»į»“į»•į»—į»‘į»™į»į»Ÿį»”į»›į»£Ć¹į»–į»§Å©Ćŗį»„į»«į»­į»Æį»©į»±į»³į»·į»¹Ć½į»µį»" + }, + "georgianacademy": { + "type": "_sbcs", + "chars": "Ā€Āā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°Å ā€¹Å’ĀĀŽĀĀā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢Å”ā€ŗœĀĀžÅøĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾Āæįƒįƒ‘įƒ’įƒ“įƒ”įƒ•įƒ–įƒ—įƒ˜įƒ™įƒšįƒ›įƒœįƒįƒžįƒŸįƒ įƒ”įƒ¢įƒ£įƒ¤įƒ„įƒ¦įƒ§įƒØįƒ©įƒŖįƒ«įƒ¬įƒ­įƒ®įƒÆįƒ°įƒ±įƒ²įƒ³įƒ“įƒµįƒ¶Ć§ĆØĆ©ĆŖƫƬƭƮĆÆĆ°Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Ć¾Ćæ" + }, + "georgianps": { + "type": "_sbcs", + "chars": "Ā€Āā€šĘ’ā€žā€¦ā€ ā€”Ė†ā€°Å ā€¹Å’ĀĀŽĀĀā€˜ā€™ā€œā€ā€¢ā€“ā€”Ėœā„¢Å”ā€ŗœĀĀžÅøĀ Ā”Ā¢Ā£Ā¤Ā„Ā¦Ā§ĀØĀ©ĀŖĀ«Ā¬Ā­Ā®ĀÆĀ°Ā±Ā²Ā³Ā“ĀµĀ¶Ā·ĀøĀ¹ĀŗĀ»Ā¼Ā½Ā¾Āæįƒįƒ‘įƒ’įƒ“įƒ”įƒ•įƒ–įƒ±įƒ—įƒ˜įƒ™įƒšįƒ›įƒœįƒ²įƒįƒžįƒŸįƒ įƒ”įƒ¢įƒ³įƒ£įƒ¤įƒ„įƒ¦įƒ§įƒØįƒ©įƒŖįƒ«įƒ¬įƒ­įƒ®įƒ“įƒÆįƒ°įƒµĆ¦Ć§ĆØĆ©ĆŖƫƬƭƮĆÆĆ°Ć±Ć²Ć³Ć“ĆµĆ¶Ć·ĆøĆ¹ĆŗĆ»Ć¼Ć½Ć¾Ćæ" + }, + "pt154": { + "type": "_sbcs", + "chars": "Ņ–Ņ’Ó®Ņ“ā€žā€¦Ņ¶Ņ®Ņ²ŅÆŅ Ó¢Ņ¢ŅšŅŗŅøŅ—ā€˜ā€™ā€œā€ā€¢ā€“ā€”Ņ³Ņ·Ņ”Ó£Ņ£Ņ›Ņ»Ņ¹Ā ŠŽŃžŠˆÓØŅ˜Ņ°Ā§ŠĀ©Ó˜Ā«Ā¬ÓÆĀ®ŅœĀ°Ņ±Š†Ń–Ņ™Ó©Ā¶Ā·Ń‘ā„–Ó™Ā»Ń˜ŅŖŅ«ŅŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюя" + }, + "viscii": { + "type": "_sbcs", + "chars": "\u0000\u0001įŗ²\u0003\u0004įŗ“įŗŖ\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013į»¶\u0015\u0016\u0017\u0018į»ø\u001a\u001b\u001c\u001dį»“\u001f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~įŗ įŗ®įŗ°įŗ¶įŗ¤įŗ¦įŗØįŗ¬įŗ¼įŗøįŗ¾į»€į»‚į»„į»†į»į»’į»”į»–į»˜į»¢į»šį»œį»žį»Šį»Žį»Œį»ˆį»¦ÅØį»¤į»²Ć•įŗÆįŗ±įŗ·įŗ„įŗ§įŗ©įŗ­įŗ½įŗ¹įŗæį»į»ƒį»…į»‡į»‘į»“į»•į»—į» Ę į»™į»į»Ÿį»‹į»°į»Øį»Ŗį»¬Ę”į»›ĘÆƀƁƂƃįŗ¢Ä‚įŗ³įŗµĆˆĆ‰ĆŠįŗŗƌƍÄØį»³Äį»©Ć’Ć“Ć”įŗ”į»·į»«į»­Ć™Ćšį»¹į»µĆį»”Ę°Ć Ć”Ć¢Ć£įŗ£Äƒį»Æįŗ«ĆØĆ©ĆŖįŗ»Ć¬Ć­Ä©į»‰Ä‘į»±Ć²Ć³Ć“Ƶį»į»į»„Ć¹ĆŗÅ©į»§Ć½į»£į»®" + }, + "iso646cn": { + "type": "_sbcs", + "chars": "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#Ā„%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}ā€¾ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½" + }, + "iso646jp": { + "type": "_sbcs", + "chars": "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[Ā„]^_`abcdefghijklmnopqrstuvwxyz{|}ā€¾ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½" + }, + "hproman8": { + "type": "_sbcs", + "chars": "Ā€ĀĀ‚ĀƒĀ„Ā…Ā†Ā‡ĀˆĀ‰ĀŠĀ‹ĀŒĀĀŽĀĀĀ‘Ā’Ā“Ā”Ā•Ā–Ā—Ā˜Ā™ĀšĀ›ĀœĀĀžĀŸĀ Ć€Ć‚ĆˆĆŠĆ‹ĆŽĆĀ“Ė‹Ė†ĀØĖœĆ™Ć›ā‚¤ĀÆĆĆ½Ā°Ć‡Ć§Ć‘ƱĀ”ĀæĀ¤Ā£Ā„Ā§Ę’Ā¢Ć¢ĆŖĆ“Ć»Ć”Ć©Ć³ĆŗĆ ĆØĆ²Ć¹Ć¤Ć«Ć¶Ć¼Ć…Ć®Ć˜Ć†Ć„Ć­ĆøĆ¦Ć„Ć¬Ć–ĆœĆ‰ĆÆĆŸĆ”ĆĆƒĆ£ĆĆ°ĆĆŒĆ“Ć’Ć•ĆµÅ Å”ĆšÅøĆæĆžĆ¾Ā·ĀµĀ¶Ā¾ā€”Ā¼Ā½ĀŖĀŗĀ«ā– Ā»Ā±ļæ½" + }, + "macintosh": { + "type": "_sbcs", + "chars": "Ć„Ć…Ć‡Ć‰Ć‘Ć–ĆœĆ”Ć Ć¢Ć¤Ć£Ć„Ć§Ć©ĆØĆŖƫƭƬƮĆÆĆ±Ć³Ć²Ć“Ć¶ĆµĆŗĆ¹Ć»Ć¼ā€ Ā°Ā¢Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ā“ĀØā‰ Ć†Ć˜āˆžĀ±ā‰¤ā‰„Ā„Āµāˆ‚āˆ‘āˆĻ€āˆ«ĀŖĀŗā„¦Ć¦ĆøĀæĀ”Ā¬āˆšĘ’ā‰ˆāˆ†Ā«Ā»ā€¦Ā Ć€ĆƒĆ•Å’Å“ā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠĆæÅøā„Ā¤ā€¹ā€ŗļ¬ļ¬‚ā€”Ā·ā€šā€žā€°Ć‚ĆŠĆĆ‹ĆˆĆĆŽĆĆŒĆ“Ć”ļæ½Ć’ƚƛƙıĖ†ĖœĀÆĖ˜Ė™ĖšĀøĖĖ›Ė‡" + }, + "ascii": { + "type": "_sbcs", + "chars": "ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½" + }, + "tis620": { + "type": "_sbcs", + "chars": "ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ļæ½ąøąø‚ąøƒąø„ąø…ąø†ąø‡ąøˆąø‰ąøŠąø‹ąøŒąøąøŽąøąøąø‘ąø’ąø“ąø”ąø•ąø–ąø—ąø˜ąø™ąøšąø›ąøœąøąøžąøŸąø ąø”ąø¢ąø£ąø¤ąø„ąø¦ąø§ąøØąø©ąøŖąø«ąø¬ąø­ąø®ąøÆąø°ąø±ąø²ąø³ąø“ąøµąø¶ąø·ąøøąø¹ąøŗļæ½ļæ½ļæ½ļæ½ąøæą¹€ą¹ą¹‚ą¹ƒą¹„ą¹…ą¹†ą¹‡ą¹ˆą¹‰ą¹Šą¹‹ą¹Œą¹ą¹Žą¹ą¹ą¹‘ą¹’ą¹“ą¹”ą¹•ą¹–ą¹—ą¹˜ą¹™ą¹šą¹›ļæ½ļæ½ļæ½ļæ½" + } +} + +/***/ }), + +/***/ 9320: +/***/ ((module) => { + +"use strict"; + + +// Manually added data to be used by sbcs codec in addition to generated one. + +module.exports = { + // Not supported by iconv, not sure why. + "10029": "maccenteuro", + "maccenteuro": { + "type": "_sbcs", + "chars": "Ć„Ä€ÄĆ‰Ä„Ć–ĆœĆ”Ä…ÄŒĆ¤ÄÄ†Ä‡Ć©Å¹ÅŗÄŽĆ­ÄÄ’Ä“Ä–Ć³Ä—Ć“Ć¶ĆµĆŗÄšÄ›Ć¼ā€ Ā°Ä˜Ā£Ā§ā€¢Ā¶ĆŸĀ®Ā©ā„¢Ä™ĀØā‰ Ä£Ä®ÄÆÄŖā‰¤ā‰„īĶāˆ‚āˆ‘łĻļĽľĹÄŗŅņŃĀ¬āˆšÅ„Ňāˆ†Ā«Ā»ā€¦Ā ÅˆÅĆ•Å‘ÅŒā€“ā€”ā€œā€ā€˜ā€™Ć·ā—ŠÅÅ”ŕŘā€¹ā€ŗřŖŗŠā€šā€žÅ”ÅšÅ›ĆÅ¤Å„ĆÅ½Å¾ÅŖĆ“Ć”Å«Å®ĆšÅÆÅ°Å±Å²Å³ĆĆ½Ä·Å»ÅÅ¼Ä¢Ė‡" + }, + + "808": "cp808", + "ibm808": "cp808", + "cp808": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ń€ŃŃ‚ŃƒŃ„Ń…Ń†Ń‡ŃˆŃ‰ŃŠŃ‹ŃŒŃŃŽŃŠŃ‘Š„Ń”Š‡Ń—ŠŽŃžĀ°āˆ™Ā·āˆšā„–ā‚¬ā– Ā " + }, + + "mik": { + "type": "_sbcs", + "chars": "ŠŠ‘Š’Š“Š”Š•Š–Š—Š˜Š™ŠšŠ›ŠœŠŠžŠŸŠ Š”Š¢Š£Š¤Š„Š¦Š§ŠØŠ©ŠŖŠ«Š¬Š­Š®ŠÆŠ°Š±Š²Š³Š“ŠµŠ¶Š·ŠøŠ¹ŠŗŠ»Š¼Š½Š¾Šæрстуфхцчшщъыьэюяā””ā”“ā”¬ā”œā”€ā”¼ā•£ā•‘ā•šā•”ā•©ā•¦ā• ā•ā•¬ā”ā–‘ā–’ā–“ā”‚ā”¤ā„–Ā§ā•—ā•ā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ī±ĆŸĪ“Ļ€Ī£ĻƒĀµĻ„Ī¦Ī˜Ī©Ī“āˆžĻ†Īµāˆ©ā‰”Ā±ā‰„ā‰¤āŒ āŒ”Ć·ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– Ā " + }, + + "cp720": { + "type": "_sbcs", + "chars": "\x80\x81Ć©Ć¢\x84Ć \x86ƧĆŖĆ«ĆØĆÆĆ®\x8d\x8e\x8f\x90\u0651\u0652Ć“Ā¤Ł€Ć»Ć¹Ų”Ų¢Ų£Ų¤Ā£Ų„Ų¦Ų§ŲØŲ©ŲŖŲ«Ų¬Ų­Ų®ŲÆŲ°Ų±Ų²Ų³Ų“ŲµĀ«Ā»ā–‘ā–’ā–“ā”‚ā”¤ā•”ā•¢ā•–ā••ā•£ā•‘ā•—ā•ā•œā•›ā”ā””ā”“ā”¬ā”œā”€ā”¼ā•žā•Ÿā•šā•”ā•©ā•¦ā• ā•ā•¬ā•§ā•Øā•¤ā•„ā•™ā•˜ā•’ā•“ā•«ā•Ŗā”˜ā”Œā–ˆā–„ā–Œā–ā–€Ų¶Ų·ŲøŲ¹ŲŗŁĀµŁ‚ŁƒŁ„Ł…Ł†Ł‡ŁˆŁ‰ŁŠā‰”\u064b\u064c\u064d\u064e\u064f\u0650ā‰ˆĀ°āˆ™Ā·āˆšāæĀ²ā– \u00a0" + }, + + // Aliases of generated encodings. + "ascii8bit": "ascii", + "usascii": "ascii", + "ansix34": "ascii", + "ansix341968": "ascii", + "ansix341986": "ascii", + "csascii": "ascii", + "cp367": "ascii", + "ibm367": "ascii", + "isoir6": "ascii", + "iso646us": "ascii", + "iso646irv": "ascii", + "us": "ascii", + + "latin1": "iso88591", + "latin2": "iso88592", + "latin3": "iso88593", + "latin4": "iso88594", + "latin5": "iso88599", + "latin6": "iso885910", + "latin7": "iso885913", + "latin8": "iso885914", + "latin9": "iso885915", + "latin10": "iso885916", + + "csisolatin1": "iso88591", + "csisolatin2": "iso88592", + "csisolatin3": "iso88593", + "csisolatin4": "iso88594", + "csisolatincyrillic": "iso88595", + "csisolatinarabic": "iso88596", + "csisolatingreek" : "iso88597", + "csisolatinhebrew": "iso88598", + "csisolatin5": "iso88599", + "csisolatin6": "iso885910", + + "l1": "iso88591", + "l2": "iso88592", + "l3": "iso88593", + "l4": "iso88594", + "l5": "iso88599", + "l6": "iso885910", + "l7": "iso885913", + "l8": "iso885914", + "l9": "iso885915", + "l10": "iso885916", + + "isoir14": "iso646jp", + "isoir57": "iso646cn", + "isoir100": "iso88591", + "isoir101": "iso88592", + "isoir109": "iso88593", + "isoir110": "iso88594", + "isoir144": "iso88595", + "isoir127": "iso88596", + "isoir126": "iso88597", + "isoir138": "iso88598", + "isoir148": "iso88599", + "isoir157": "iso885910", + "isoir166": "tis620", + "isoir179": "iso885913", + "isoir199": "iso885914", + "isoir203": "iso885915", + "isoir226": "iso885916", + + "cp819": "iso88591", + "ibm819": "iso88591", + + "cyrillic": "iso88595", + + "arabic": "iso88596", + "arabic8": "iso88596", + "ecma114": "iso88596", + "asmo708": "iso88596", + + "greek" : "iso88597", + "greek8" : "iso88597", + "ecma118" : "iso88597", + "elot928" : "iso88597", + + "hebrew": "iso88598", + "hebrew8": "iso88598", + + "turkish": "iso88599", + "turkish8": "iso88599", + + "thai": "iso885911", + "thai8": "iso885911", + + "celtic": "iso885914", + "celtic8": "iso885914", + "isoceltic": "iso885914", + + "tis6200": "tis620", + "tis62025291": "tis620", + "tis62025330": "tis620", + + "10000": "macroman", + "10006": "macgreek", + "10007": "maccyrillic", + "10079": "maciceland", + "10081": "macturkish", + + "cspc8codepage437": "cp437", + "cspc775baltic": "cp775", + "cspc850multilingual": "cp850", + "cspcp852": "cp852", + "cspc862latinhebrew": "cp862", + "cpgr": "cp869", + + "msee": "cp1250", + "mscyrl": "cp1251", + "msansi": "cp1252", + "msgreek": "cp1253", + "msturk": "cp1254", + "mshebr": "cp1255", + "msarab": "cp1256", + "winbaltrim": "cp1257", + + "cp20866": "koi8r", + "20866": "koi8r", + "ibm878": "koi8r", + "cskoi8r": "koi8r", + + "cp21866": "koi8u", + "21866": "koi8u", + "ibm1168": "koi8u", + + "strk10482002": "rk1048", + + "tcvn5712": "tcvn", + "tcvn57121": "tcvn", + + "gb198880": "iso646cn", + "cn": "iso646cn", + + "csiso14jisc6220ro": "iso646jp", + "jisc62201969ro": "iso646jp", + "jp": "iso646jp", + + "cshproman8": "hproman8", + "r8": "hproman8", + "roman8": "hproman8", + "xroman8": "hproman8", + "ibm1051": "hproman8", + + "mac": "macintosh", + "csmacintosh": "macintosh", +}; + + + +/***/ }), + +/***/ 8787: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +var Buffer = __nccwpck_require__(5118).Buffer; + +// Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js + +// == UTF16-BE codec. ========================================================== + +exports.utf16be = Utf16BECodec; +function Utf16BECodec() { +} + +Utf16BECodec.prototype.encoder = Utf16BEEncoder; +Utf16BECodec.prototype.decoder = Utf16BEDecoder; +Utf16BECodec.prototype.bomAware = true; + + +// -- Encoding + +function Utf16BEEncoder() { +} + +Utf16BEEncoder.prototype.write = function(str) { + var buf = Buffer.from(str, 'ucs2'); + for (var i = 0; i < buf.length; i += 2) { + var tmp = buf[i]; buf[i] = buf[i+1]; buf[i+1] = tmp; + } + return buf; +} + +Utf16BEEncoder.prototype.end = function() { +} + + +// -- Decoding + +function Utf16BEDecoder() { + this.overflowByte = -1; +} + +Utf16BEDecoder.prototype.write = function(buf) { + if (buf.length == 0) + return ''; + + var buf2 = Buffer.alloc(buf.length + 1), + i = 0, j = 0; + + if (this.overflowByte !== -1) { + buf2[0] = buf[0]; + buf2[1] = this.overflowByte; + i = 1; j = 2; + } + + for (; i < buf.length-1; i += 2, j+= 2) { + buf2[j] = buf[i+1]; + buf2[j+1] = buf[i]; + } + + this.overflowByte = (i == buf.length-1) ? buf[buf.length-1] : -1; + + return buf2.slice(0, j).toString('ucs2'); +} + +Utf16BEDecoder.prototype.end = function() { + this.overflowByte = -1; +} + + +// == UTF-16 codec ============================================================= +// Decoder chooses automatically from UTF-16LE and UTF-16BE using BOM and space-based heuristic. +// Defaults to UTF-16LE, as it's prevalent and default in Node. +// http://en.wikipedia.org/wiki/UTF-16 and http://encoding.spec.whatwg.org/#utf-16le +// Decoder default can be changed: iconv.decode(buf, 'utf16', {defaultEncoding: 'utf-16be'}); + +// Encoder uses UTF-16LE and prepends BOM (which can be overridden with addBOM: false). + +exports.utf16 = Utf16Codec; +function Utf16Codec(codecOptions, iconv) { + this.iconv = iconv; +} + +Utf16Codec.prototype.encoder = Utf16Encoder; +Utf16Codec.prototype.decoder = Utf16Decoder; + + +// -- Encoding (pass-through) + +function Utf16Encoder(options, codec) { + options = options || {}; + if (options.addBOM === undefined) + options.addBOM = true; + this.encoder = codec.iconv.getEncoder('utf-16le', options); +} + +Utf16Encoder.prototype.write = function(str) { + return this.encoder.write(str); +} + +Utf16Encoder.prototype.end = function() { + return this.encoder.end(); +} + + +// -- Decoding + +function Utf16Decoder(options, codec) { + this.decoder = null; + this.initialBufs = []; + this.initialBufsLen = 0; + + this.options = options || {}; + this.iconv = codec.iconv; +} + +Utf16Decoder.prototype.write = function(buf) { + if (!this.decoder) { + // Codec is not chosen yet. Accumulate initial bytes. + this.initialBufs.push(buf); + this.initialBufsLen += buf.length; + + if (this.initialBufsLen < 16) // We need more bytes to use space heuristic (see below) + return ''; + + // We have enough bytes -> detect endianness. + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + + var resStr = ''; + for (var i = 0; i < this.initialBufs.length; i++) + resStr += this.decoder.write(this.initialBufs[i]); + + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + + return this.decoder.write(buf); +} + +Utf16Decoder.prototype.end = function() { + if (!this.decoder) { + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + + var resStr = ''; + for (var i = 0; i < this.initialBufs.length; i++) + resStr += this.decoder.write(this.initialBufs[i]); + + var trail = this.decoder.end(); + if (trail) + resStr += trail; + + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + return this.decoder.end(); +} + +function detectEncoding(bufs, defaultEncoding) { + var b = []; + var charsProcessed = 0; + var asciiCharsLE = 0, asciiCharsBE = 0; // Number of ASCII chars when decoded as LE or BE. + + outer_loop: + for (var i = 0; i < bufs.length; i++) { + var buf = bufs[i]; + for (var j = 0; j < buf.length; j++) { + b.push(buf[j]); + if (b.length === 2) { + if (charsProcessed === 0) { + // Check BOM first. + if (b[0] === 0xFF && b[1] === 0xFE) return 'utf-16le'; + if (b[0] === 0xFE && b[1] === 0xFF) return 'utf-16be'; + } + + if (b[0] === 0 && b[1] !== 0) asciiCharsBE++; + if (b[0] !== 0 && b[1] === 0) asciiCharsLE++; + + b.length = 0; + charsProcessed++; + + if (charsProcessed >= 100) { + break outer_loop; + } + } + } + } + + // Make decisions. + // Most of the time, the content has ASCII chars (U+00**), but the opposite (U+**00) is uncommon. + // So, we count ASCII as if it was LE or BE, and decide from that. + if (asciiCharsBE > asciiCharsLE) return 'utf-16be'; + if (asciiCharsBE < asciiCharsLE) return 'utf-16le'; + + // Couldn't decide (likely all zeros or not enough data). + return defaultEncoding || 'utf-16le'; +} + + + + +/***/ }), + +/***/ 4927: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +var Buffer = __nccwpck_require__(5118).Buffer; + +// == UTF32-LE/BE codec. ========================================================== + +exports._utf32 = Utf32Codec; + +function Utf32Codec(codecOptions, iconv) { + this.iconv = iconv; + this.bomAware = true; + this.isLE = codecOptions.isLE; +} + +exports.utf32le = { type: '_utf32', isLE: true }; +exports.utf32be = { type: '_utf32', isLE: false }; + +// Aliases +exports.ucs4le = 'utf32le'; +exports.ucs4be = 'utf32be'; + +Utf32Codec.prototype.encoder = Utf32Encoder; +Utf32Codec.prototype.decoder = Utf32Decoder; + +// -- Encoding + +function Utf32Encoder(options, codec) { + this.isLE = codec.isLE; + this.highSurrogate = 0; +} + +Utf32Encoder.prototype.write = function(str) { + var src = Buffer.from(str, 'ucs2'); + var dst = Buffer.alloc(src.length * 2); + var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE; + var offset = 0; + + for (var i = 0; i < src.length; i += 2) { + var code = src.readUInt16LE(i); + var isHighSurrogate = (0xD800 <= code && code < 0xDC00); + var isLowSurrogate = (0xDC00 <= code && code < 0xE000); + + if (this.highSurrogate) { + if (isHighSurrogate || !isLowSurrogate) { + // There shouldn't be two high surrogates in a row, nor a high surrogate which isn't followed by a low + // surrogate. If this happens, keep the pending high surrogate as a stand-alone semi-invalid character + // (technically wrong, but expected by some applications, like Windows file names). + write32.call(dst, this.highSurrogate, offset); + offset += 4; + } + else { + // Create 32-bit value from high and low surrogates; + var codepoint = (((this.highSurrogate - 0xD800) << 10) | (code - 0xDC00)) + 0x10000; + + write32.call(dst, codepoint, offset); + offset += 4; + this.highSurrogate = 0; + + continue; + } + } + + if (isHighSurrogate) + this.highSurrogate = code; + else { + // Even if the current character is a low surrogate, with no previous high surrogate, we'll + // encode it as a semi-invalid stand-alone character for the same reasons expressed above for + // unpaired high surrogates. + write32.call(dst, code, offset); + offset += 4; + this.highSurrogate = 0; + } + } + + if (offset < dst.length) + dst = dst.slice(0, offset); + + return dst; +}; + +Utf32Encoder.prototype.end = function() { + // Treat any leftover high surrogate as a semi-valid independent character. + if (!this.highSurrogate) + return; + + var buf = Buffer.alloc(4); + + if (this.isLE) + buf.writeUInt32LE(this.highSurrogate, 0); + else + buf.writeUInt32BE(this.highSurrogate, 0); + + this.highSurrogate = 0; + + return buf; +}; + +// -- Decoding + +function Utf32Decoder(options, codec) { + this.isLE = codec.isLE; + this.badChar = codec.iconv.defaultCharUnicode.charCodeAt(0); + this.overflow = []; +} + +Utf32Decoder.prototype.write = function(src) { + if (src.length === 0) + return ''; + + var i = 0; + var codepoint = 0; + var dst = Buffer.alloc(src.length + 4); + var offset = 0; + var isLE = this.isLE; + var overflow = this.overflow; + var badChar = this.badChar; + + if (overflow.length > 0) { + for (; i < src.length && overflow.length < 4; i++) + overflow.push(src[i]); + + if (overflow.length === 4) { + // NOTE: codepoint is a signed int32 and can be negative. + // NOTE: We copied this block from below to help V8 optimize it (it works with array, not buffer). + if (isLE) { + codepoint = overflow[i] | (overflow[i+1] << 8) | (overflow[i+2] << 16) | (overflow[i+3] << 24); + } else { + codepoint = overflow[i+3] | (overflow[i+2] << 8) | (overflow[i+1] << 16) | (overflow[i] << 24); + } + overflow.length = 0; + + offset = _writeCodepoint(dst, offset, codepoint, badChar); + } + } + + // Main loop. Should be as optimized as possible. + for (; i < src.length - 3; i += 4) { + // NOTE: codepoint is a signed int32 and can be negative. + if (isLE) { + codepoint = src[i] | (src[i+1] << 8) | (src[i+2] << 16) | (src[i+3] << 24); + } else { + codepoint = src[i+3] | (src[i+2] << 8) | (src[i+1] << 16) | (src[i] << 24); + } + offset = _writeCodepoint(dst, offset, codepoint, badChar); + } + + // Keep overflowing bytes. + for (; i < src.length; i++) { + overflow.push(src[i]); + } + + return dst.slice(0, offset).toString('ucs2'); +}; + +function _writeCodepoint(dst, offset, codepoint, badChar) { + // NOTE: codepoint is signed int32 and can be negative. We keep it that way to help V8 with optimizations. + if (codepoint < 0 || codepoint > 0x10FFFF) { + // Not a valid Unicode codepoint + codepoint = badChar; + } + + // Ephemeral Planes: Write high surrogate. + if (codepoint >= 0x10000) { + codepoint -= 0x10000; + + var high = 0xD800 | (codepoint >> 10); + dst[offset++] = high & 0xff; + dst[offset++] = high >> 8; + + // Low surrogate is written below. + var codepoint = 0xDC00 | (codepoint & 0x3FF); + } + + // Write BMP char or low surrogate. + dst[offset++] = codepoint & 0xff; + dst[offset++] = codepoint >> 8; + + return offset; +}; + +Utf32Decoder.prototype.end = function() { + this.overflow.length = 0; +}; + +// == UTF-32 Auto codec ============================================================= +// Decoder chooses automatically from UTF-32LE and UTF-32BE using BOM and space-based heuristic. +// Defaults to UTF-32LE. http://en.wikipedia.org/wiki/UTF-32 +// Encoder/decoder default can be changed: iconv.decode(buf, 'utf32', {defaultEncoding: 'utf-32be'}); + +// Encoder prepends BOM (which can be overridden with (addBOM: false}). + +exports.utf32 = Utf32AutoCodec; +exports.ucs4 = 'utf32'; + +function Utf32AutoCodec(options, iconv) { + this.iconv = iconv; +} + +Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder; +Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder; + +// -- Encoding + +function Utf32AutoEncoder(options, codec) { + options = options || {}; + + if (options.addBOM === undefined) + options.addBOM = true; + + this.encoder = codec.iconv.getEncoder(options.defaultEncoding || 'utf-32le', options); +} + +Utf32AutoEncoder.prototype.write = function(str) { + return this.encoder.write(str); +}; + +Utf32AutoEncoder.prototype.end = function() { + return this.encoder.end(); +}; + +// -- Decoding + +function Utf32AutoDecoder(options, codec) { + this.decoder = null; + this.initialBufs = []; + this.initialBufsLen = 0; + this.options = options || {}; + this.iconv = codec.iconv; +} + +Utf32AutoDecoder.prototype.write = function(buf) { + if (!this.decoder) { + // Codec is not chosen yet. Accumulate initial bytes. + this.initialBufs.push(buf); + this.initialBufsLen += buf.length; + + if (this.initialBufsLen < 32) // We need more bytes to use space heuristic (see below) + return ''; + + // We have enough bytes -> detect endianness. + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + + var resStr = ''; + for (var i = 0; i < this.initialBufs.length; i++) + resStr += this.decoder.write(this.initialBufs[i]); + + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + + return this.decoder.write(buf); +}; + +Utf32AutoDecoder.prototype.end = function() { + if (!this.decoder) { + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + + var resStr = ''; + for (var i = 0; i < this.initialBufs.length; i++) + resStr += this.decoder.write(this.initialBufs[i]); + + var trail = this.decoder.end(); + if (trail) + resStr += trail; + + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + + return this.decoder.end(); +}; + +function detectEncoding(bufs, defaultEncoding) { + var b = []; + var charsProcessed = 0; + var invalidLE = 0, invalidBE = 0; // Number of invalid chars when decoded as LE or BE. + var bmpCharsLE = 0, bmpCharsBE = 0; // Number of BMP chars when decoded as LE or BE. + + outer_loop: + for (var i = 0; i < bufs.length; i++) { + var buf = bufs[i]; + for (var j = 0; j < buf.length; j++) { + b.push(buf[j]); + if (b.length === 4) { + if (charsProcessed === 0) { + // Check BOM first. + if (b[0] === 0xFF && b[1] === 0xFE && b[2] === 0 && b[3] === 0) { + return 'utf-32le'; + } + if (b[0] === 0 && b[1] === 0 && b[2] === 0xFE && b[3] === 0xFF) { + return 'utf-32be'; + } + } + + if (b[0] !== 0 || b[1] > 0x10) invalidBE++; + if (b[3] !== 0 || b[2] > 0x10) invalidLE++; + + if (b[0] === 0 && b[1] === 0 && (b[2] !== 0 || b[3] !== 0)) bmpCharsBE++; + if ((b[0] !== 0 || b[1] !== 0) && b[2] === 0 && b[3] === 0) bmpCharsLE++; + + b.length = 0; + charsProcessed++; + + if (charsProcessed >= 100) { + break outer_loop; + } + } + } + } + + // Make decisions. + if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return 'utf-32be'; + if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return 'utf-32le'; + + // Couldn't decide (likely all zeros or not enough data). + return defaultEncoding || 'utf-32le'; +} + + +/***/ }), + +/***/ 6208: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +var Buffer = __nccwpck_require__(5118).Buffer; + +// UTF-7 codec, according to https://tools.ietf.org/html/rfc2152 +// See also below a UTF-7-IMAP codec, according to http://tools.ietf.org/html/rfc3501#section-5.1.3 + +exports.utf7 = Utf7Codec; +exports.unicode11utf7 = 'utf7'; // Alias UNICODE-1-1-UTF-7 +function Utf7Codec(codecOptions, iconv) { + this.iconv = iconv; +}; + +Utf7Codec.prototype.encoder = Utf7Encoder; +Utf7Codec.prototype.decoder = Utf7Decoder; +Utf7Codec.prototype.bomAware = true; + + +// -- Encoding + +var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g; + +function Utf7Encoder(options, codec) { + this.iconv = codec.iconv; +} + +Utf7Encoder.prototype.write = function(str) { + // Naive implementation. + // Non-direct chars are encoded as "+-"; single "+" char is encoded as "+-". + return Buffer.from(str.replace(nonDirectChars, function(chunk) { + return "+" + (chunk === '+' ? '' : + this.iconv.encode(chunk, 'utf16-be').toString('base64').replace(/=+$/, '')) + + "-"; + }.bind(this))); +} + +Utf7Encoder.prototype.end = function() { +} + + +// -- Decoding + +function Utf7Decoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = ''; +} + +var base64Regex = /[A-Za-z0-9\/+]/; +var base64Chars = []; +for (var i = 0; i < 256; i++) + base64Chars[i] = base64Regex.test(String.fromCharCode(i)); + +var plusChar = '+'.charCodeAt(0), + minusChar = '-'.charCodeAt(0), + andChar = '&'.charCodeAt(0); + +Utf7Decoder.prototype.write = function(buf) { + var res = "", lastI = 0, + inBase64 = this.inBase64, + base64Accum = this.base64Accum; + + // The decoder is more involved as we must handle chunks in stream. + + for (var i = 0; i < buf.length; i++) { + if (!inBase64) { // We're in direct mode. + // Write direct chars until '+' + if (buf[i] == plusChar) { + res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars. + lastI = i+1; + inBase64 = true; + } + } else { // We decode base64. + if (!base64Chars[buf[i]]) { // Base64 ended. + if (i == lastI && buf[i] == minusChar) {// "+-" -> "+" + res += "+"; + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i), "ascii"); + res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be"); + } + + if (buf[i] != minusChar) // Minus is absorbed after base64. + i--; + + lastI = i+1; + inBase64 = false; + base64Accum = ''; + } + } + } + + if (!inBase64) { + res += this.iconv.decode(buf.slice(lastI), "ascii"); // Write direct chars. + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii"); + + var canBeDecoded = b64str.length - (b64str.length % 8); // Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars. + base64Accum = b64str.slice(canBeDecoded); // The rest will be decoded in future. + b64str = b64str.slice(0, canBeDecoded); + + res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be"); + } + + this.inBase64 = inBase64; + this.base64Accum = base64Accum; + + return res; +} + +Utf7Decoder.prototype.end = function() { + var res = ""; + if (this.inBase64 && this.base64Accum.length > 0) + res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be"); + + this.inBase64 = false; + this.base64Accum = ''; + return res; +} + + +// UTF-7-IMAP codec. +// RFC3501 Sec. 5.1.3 Modified UTF-7 (http://tools.ietf.org/html/rfc3501#section-5.1.3) +// Differences: +// * Base64 part is started by "&" instead of "+" +// * Direct characters are 0x20-0x7E, except "&" (0x26) +// * In Base64, "," is used instead of "/" +// * Base64 must not be used to represent direct characters. +// * No implicit shift back from Base64 (should always end with '-') +// * String must end in non-shifted position. +// * "-&" while in base64 is not allowed. + + +exports.utf7imap = Utf7IMAPCodec; +function Utf7IMAPCodec(codecOptions, iconv) { + this.iconv = iconv; +}; + +Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder; +Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder; +Utf7IMAPCodec.prototype.bomAware = true; + + +// -- Encoding + +function Utf7IMAPEncoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = Buffer.alloc(6); + this.base64AccumIdx = 0; +} + +Utf7IMAPEncoder.prototype.write = function(str) { + var inBase64 = this.inBase64, + base64Accum = this.base64Accum, + base64AccumIdx = this.base64AccumIdx, + buf = Buffer.alloc(str.length*5 + 10), bufIdx = 0; + + for (var i = 0; i < str.length; i++) { + var uChar = str.charCodeAt(i); + if (0x20 <= uChar && uChar <= 0x7E) { // Direct character or '&'. + if (inBase64) { + if (base64AccumIdx > 0) { + bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString('base64').replace(/\//g, ',').replace(/=+$/, ''), bufIdx); + base64AccumIdx = 0; + } + + buf[bufIdx++] = minusChar; // Write '-', then go to direct mode. + inBase64 = false; + } + + if (!inBase64) { + buf[bufIdx++] = uChar; // Write direct character + + if (uChar === andChar) // Ampersand -> '&-' + buf[bufIdx++] = minusChar; + } + + } else { // Non-direct character + if (!inBase64) { + buf[bufIdx++] = andChar; // Write '&', then go to base64 mode. + inBase64 = true; + } + if (inBase64) { + base64Accum[base64AccumIdx++] = uChar >> 8; + base64Accum[base64AccumIdx++] = uChar & 0xFF; + + if (base64AccumIdx == base64Accum.length) { + bufIdx += buf.write(base64Accum.toString('base64').replace(/\//g, ','), bufIdx); + base64AccumIdx = 0; + } + } + } + } + + this.inBase64 = inBase64; + this.base64AccumIdx = base64AccumIdx; + + return buf.slice(0, bufIdx); +} + +Utf7IMAPEncoder.prototype.end = function() { + var buf = Buffer.alloc(10), bufIdx = 0; + if (this.inBase64) { + if (this.base64AccumIdx > 0) { + bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString('base64').replace(/\//g, ',').replace(/=+$/, ''), bufIdx); + this.base64AccumIdx = 0; + } + + buf[bufIdx++] = minusChar; // Write '-', then go to direct mode. + this.inBase64 = false; + } + + return buf.slice(0, bufIdx); +} + + +// -- Decoding + +function Utf7IMAPDecoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = ''; +} + +var base64IMAPChars = base64Chars.slice(); +base64IMAPChars[','.charCodeAt(0)] = true; + +Utf7IMAPDecoder.prototype.write = function(buf) { + var res = "", lastI = 0, + inBase64 = this.inBase64, + base64Accum = this.base64Accum; + + // The decoder is more involved as we must handle chunks in stream. + // It is forgiving, closer to standard UTF-7 (for example, '-' is optional at the end). + + for (var i = 0; i < buf.length; i++) { + if (!inBase64) { // We're in direct mode. + // Write direct chars until '&' + if (buf[i] == andChar) { + res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars. + lastI = i+1; + inBase64 = true; + } + } else { // We decode base64. + if (!base64IMAPChars[buf[i]]) { // Base64 ended. + if (i == lastI && buf[i] == minusChar) { // "&-" -> "&" + res += "&"; + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i), "ascii").replace(/,/g, '/'); + res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be"); + } + + if (buf[i] != minusChar) // Minus may be absorbed after base64. + i--; + + lastI = i+1; + inBase64 = false; + base64Accum = ''; + } + } + } + + if (!inBase64) { + res += this.iconv.decode(buf.slice(lastI), "ascii"); // Write direct chars. + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii").replace(/,/g, '/'); + + var canBeDecoded = b64str.length - (b64str.length % 8); // Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars. + base64Accum = b64str.slice(canBeDecoded); // The rest will be decoded in future. + b64str = b64str.slice(0, canBeDecoded); + + res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be"); + } + + this.inBase64 = inBase64; + this.base64Accum = base64Accum; + + return res; +} + +Utf7IMAPDecoder.prototype.end = function() { + var res = ""; + if (this.inBase64 && this.base64Accum.length > 0) + res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be"); + + this.inBase64 = false; + this.base64Accum = ''; + return res; +} + + + + +/***/ }), + +/***/ 3824: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +var BOMChar = '\uFEFF'; + +exports.PrependBOM = PrependBOMWrapper +function PrependBOMWrapper(encoder, options) { + this.encoder = encoder; + this.addBOM = true; +} + +PrependBOMWrapper.prototype.write = function(str) { + if (this.addBOM) { + str = BOMChar + str; + this.addBOM = false; + } + + return this.encoder.write(str); +} + +PrependBOMWrapper.prototype.end = function() { + return this.encoder.end(); +} + + +//------------------------------------------------------------------------------ + +exports.StripBOM = StripBOMWrapper; +function StripBOMWrapper(decoder, options) { + this.decoder = decoder; + this.pass = false; + this.options = options || {}; +} + +StripBOMWrapper.prototype.write = function(buf) { + var res = this.decoder.write(buf); + if (this.pass || !res) + return res; + + if (res[0] === BOMChar) { + res = res.slice(1); + if (typeof this.options.stripBOM === 'function') + this.options.stripBOM(); + } + + this.pass = true; + return res; +} + +StripBOMWrapper.prototype.end = function() { + return this.decoder.end(); +} + + + +/***/ }), + +/***/ 7813: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Buffer = __nccwpck_require__(5118).Buffer; + +var bomHandling = __nccwpck_require__(3824), + iconv = module.exports; + +// All codecs and aliases are kept here, keyed by encoding name/alias. +// They are lazy loaded in `iconv.getCodec` from `encodings/index.js`. +iconv.encodings = null; + +// Characters emitted in case of error. +iconv.defaultCharUnicode = 'ļæ½'; +iconv.defaultCharSingleByte = '?'; + +// Public API. +iconv.encode = function encode(str, encoding, options) { + str = "" + (str || ""); // Ensure string. + + var encoder = iconv.getEncoder(encoding, options); + + var res = encoder.write(str); + var trail = encoder.end(); + + return (trail && trail.length > 0) ? Buffer.concat([res, trail]) : res; +} + +iconv.decode = function decode(buf, encoding, options) { + if (typeof buf === 'string') { + if (!iconv.skipDecodeWarning) { + console.error('Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding'); + iconv.skipDecodeWarning = true; + } + + buf = Buffer.from("" + (buf || ""), "binary"); // Ensure buffer. + } + + var decoder = iconv.getDecoder(encoding, options); + + var res = decoder.write(buf); + var trail = decoder.end(); + + return trail ? (res + trail) : res; +} + +iconv.encodingExists = function encodingExists(enc) { + try { + iconv.getCodec(enc); + return true; + } catch (e) { + return false; + } +} + +// Legacy aliases to convert functions +iconv.toEncoding = iconv.encode; +iconv.fromEncoding = iconv.decode; + +// Search for a codec in iconv.encodings. Cache codec data in iconv._codecDataCache. +iconv._codecDataCache = {}; +iconv.getCodec = function getCodec(encoding) { + if (!iconv.encodings) + iconv.encodings = __nccwpck_require__(9541); // Lazy load all encoding definitions. + + // Canonicalize encoding name: strip all non-alphanumeric chars and appended year. + var enc = iconv._canonicalizeEncoding(encoding); + + // Traverse iconv.encodings to find actual codec. + var codecOptions = {}; + while (true) { + var codec = iconv._codecDataCache[enc]; + if (codec) + return codec; + + var codecDef = iconv.encodings[enc]; + + switch (typeof codecDef) { + case "string": // Direct alias to other encoding. + enc = codecDef; + break; + + case "object": // Alias with options. Can be layered. + for (var key in codecDef) + codecOptions[key] = codecDef[key]; + + if (!codecOptions.encodingName) + codecOptions.encodingName = enc; + + enc = codecDef.type; + break; + + case "function": // Codec itself. + if (!codecOptions.encodingName) + codecOptions.encodingName = enc; + + // The codec function must load all tables and return object with .encoder and .decoder methods. + // It'll be called only once (for each different options object). + codec = new codecDef(codecOptions, iconv); + + iconv._codecDataCache[codecOptions.encodingName] = codec; // Save it to be reused later. + return codec; + + default: + throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '"+enc+"')"); + } + } +} + +iconv._canonicalizeEncoding = function(encoding) { + // Canonicalize encoding name: strip all non-alphanumeric chars and appended year. + return (''+encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, ""); +} + +iconv.getEncoder = function getEncoder(encoding, options) { + var codec = iconv.getCodec(encoding), + encoder = new codec.encoder(options, codec); + + if (codec.bomAware && options && options.addBOM) + encoder = new bomHandling.PrependBOM(encoder, options); + + return encoder; +} + +iconv.getDecoder = function getDecoder(encoding, options) { + var codec = iconv.getCodec(encoding), + decoder = new codec.decoder(options, codec); + + if (codec.bomAware && !(options && options.stripBOM === false)) + decoder = new bomHandling.StripBOM(decoder, options); + + return decoder; +} + +// Streaming API +// NOTE: Streaming API naturally depends on 'stream' module from Node.js. Unfortunately in browser environments this module can add +// up to 100Kb to the output bundle. To avoid unnecessary code bloat, we don't enable Streaming API in browser by default. +// If you would like to enable it explicitly, please add the following code to your app: +// > iconv.enableStreamingAPI(require('stream')); +iconv.enableStreamingAPI = function enableStreamingAPI(stream_module) { + if (iconv.supportsStreams) + return; + + // Dependency-inject stream module to create IconvLite stream classes. + var streams = __nccwpck_require__(9868)(stream_module); + + // Not public API yet, but expose the stream classes. + iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream; + iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream; + + // Streaming API. + iconv.encodeStream = function encodeStream(encoding, options) { + return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options); + } + + iconv.decodeStream = function decodeStream(encoding, options) { + return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options); + } + + iconv.supportsStreams = true; +} + +// Enable Streaming API automatically if 'stream' module is available and non-empty (the majority of environments). +var stream_module; +try { + stream_module = __nccwpck_require__(2413); +} catch (e) {} + +if (stream_module && stream_module.Transform) { + iconv.enableStreamingAPI(stream_module); + +} else { + // In rare cases where 'stream' module is not available by default, throw a helpful exception. + iconv.encodeStream = iconv.decodeStream = function() { + throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it."); + }; +} + +if (false) {} + + +/***/ }), + +/***/ 9868: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Buffer = __nccwpck_require__(5118).Buffer; + +// NOTE: Due to 'stream' module being pretty large (~100Kb, significant in browser environments), +// we opt to dependency-inject it instead of creating a hard dependency. +module.exports = function(stream_module) { + var Transform = stream_module.Transform; + + // == Encoder stream ======================================================= + + function IconvLiteEncoderStream(conv, options) { + this.conv = conv; + options = options || {}; + options.decodeStrings = false; // We accept only strings, so we don't need to decode them. + Transform.call(this, options); + } + + IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, { + constructor: { value: IconvLiteEncoderStream } + }); + + IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) { + if (typeof chunk != 'string') + return done(new Error("Iconv encoding stream needs strings as its input.")); + try { + var res = this.conv.write(chunk); + if (res && res.length) this.push(res); + done(); + } + catch (e) { + done(e); + } + } + + IconvLiteEncoderStream.prototype._flush = function(done) { + try { + var res = this.conv.end(); + if (res && res.length) this.push(res); + done(); + } + catch (e) { + done(e); + } + } + + IconvLiteEncoderStream.prototype.collect = function(cb) { + var chunks = []; + this.on('error', cb); + this.on('data', function(chunk) { chunks.push(chunk); }); + this.on('end', function() { + cb(null, Buffer.concat(chunks)); + }); + return this; + } + + + // == Decoder stream ======================================================= + + function IconvLiteDecoderStream(conv, options) { + this.conv = conv; + options = options || {}; + options.encoding = this.encoding = 'utf8'; // We output strings. + Transform.call(this, options); + } + + IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, { + constructor: { value: IconvLiteDecoderStream } + }); + + IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) { + if (!Buffer.isBuffer(chunk) && !(chunk instanceof Uint8Array)) + return done(new Error("Iconv decoding stream needs buffers as its input.")); + try { + var res = this.conv.write(chunk); + if (res && res.length) this.push(res, this.encoding); + done(); + } + catch (e) { + done(e); + } + } + + IconvLiteDecoderStream.prototype._flush = function(done) { + try { + var res = this.conv.end(); + if (res && res.length) this.push(res, this.encoding); + done(); + } + catch (e) { + done(e); + } + } + + IconvLiteDecoderStream.prototype.collect = function(cb) { + var res = ''; + this.on('error', cb); + this.on('data', function(chunk) { res += chunk; }); + this.on('end', function() { + cb(null, res); + }); + return this; + } + + return { + IconvLiteEncoderStream: IconvLiteEncoderStream, + IconvLiteDecoderStream: IconvLiteDecoderStream, + }; +}; + + +/***/ }), + +/***/ 5902: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var hashClear = __nccwpck_require__(1789), + hashDelete = __nccwpck_require__(712), + hashGet = __nccwpck_require__(5395), + hashHas = __nccwpck_require__(5232), + hashSet = __nccwpck_require__(7320); + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +module.exports = Hash; + + +/***/ }), + +/***/ 6608: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var listCacheClear = __nccwpck_require__(9792), + listCacheDelete = __nccwpck_require__(7716), + listCacheGet = __nccwpck_require__(5789), + listCacheHas = __nccwpck_require__(9386), + listCacheSet = __nccwpck_require__(7399); + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +module.exports = ListCache; + + +/***/ }), + +/***/ 881: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var getNative = __nccwpck_require__(4479), + root = __nccwpck_require__(9882); + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'); + +module.exports = Map; + + +/***/ }), + +/***/ 938: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var mapCacheClear = __nccwpck_require__(1610), + mapCacheDelete = __nccwpck_require__(6657), + mapCacheGet = __nccwpck_require__(1372), + mapCacheHas = __nccwpck_require__(609), + mapCacheSet = __nccwpck_require__(5582); + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +module.exports = MapCache; + + +/***/ }), + +/***/ 9213: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var root = __nccwpck_require__(9882); + +/** Built-in value references. */ +var Symbol = root.Symbol; + +module.exports = Symbol; + + +/***/ }), + +/***/ 4356: +/***/ ((module) => { + +/** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ +function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; +} + +module.exports = arrayMap; + + +/***/ }), + +/***/ 6752: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var eq = __nccwpck_require__(1901); + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +module.exports = assocIndexOf; + + +/***/ }), + +/***/ 5758: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var castPath = __nccwpck_require__(2688), + toKey = __nccwpck_require__(9071); + +/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ +function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; +} + +module.exports = baseGet; + + +/***/ }), + +/***/ 7497: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var Symbol = __nccwpck_require__(9213), + getRawTag = __nccwpck_require__(923), + objectToString = __nccwpck_require__(4200); + +/** `Object#toString` result references. */ +var nullTag = '[object Null]', undefinedTag = '[object Undefined]'; /** Built-in value references. */ var symToStringTag = Symbol ? Symbol.toStringTag : undefined; /** - * The base implementation of `getTag` without fallbacks for buggy environments. + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); +} + +module.exports = baseGetTag; + + +/***/ }), + +/***/ 411: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var isFunction = __nccwpck_require__(7799), + isMasked = __nccwpck_require__(9058), + isObject = __nccwpck_require__(3334), + toSource = __nccwpck_require__(6928); + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Used for built-in method references. */ +var funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +module.exports = baseIsNative; + + +/***/ }), + +/***/ 6792: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var Symbol = __nccwpck_require__(9213), + arrayMap = __nccwpck_require__(4356), + isArray = __nccwpck_require__(4869), + isSymbol = __nccwpck_require__(6403); + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +module.exports = baseToString; + + +/***/ }), + +/***/ 2688: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var isArray = __nccwpck_require__(4869), + isKey = __nccwpck_require__(9084), + stringToPath = __nccwpck_require__(1853), + toString = __nccwpck_require__(2931); + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); +} + +module.exports = castPath; + + +/***/ }), + +/***/ 8380: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var root = __nccwpck_require__(9882); + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +module.exports = coreJsData; + + +/***/ }), + +/***/ 2085: +/***/ ((module) => { + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +module.exports = freeGlobal; + + +/***/ }), + +/***/ 9980: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var isKeyable = __nccwpck_require__(3308); + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +module.exports = getMapData; + + +/***/ }), + +/***/ 4479: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var baseIsNative = __nccwpck_require__(411), + getValue = __nccwpck_require__(3542); + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +module.exports = getNative; + + +/***/ }), + +/***/ 923: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var Symbol = __nccwpck_require__(9213); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** Built-in value references. */ +var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. * * @private * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. + * @returns {string} Returns the raw `toStringTag`. */ -function baseGetTag(value) { - if (value == null) { - return value === undefined ? undefinedTag : nullTag; +function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } } - return (symToStringTag && symToStringTag in Object(value)) - ? getRawTag(value) - : objectToString(value); + return result; } -module.exports = baseGetTag; +module.exports = getRawTag; /***/ }), -/***/ 411: +/***/ 3542: +/***/ ((module) => { + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +module.exports = getValue; + + +/***/ }), + +/***/ 1789: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var isFunction = __nccwpck_require__(7799), - isMasked = __nccwpck_require__(9058), - isObject = __nccwpck_require__(3334), - toSource = __nccwpck_require__(6928); +var nativeCreate = __nccwpck_require__(3041); /** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash */ -var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; +} -/** Used to detect host constructors (Safari). */ -var reIsHostCtor = /^\[object .+?Constructor\]$/; +module.exports = hashClear; -/** Used for built-in method references. */ -var funcProto = Function.prototype, - objectProto = Object.prototype; -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; +/***/ }), + +/***/ 712: +/***/ ((module) => { + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} + +module.exports = hashDelete; + + +/***/ }), + +/***/ 5395: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var nativeCreate = __nccwpck_require__(3041); + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used for built-in method references. */ +var objectProto = Object.prototype; /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; -/** Used to detect if a method is native. */ -var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' -); +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +module.exports = hashGet; + + +/***/ }), + +/***/ 5232: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var nativeCreate = __nccwpck_require__(3041); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; /** - * The base implementation of `_.isNative` without bad shim checks. + * Checks if a hash value for `key` exists. * * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ -function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); } -module.exports = baseIsNative; +module.exports = hashHas; /***/ }), -/***/ 6792: +/***/ 7320: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var Symbol = __nccwpck_require__(9213), - arrayMap = __nccwpck_require__(4356), - isArray = __nccwpck_require__(4869), - isSymbol = __nccwpck_require__(6403); - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0; +var nativeCreate = __nccwpck_require__(3041); -/** Used to convert symbols to primitives and strings. */ -var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; /** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. + * Sets the hash `key` to `value`. * * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. */ -function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isArray(value)) { - // Recursively convert values (susceptible to call stack limits). - return arrayMap(value, baseToString) + ''; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; } -module.exports = baseToString; +module.exports = hashSet; /***/ }), -/***/ 2688: +/***/ 9084: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { var isArray = __nccwpck_require__(4869), - isKey = __nccwpck_require__(9084), - stringToPath = __nccwpck_require__(1853), - toString = __nccwpck_require__(2931); + isSymbol = __nccwpck_require__(6403); + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; /** - * Casts `value` to a path array if it's not one. + * Checks if `value` is a property name and not a property path. * * @private - * @param {*} value The value to inspect. + * @param {*} value The value to check. * @param {Object} [object] The object to query keys on. - * @returns {Array} Returns the cast property path array. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. */ -function castPath(value, object) { +function isKey(value, object) { if (isArray(value)) { - return value; + return false; } - return isKey(value, object) ? [value] : stringToPath(toString(value)); + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); } -module.exports = castPath; - - -/***/ }), - -/***/ 8380: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var root = __nccwpck_require__(9882); - -/** Used to detect overreaching core-js shims. */ -var coreJsData = root['__core-js_shared__']; - -module.exports = coreJsData; +module.exports = isKey; /***/ }), -/***/ 2085: +/***/ 3308: /***/ ((module) => { -/** Detect free variable `global` from Node.js. */ -var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} -module.exports = freeGlobal; +module.exports = isKeyable; /***/ }), -/***/ 9980: +/***/ 9058: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var isKeyable = __nccwpck_require__(3308); +var coreJsData = __nccwpck_require__(8380); + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); /** - * Gets the data for `map`. + * Checks if `func` has its source masked. * * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. */ -function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); } -module.exports = getMapData; +module.exports = isMasked; /***/ }), -/***/ 4479: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var baseIsNative = __nccwpck_require__(411), - getValue = __nccwpck_require__(3542); +/***/ 9792: +/***/ ((module) => { /** - * Gets the native function at `key` of `object`. + * Removes all key-value entries from the list cache. * * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. + * @name clear + * @memberOf ListCache */ -function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; +function listCacheClear() { + this.__data__ = []; + this.size = 0; } -module.exports = getNative; +module.exports = listCacheClear; /***/ }), -/***/ 923: +/***/ 7716: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var Symbol = __nccwpck_require__(9213); +var assocIndexOf = __nccwpck_require__(6752); /** Used for built-in method references. */ -var objectProto = Object.prototype; +var arrayProto = Array.prototype; -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; +/** Built-in value references. */ +var splice = arrayProto.splice; /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ -var nativeObjectToString = objectProto.toString; +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); -/** Built-in value references. */ -var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} + +module.exports = listCacheDelete; + + +/***/ }), + +/***/ 5789: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var assocIndexOf = __nccwpck_require__(6752); /** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * Gets the list cache value for `key`. * * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. */ -function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag]; +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); - try { - value[symToStringTag] = undefined; - var unmasked = true; - } catch (e) {} + return index < 0 ? undefined : data[index][1]; +} - var result = nativeObjectToString.call(value); - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag; - } else { - delete value[symToStringTag]; - } - } - return result; +module.exports = listCacheGet; + + +/***/ }), + +/***/ 9386: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var assocIndexOf = __nccwpck_require__(6752); + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; } -module.exports = getRawTag; +module.exports = listCacheHas; /***/ }), -/***/ 3542: -/***/ ((module) => { +/***/ 7399: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var assocIndexOf = __nccwpck_require__(6752); /** - * Gets the value at `key` of `object`. + * Sets the list cache `key` to `value`. * * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. */ -function getValue(object, key) { - return object == null ? undefined : object[key]; +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; } -module.exports = getValue; +module.exports = listCacheSet; /***/ }), -/***/ 1789: +/***/ 1610: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var nativeCreate = __nccwpck_require__(3041); +var Hash = __nccwpck_require__(5902), + ListCache = __nccwpck_require__(6608), + Map = __nccwpck_require__(881); /** - * Removes all key-value entries from the hash. + * Removes all key-value entries from the map. * * @private * @name clear - * @memberOf Hash + * @memberOf MapCache */ -function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; +function mapCacheClear() { this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; } -module.exports = hashClear; +module.exports = mapCacheClear; /***/ }), -/***/ 712: -/***/ ((module) => { +/***/ 6657: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var getMapData = __nccwpck_require__(9980); /** - * Removes `key` and its value from the hash. + * Removes `key` and its value from the map. * * @private * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. + * @memberOf MapCache * @param {string} key The key of the value to remove. * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ -function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key]; +function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); this.size -= result ? 1 : 0; return result; } -module.exports = hashDelete; +module.exports = mapCacheDelete; /***/ }), -/***/ 5395: +/***/ 1372: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var nativeCreate = __nccwpck_require__(3041); - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; +var getMapData = __nccwpck_require__(9980); /** - * Gets the hash value for `key`. + * Gets the map value for `key`. * * @private * @name get - * @memberOf Hash + * @memberOf MapCache * @param {string} key The key of the value to get. * @returns {*} Returns the entry value. */ -function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; +function mapCacheGet(key) { + return getMapData(this, key).get(key); } -module.exports = hashGet; +module.exports = mapCacheGet; /***/ }), -/***/ 5232: +/***/ 609: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var nativeCreate = __nccwpck_require__(3041); - -/** Used for built-in method references. */ -var objectProto = Object.prototype; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; +var getMapData = __nccwpck_require__(9980); /** - * Checks if a hash value for `key` exists. + * Checks if a map value for `key` exists. * * @private * @name has - * @memberOf Hash + * @memberOf MapCache * @param {string} key The key of the entry to check. * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. */ -function hashHas(key) { - var data = this.__data__; - return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); +function mapCacheHas(key) { + return getMapData(this, key).has(key); } -module.exports = hashHas; +module.exports = mapCacheHas; /***/ }), -/***/ 7320: +/***/ 5582: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var nativeCreate = __nccwpck_require__(3041); - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; +var getMapData = __nccwpck_require__(9980); /** - * Sets the hash `key` to `value`. + * Sets the map `key` to `value`. * * @private * @name set - * @memberOf Hash + * @memberOf MapCache * @param {string} key The key of the value to set. * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. + * @returns {Object} Returns the map cache instance. */ -function hashSet(key, value) { - var data = this.__data__; - this.size += this.has(key) ? 0 : 1; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; +function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; return this; } -module.exports = hashSet; +module.exports = mapCacheSet; /***/ }), -/***/ 9084: +/***/ 9422: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var isArray = __nccwpck_require__(4869), - isSymbol = __nccwpck_require__(6403); +var memoize = __nccwpck_require__(9885); -/** Used to match property names within property paths. */ -var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/; +/** Used as the maximum memoize cache size. */ +var MAX_MEMOIZE_SIZE = 500; /** - * Checks if `value` is a property name and not a property path. + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. * * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. */ -function isKey(value, object) { - if (isArray(value)) { - return false; - } - var type = typeof value; - if (type == 'number' || type == 'symbol' || type == 'boolean' || - value == null || isSymbol(value)) { - return true; - } - return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || - (object != null && value in Object(object)); +function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; } -module.exports = isKey; +module.exports = memoizeCapped; /***/ }), -/***/ 3308: -/***/ ((module) => { +/***/ 3041: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ -function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); -} +var getNative = __nccwpck_require__(4479); -module.exports = isKeyable; +/* Built-in method references that are verified to be native. */ +var nativeCreate = getNative(Object, 'create'); + +module.exports = nativeCreate; /***/ }), -/***/ 9058: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +/***/ 4200: +/***/ ((module) => { -var coreJsData = __nccwpck_require__(8380); +/** Used for built-in method references. */ +var objectProto = Object.prototype; -/** Used to detect methods masquerading as native. */ -var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; -}()); +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; /** - * Checks if `func` has its source masked. + * Converts `value` to a string using `Object.prototype.toString`. * * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. */ -function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); +function objectToString(value) { + return nativeObjectToString.call(value); } -module.exports = isMasked; +module.exports = objectToString; + + +/***/ }), + +/***/ 9882: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var freeGlobal = __nccwpck_require__(2085); + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +module.exports = root; /***/ }), -/***/ 9792: -/***/ ((module) => { +/***/ 1853: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var memoizeCapped = __nccwpck_require__(9422); + +/** Used to match property names within property paths. */ +var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; /** - * Removes all key-value entries from the list cache. + * Converts `string` to a property path array. * * @private - * @name clear - * @memberOf ListCache + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. */ -function listCacheClear() { - this.__data__ = []; - this.size = 0; -} +var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); -module.exports = listCacheClear; +module.exports = stringToPath; /***/ }), -/***/ 7716: +/***/ 9071: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var assocIndexOf = __nccwpck_require__(6752); - -/** Used for built-in method references. */ -var arrayProto = Array.prototype; +var isSymbol = __nccwpck_require__(6403); -/** Built-in value references. */ -var splice = arrayProto.splice; +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; /** - * Removes `key` and its value from the list cache. + * Converts `value` to a string key if it's not a string or symbol. * * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. */ -function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; } - --this.size; - return true; + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; } -module.exports = listCacheDelete; +module.exports = toKey; /***/ }), -/***/ 5789: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +/***/ 6928: +/***/ ((module) => { -var assocIndexOf = __nccwpck_require__(6752); +/** Used for built-in method references. */ +var funcProto = Function.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; /** - * Gets the list cache value for `key`. + * Converts `func` to its source code. * * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. */ -function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; } -module.exports = listCacheGet; +module.exports = toSource; /***/ }), -/***/ 9386: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var assocIndexOf = __nccwpck_require__(6752); +/***/ 1901: +/***/ ((module) => { /** - * Checks if a list cache value for `key` exists. + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true */ -function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; +function eq(value, other) { + return value === other || (value !== value && other !== other); } -module.exports = listCacheHas; +module.exports = eq; /***/ }), -/***/ 7399: +/***/ 6908: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var assocIndexOf = __nccwpck_require__(6752); +var baseGet = __nccwpck_require__(5758); /** - * Sets the list cache `key` to `value`. + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' */ -function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - ++this.size; - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; +function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; } -module.exports = listCacheSet; +module.exports = get; /***/ }), -/***/ 1610: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var Hash = __nccwpck_require__(5902), - ListCache = __nccwpck_require__(6608), - Map = __nccwpck_require__(881); +/***/ 4869: +/***/ ((module) => { /** - * Removes all key-value entries from the map. + * Checks if `value` is classified as an `Array` object. * - * @private - * @name clear - * @memberOf MapCache - */ -function mapCacheClear() { - this.size = 0; - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; -} + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; -module.exports = mapCacheClear; +module.exports = isArray; /***/ }), -/***/ 6657: +/***/ 7799: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var getMapData = __nccwpck_require__(9980); +var baseGetTag = __nccwpck_require__(7497), + isObject = __nccwpck_require__(3334); + +/** `Object#toString` result references. */ +var asyncTag = '[object AsyncFunction]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; /** - * Removes `key` and its value from the map. + * Checks if `value` is classified as a `Function` object. * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false */ -function mapCacheDelete(key) { - var result = getMapData(this, key)['delete'](key); - this.size -= result ? 1 : 0; - return result; +function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; } -module.exports = mapCacheDelete; +module.exports = isFunction; /***/ }), -/***/ 1372: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var getMapData = __nccwpck_require__(9980); +/***/ 3334: +/***/ ((module) => { /** - * Gets the map value for `key`. + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false */ -function mapCacheGet(key) { - return getMapData(this, key).get(key); +function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); } -module.exports = mapCacheGet; +module.exports = isObject; /***/ }), -/***/ 609: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var getMapData = __nccwpck_require__(9980); +/***/ 5926: +/***/ ((module) => { /** - * Checks if a map value for `key` exists. + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false */ -function mapCacheHas(key) { - return getMapData(this, key).has(key); +function isObjectLike(value) { + return value != null && typeof value == 'object'; } -module.exports = mapCacheHas; +module.exports = isObjectLike; /***/ }), -/***/ 5582: +/***/ 6403: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var getMapData = __nccwpck_require__(9980); +var baseGetTag = __nccwpck_require__(7497), + isObjectLike = __nccwpck_require__(5926); + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; /** - * Sets the map `key` to `value`. + * Checks if `value` is classified as a `Symbol` primitive or object. * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false */ -function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size; - - data.set(key, value); - this.size += data.size == size ? 0 : 1; - return this; +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); } -module.exports = mapCacheSet; +module.exports = isSymbol; /***/ }), -/***/ 9422: +/***/ 9885: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var memoize = __nccwpck_require__(9885); +var MapCache = __nccwpck_require__(938); -/** Used as the maximum memoize cache size. */ -var MAX_MEMOIZE_SIZE = 500; +/** Error message constants. */ +var FUNC_ERROR_TEXT = 'Expected a function'; /** - * A specialized version of `_.memoize` which clears the memoized function's - * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. * - * @private + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; */ -function memoizeCapped(func) { - var result = memoize(func, function(key) { - if (cache.size === MAX_MEMOIZE_SIZE) { - cache.clear(); - } - return key; - }); - - var cache = result.cache; - return result; -} - -module.exports = memoizeCapped; - - -/***/ }), - -/***/ 3041: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; -var getNative = __nccwpck_require__(4479); + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} -/* Built-in method references that are verified to be native. */ -var nativeCreate = getNative(Object, 'create'); +// Expose `MapCache`. +memoize.Cache = MapCache; -module.exports = nativeCreate; +module.exports = memoize; /***/ }), -/***/ 4200: -/***/ ((module) => { - -/** Used for built-in method references. */ -var objectProto = Object.prototype; +/***/ 2931: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var nativeObjectToString = objectProto.toString; +var baseToString = __nccwpck_require__(6792); /** - * Converts `value` to a string using `Object.prototype.toString`. + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. * - * @private + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang * @param {*} value The value to convert. * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' */ -function objectToString(value) { - return nativeObjectToString.call(value); +function toString(value) { + return value == null ? '' : baseToString(value); } -module.exports = objectToString; +module.exports = toString; /***/ }), -/***/ 9882: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var freeGlobal = __nccwpck_require__(2085); - -/** Detect free variable `self`. */ -var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - -/** Used as a reference to the global object. */ -var root = freeGlobal || freeSelf || Function('return this')(); - -module.exports = root; +/***/ 467: +/***/ ((module, exports, __nccwpck_require__) => { +"use strict"; -/***/ }), -/***/ 1853: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +Object.defineProperty(exports, "__esModule", ({ value: true })); -var memoizeCapped = __nccwpck_require__(9422); +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var Stream = _interopDefault(__nccwpck_require__(2413)); +var http = _interopDefault(__nccwpck_require__(8605)); +var Url = _interopDefault(__nccwpck_require__(8835)); +var https = _interopDefault(__nccwpck_require__(7211)); +var zlib = _interopDefault(__nccwpck_require__(8761)); + +// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js + +// fix for "Readable" isn't a named export issue +const Readable = Stream.Readable; + +const BUFFER = Symbol('buffer'); +const TYPE = Symbol('type'); + +class Blob { + constructor() { + this[TYPE] = ''; + + const blobParts = arguments[0]; + const options = arguments[1]; + + const buffers = []; + let size = 0; + + if (blobParts) { + const a = blobParts; + const length = Number(a.length); + for (let i = 0; i < length; i++) { + const element = a[i]; + let buffer; + if (element instanceof Buffer) { + buffer = element; + } else if (ArrayBuffer.isView(element)) { + buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); + } else if (element instanceof ArrayBuffer) { + buffer = Buffer.from(element); + } else if (element instanceof Blob) { + buffer = element[BUFFER]; + } else { + buffer = Buffer.from(typeof element === 'string' ? element : String(element)); + } + size += buffer.length; + buffers.push(buffer); + } + } + + this[BUFFER] = Buffer.concat(buffers); + + let type = options && options.type !== undefined && String(options.type).toLowerCase(); + if (type && !/[^\u0020-\u007E]/.test(type)) { + this[TYPE] = type; + } + } + get size() { + return this[BUFFER].length; + } + get type() { + return this[TYPE]; + } + text() { + return Promise.resolve(this[BUFFER].toString()); + } + arrayBuffer() { + const buf = this[BUFFER]; + const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + return Promise.resolve(ab); + } + stream() { + const readable = new Readable(); + readable._read = function () {}; + readable.push(this[BUFFER]); + readable.push(null); + return readable; + } + toString() { + return '[object Blob]'; + } + slice() { + const size = this.size; + + const start = arguments[0]; + const end = arguments[1]; + let relativeStart, relativeEnd; + if (start === undefined) { + relativeStart = 0; + } else if (start < 0) { + relativeStart = Math.max(size + start, 0); + } else { + relativeStart = Math.min(start, size); + } + if (end === undefined) { + relativeEnd = size; + } else if (end < 0) { + relativeEnd = Math.max(size + end, 0); + } else { + relativeEnd = Math.min(end, size); + } + const span = Math.max(relativeEnd - relativeStart, 0); + + const buffer = this[BUFFER]; + const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); + const blob = new Blob([], { type: arguments[2] }); + blob[BUFFER] = slicedBuffer; + return blob; + } +} -/** Used to match property names within property paths. */ -var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; +Object.defineProperties(Blob.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } +}); -/** Used to match backslashes in property paths. */ -var reEscapeChar = /\\(\\)?/g; +Object.defineProperty(Blob.prototype, Symbol.toStringTag, { + value: 'Blob', + writable: false, + enumerable: false, + configurable: true +}); /** - * Converts `string` to a property path array. + * fetch-error.js * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. + * FetchError interface for operational errors */ -var stringToPath = memoizeCapped(function(string) { - var result = []; - if (string.charCodeAt(0) === 46 /* . */) { - result.push(''); - } - string.replace(rePropName, function(match, number, quote, subString) { - result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; -}); - -module.exports = stringToPath; - - -/***/ }), - -/***/ 9071: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var isSymbol = __nccwpck_require__(6403); - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0; /** - * Converts `value` to a string key if it's not a string or symbol. + * Create FetchError instance * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. + * @param String message Error message for human + * @param String type Error type for machine + * @param String systemError For Node.js system error + * @return FetchError */ -function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; -} +function FetchError(message, type, systemError) { + Error.call(this, message); -module.exports = toKey; + this.message = message; + this.type = type; + + // when err.type is `system`, err.code contains system error code + if (systemError) { + this.code = this.errno = systemError.code; + } + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} -/***/ }), +FetchError.prototype = Object.create(Error.prototype); +FetchError.prototype.constructor = FetchError; +FetchError.prototype.name = 'FetchError'; -/***/ 6928: -/***/ ((module) => { +let convert; +try { + convert = __nccwpck_require__(8685)/* .convert */ .O; +} catch (e) {} -/** Used for built-in method references. */ -var funcProto = Function.prototype; +const INTERNALS = Symbol('Body internals'); -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; +// fix an issue where "PassThrough" isn't a named export for node <10 +const PassThrough = Stream.PassThrough; /** - * Converts `func` to its source code. + * Body mixin * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. + * Ref: https://fetch.spec.whatwg.org/#body + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void */ -function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; +function Body(body) { + var _this = this; + + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$size = _ref.size; + + let size = _ref$size === undefined ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === undefined ? 0 : _ref$timeout; + + if (body == null) { + // body is undefined or null + body = null; + } else if (isURLSearchParams(body)) { + // body is a URLSearchParams + body = Buffer.from(body.toString()); + } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { + // body is ArrayBuffer + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + // body is ArrayBufferView + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream) ; else { + // none of the above + // coerce to string then buffer + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + + if (body instanceof Stream) { + body.on('error', function (err) { + const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err); + _this[INTERNALS].error = error; + }); + } } -module.exports = toSource; - +Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + + /** + * Decode response as ArrayBuffer + * + * @return Promise + */ + arrayBuffer() { + return consumeBody.call(this).then(function (buf) { + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + }); + }, + + /** + * Return raw response as Blob + * + * @return Promise + */ + blob() { + let ct = this.headers && this.headers.get('content-type') || ''; + return consumeBody.call(this).then(function (buf) { + return Object.assign( + // Prevent copying + new Blob([], { + type: ct.toLowerCase() + }), { + [BUFFER]: buf + }); + }); + }, + + /** + * Decode response as json + * + * @return Promise + */ + json() { + var _this2 = this; + + return consumeBody.call(this).then(function (buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json')); + } + }); + }, + + /** + * Decode response as text + * + * @return Promise + */ + text() { + return consumeBody.call(this).then(function (buffer) { + return buffer.toString(); + }); + }, + + /** + * Decode response as buffer (non-spec api) + * + * @return Promise + */ + buffer() { + return consumeBody.call(this); + }, + + /** + * Decode response as text, while automatically detecting the encoding and + * trying to decode to UTF-8 (non-spec api) + * + * @return Promise + */ + textConverted() { + var _this3 = this; + + return consumeBody.call(this).then(function (buffer) { + return convertBody(buffer, _this3.headers); + }); + } +}; -/***/ }), +// In browsers, all properties are enumerable. +Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } +}); -/***/ 1901: -/***/ ((module) => { +Body.mixIn = function (proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + // istanbul ignore else: future proof + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } +}; /** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true + * Consume and convert an entire Body to a Buffer. * - * _.eq('a', Object('a')); - * // => false + * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body * - * _.eq(NaN, NaN); - * // => true + * @return Promise */ -function eq(value, other) { - return value === other || (value !== value && other !== other); +function consumeBody() { + var _this4 = this; + + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + + this[INTERNALS].disturbed = true; + + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + + let body = this.body; + + // body is null + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is blob + if (isBlob(body)) { + body = body.stream(); + } + + // body is buffer + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + + // istanbul ignore if: should never happen + if (!(body instanceof Stream)) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is stream + // get ready to actually consume the body + let accum = []; + let accumBytes = 0; + let abort = false; + + return new Body.Promise(function (resolve, reject) { + let resTimeout; + + // allow timeout on slow response body + if (_this4.timeout) { + resTimeout = setTimeout(function () { + abort = true; + reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout')); + }, _this4.timeout); + } + + // handle stream errors + body.on('error', function (err) { + if (err.name === 'AbortError') { + // if the request was aborted, reject with this Error + abort = true; + reject(err); + } else { + // other errors, such as incorrect content-encoding + reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + + body.on('data', function (chunk) { + if (abort || chunk === null) { + return; + } + + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size')); + return; + } + + accumBytes += chunk.length; + accum.push(chunk); + }); + + body.on('end', function () { + if (abort) { + return; + } + + clearTimeout(resTimeout); + + try { + resolve(Buffer.concat(accum, accumBytes)); + } catch (err) { + // handle streams that have accumulated too much data (issue #414) + reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + }); } -module.exports = eq; - +/** + * Detect buffer encoding and convert to target encoding + * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding + * + * @param Buffer buffer Incoming buffer + * @param String encoding Target encoding + * @return String + */ +function convertBody(buffer, headers) { + if (typeof convert !== 'function') { + throw new Error('The package `encoding` must be installed to use the textConverted() function'); + } + + const ct = headers.get('content-type'); + let charset = 'utf-8'; + let res, str; + + // header + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + + // no charset in content type, peek at response body for at most 1024 bytes + str = buffer.slice(0, 1024).toString(); + + // html5 + if (!res && str) { + res = / { +/** + * Check if `obj` is a W3C `Blob` object (which `File` inherits from) + * @param {*} obj + * @return {boolean} + */ +function isBlob(obj) { + return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]); +} -var baseGet = __nccwpck_require__(5758); +/** + * Clone body given Res/Req instance + * + * @param Mixed instance Response or Request instance + * @return Mixed + */ +function clone(instance) { + let p1, p2; + let body = instance.body; + + // don't allow cloning a used body + if (instance.bodyUsed) { + throw new Error('cannot clone body after it is used'); + } + + // check that body is a stream and not form-data object + // note: we can't clone the form-data object without having it as a dependency + if (body instanceof Stream && typeof body.getBoundary !== 'function') { + // tee instance body + p1 = new PassThrough(); + p2 = new PassThrough(); + body.pipe(p1); + body.pipe(p2); + // set instance body to teed body and return the other teed body + instance[INTERNALS].body = p1; + body = p2; + } + + return body; +} /** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. + * Performs the operation "extract a `Content-Type` value from |object|" as + * specified in the specification: + * https://fetch.spec.whatwg.org/#concept-bodyinit-extract * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example + * This function assumes that instance.body is present. * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * @param Mixed instance Any options.body input + */ +function extractContentType(body) { + if (body === null) { + // body is null + return null; + } else if (typeof body === 'string') { + // body is string + return 'text/plain;charset=UTF-8'; + } else if (isURLSearchParams(body)) { + // body is a URLSearchParams + return 'application/x-www-form-urlencoded;charset=UTF-8'; + } else if (isBlob(body)) { + // body is blob + return body.type || null; + } else if (Buffer.isBuffer(body)) { + // body is buffer + return null; + } else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { + // body is ArrayBuffer + return null; + } else if (ArrayBuffer.isView(body)) { + // body is ArrayBufferView + return null; + } else if (typeof body.getBoundary === 'function') { + // detect form data input from form-data module + return `multipart/form-data;boundary=${body.getBoundary()}`; + } else if (body instanceof Stream) { + // body is stream + // can't really do much about this + return null; + } else { + // Body constructor defaults other things to string + return 'text/plain;charset=UTF-8'; + } +} + +/** + * The Fetch Standard treats this as if "total bytes" is a property on the body. + * For us, we have to explicitly get it with a function. * - * _.get(object, 'a[0].b.c'); - * // => 3 + * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 + * @param Body instance Instance of Body + * @return Number? Number of bytes, or null if not possible + */ +function getTotalBytes(instance) { + const body = instance.body; + + + if (body === null) { + // body is null + return 0; + } else if (isBlob(body)) { + return body.size; + } else if (Buffer.isBuffer(body)) { + // body is buffer + return body.length; + } else if (body && typeof body.getLengthSync === 'function') { + // detect form data input from form-data module + if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x + body.hasKnownLength && body.hasKnownLength()) { + // 2.x + return body.getLengthSync(); + } + return null; + } else { + // body is stream + return null; + } +} + +/** + * Write a Body to a Node.js WritableStream (e.g. http.Request) object. * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' + * @param Body instance Instance of Body + * @return Void */ -function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; +function writeToStream(dest, instance) { + const body = instance.body; + + + if (body === null) { + // body is null + dest.end(); + } else if (isBlob(body)) { + body.stream().pipe(dest); + } else if (Buffer.isBuffer(body)) { + // body is buffer + dest.write(body); + dest.end(); + } else { + // body is stream + body.pipe(dest); + } } -module.exports = get; +// expose Promise +Body.Promise = global.Promise; +/** + * headers.js + * + * Headers class offers convenient helpers + */ -/***/ }), +const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/; +const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/; -/***/ 4869: -/***/ ((module) => { +function validateName(name) { + name = `${name}`; + if (invalidTokenRegex.test(name) || name === '') { + throw new TypeError(`${name} is not a legal HTTP header name`); + } +} + +function validateValue(value) { + value = `${value}`; + if (invalidHeaderCharRegex.test(value)) { + throw new TypeError(`${value} is not a legal HTTP header value`); + } +} /** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false + * Find the key in the map object given a header name. * - * _.isArray('abc'); - * // => false + * Returns undefined if not found. * - * _.isArray(_.noop); - * // => false + * @param String name Header name + * @return String|Undefined */ -var isArray = Array.isArray; +function find(map, name) { + name = name.toLowerCase(); + for (const key in map) { + if (key.toLowerCase() === name) { + return key; + } + } + return undefined; +} + +const MAP = Symbol('map'); +class Headers { + /** + * Headers class + * + * @param Object headers Response headers + * @return Void + */ + constructor() { + let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined; + + this[MAP] = Object.create(null); + + if (init instanceof Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + + return; + } + + // We don't worry about converting prop to ByteString here as append() + // will handle it. + if (init == null) ; else if (typeof init === 'object') { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== 'function') { + throw new TypeError('Header pairs must be iterable'); + } + + // sequence> + // Note: per spec we have to first exhaust the lists then process them + const pairs = []; + for (const pair of init) { + if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') { + throw new TypeError('Each header pair must be iterable'); + } + pairs.push(Array.from(pair)); + } + + for (const pair of pairs) { + if (pair.length !== 2) { + throw new TypeError('Each header pair must be a name/value tuple'); + } + this.append(pair[0], pair[1]); + } + } else { + // record + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError('Provided initializer must be an object'); + } + } + + /** + * Return combined header value given name + * + * @param String name Header name + * @return Mixed + */ + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === undefined) { + return null; + } + + return this[MAP][key].join(', '); + } + + /** + * Iterate over all headers + * + * @param Function callback Executed for each item with parameters (value, name, thisArg) + * @param Boolean thisArg `this` context for callback function + * @return Void + */ + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; + + let pairs = getHeaders(this); + let i = 0; + while (i < pairs.length) { + var _pairs$i = pairs[i]; + const name = _pairs$i[0], + value = _pairs$i[1]; + + callback.call(thisArg, value, name, this); + pairs = getHeaders(this); + i++; + } + } + + /** + * Overwrite header values given name + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== undefined ? key : name] = [value]; + } + + /** + * Append a value onto existing header + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== undefined) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + + /** + * Check for header name existence + * + * @param String name Header name + * @return Boolean + */ + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== undefined; + } + + /** + * Delete all header values given name + * + * @param String name Header name + * @return Void + */ + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== undefined) { + delete this[MAP][key]; + } + } + + /** + * Return raw headers (non-spec api) + * + * @return Object + */ + raw() { + return this[MAP]; + } + + /** + * Get an iterator on keys. + * + * @return Iterator + */ + keys() { + return createHeadersIterator(this, 'key'); + } + + /** + * Get an iterator on values. + * + * @return Iterator + */ + values() { + return createHeadersIterator(this, 'value'); + } + + /** + * Get an iterator on entries. + * + * This is the default iterator of the Headers object. + * + * @return Iterator + */ + [Symbol.iterator]() { + return createHeadersIterator(this, 'key+value'); + } +} +Headers.prototype.entries = Headers.prototype[Symbol.iterator]; -module.exports = isArray; +Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + value: 'Headers', + writable: false, + enumerable: false, + configurable: true +}); +Object.defineProperties(Headers.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } +}); -/***/ }), +function getHeaders(headers) { + let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value'; + + const keys = Object.keys(headers[MAP]).sort(); + return keys.map(kind === 'key' ? function (k) { + return k.toLowerCase(); + } : kind === 'value' ? function (k) { + return headers[MAP][k].join(', '); + } : function (k) { + return [k.toLowerCase(), headers[MAP][k].join(', ')]; + }); +} -/***/ 7799: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +const INTERNAL = Symbol('internal'); -var baseGetTag = __nccwpck_require__(7497), - isObject = __nccwpck_require__(3334); +function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; +} -/** `Object#toString` result references. */ -var asyncTag = '[object AsyncFunction]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - proxyTag = '[object Proxy]'; +const HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + // istanbul ignore if + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError('Value of `this` is not a HeadersIterator'); + } + + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, + kind = _INTERNAL.kind, + index = _INTERNAL.index; + + const values = getHeaders(target, kind); + const len = values.length; + if (index >= len) { + return { + value: undefined, + done: true + }; + } + + this[INTERNAL].index = index + 1; + + return { + value: values[index], + done: false + }; + } +}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + +Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: 'HeadersIterator', + writable: false, + enumerable: false, + configurable: true +}); /** - * Checks if `value` is classified as a `Function` object. + * Export the Headers object in a form that Node.js can consume. * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example + * @param Headers headers + * @return Object + */ +function exportNodeCompatibleHeaders(headers) { + const obj = Object.assign({ __proto__: null }, headers[MAP]); + + // http.request() only supports string as Host header. This hack makes + // specifying custom Host header possible. + const hostHeaderKey = find(headers[MAP], 'Host'); + if (hostHeaderKey !== undefined) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + + return obj; +} + +/** + * Create a Headers object from an object of headers, ignoring those that do + * not conform to HTTP grammar productions. * - * _.isFunction(_); - * // => true + * @param Object obj Object of headers + * @return Headers + */ +function createHeadersLenient(obj) { + const headers = new Headers(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers[MAP][name] === undefined) { + headers[MAP][name] = [val]; + } else { + headers[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers[MAP][name] = [obj[name]]; + } + } + return headers; +} + +const INTERNALS$1 = Symbol('Response internals'); + +// fix an issue where "STATUS_CODES" aren't a named export for node <10 +const STATUS_CODES = http.STATUS_CODES; + +/** + * Response class * - * _.isFunction(/abc/); - * // => false + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void */ -function isFunction(value) { - if (!isObject(value)) { - return false; - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value); - return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; +class Response { + constructor() { + let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + Body.call(this, body, opts); + + const status = opts.status || 200; + const headers = new Headers(opts.headers); + + if (body != null && !headers.has('Content-Type')) { + const contentType = extractContentType(body); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES[status], + headers, + counter: opts.counter + }; + } + + get url() { + return this[INTERNALS$1].url || ''; + } + + get status() { + return this[INTERNALS$1].status; + } + + /** + * Convenience property representing if the request ended normally + */ + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + + get redirected() { + return this[INTERNALS$1].counter > 0; + } + + get statusText() { + return this[INTERNALS$1].statusText; + } + + get headers() { + return this[INTERNALS$1].headers; + } + + /** + * Clone this response + * + * @return Response + */ + clone() { + return new Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } } -module.exports = isFunction; +Body.mixIn(Response.prototype); +Object.defineProperties(Response.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } +}); -/***/ }), +Object.defineProperty(Response.prototype, Symbol.toStringTag, { + value: 'Response', + writable: false, + enumerable: false, + configurable: true +}); -/***/ 3334: -/***/ ((module) => { +const INTERNALS$2 = Symbol('Request internals'); + +// fix an issue where "format", "parse" aren't a named export for node <10 +const parse_url = Url.parse; +const format_url = Url.format; + +const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; /** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true + * Check if a value is an instance of Request. * - * _.isObject(null); - * // => false + * @param Mixed input + * @return Boolean */ -function isObject(value) { - var type = typeof value; - return value != null && (type == 'object' || type == 'function'); +function isRequest(input) { + return typeof input === 'object' && typeof input[INTERNALS$2] === 'object'; } -module.exports = isObject; +function isAbortSignal(signal) { + const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal); + return !!(proto && proto.constructor.name === 'AbortSignal'); +} + +/** + * Request class + * + * @param Mixed input Url or Request instance + * @param Object init Custom options + * @return Void + */ +class Request { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + let parsedURL; + + // normalize input + if (!isRequest(input)) { + if (input && input.href) { + // in order to support Node.js' Url objects; though WHATWG's URL objects + // will fall into this branch also (since their `toString()` will return + // `href` property anyway) + parsedURL = parse_url(input.href); + } else { + // coerce input to a string before attempting to parse + parsedURL = parse_url(`${input}`); + } + input = {}; + } else { + parsedURL = parse_url(input.url); + } + + let method = init.method || input.method || 'GET'; + method = method.toUpperCase(); + + if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) { + throw new TypeError('Request with GET/HEAD method cannot have body'); + } + + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + + const headers = new Headers(init.headers || input.headers || {}); + + if (inputBody != null && !headers.has('Content-Type')) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + let signal = isRequest(input) ? input.signal : null; + if ('signal' in init) signal = init.signal; + + if (signal != null && !isAbortSignal(signal)) { + throw new TypeError('Expected signal to be an instanceof AbortSignal'); + } + + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || 'follow', + headers, + parsedURL, + signal + }; + + // node-fetch-only options + this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20; + this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + + get method() { + return this[INTERNALS$2].method; + } + + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + + get headers() { + return this[INTERNALS$2].headers; + } + + get redirect() { + return this[INTERNALS$2].redirect; + } + + get signal() { + return this[INTERNALS$2].signal; + } + + /** + * Clone this request + * + * @return Request + */ + clone() { + return new Request(this); + } +} +Body.mixIn(Request.prototype); -/***/ }), +Object.defineProperty(Request.prototype, Symbol.toStringTag, { + value: 'Request', + writable: false, + enumerable: false, + configurable: true +}); -/***/ 5926: -/***/ ((module) => { +Object.defineProperties(Request.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } +}); /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". + * Convert a Request to Node.js http request options. * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example + * @param Request A Request instance + * @return Object The options object to be passed to http.request + */ +function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers = new Headers(request[INTERNALS$2].headers); + + // fetch step 1.3 + if (!headers.has('Accept')) { + headers.set('Accept', '*/*'); + } + + // Basic fetch + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError('Only absolute URLs are supported'); + } + + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError('Only HTTP(S) protocols are supported'); + } + + if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) { + throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8'); + } + + // HTTP-network-or-cache fetch steps 2.4-2.7 + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = '0'; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === 'number') { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers.set('Content-Length', contentLengthValue); + } + + // HTTP-network-or-cache fetch step 2.11 + if (!headers.has('User-Agent')) { + headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)'); + } + + // HTTP-network-or-cache fetch step 2.15 + if (request.compress && !headers.has('Accept-Encoding')) { + headers.set('Accept-Encoding', 'gzip,deflate'); + } + + let agent = request.agent; + if (typeof agent === 'function') { + agent = agent(parsedURL); + } + + if (!headers.has('Connection') && !agent) { + headers.set('Connection', 'close'); + } + + // HTTP-network fetch step 4.2 + // chunked encoding is handled by Node.js + + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers), + agent + }); +} + +/** + * abort-error.js * - * _.isObjectLike({}); - * // => true + * AbortError interface for cancelled requests + */ + +/** + * Create AbortError instance * - * _.isObjectLike([1, 2, 3]); - * // => true + * @param String message Error message for human + * @return AbortError + */ +function AbortError(message) { + Error.call(this, message); + + this.type = 'aborted'; + this.message = message; + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +AbortError.prototype = Object.create(Error.prototype); +AbortError.prototype.constructor = AbortError; +AbortError.prototype.name = 'AbortError'; + +// fix an issue where "PassThrough", "resolve" aren't a named export for node <10 +const PassThrough$1 = Stream.PassThrough; +const resolve_url = Url.resolve; + +/** + * Fetch function * - * _.isObjectLike(_.noop); - * // => false + * @param Mixed url Absolute url or Request instance + * @param Object opts Fetch options + * @return Promise + */ +function fetch(url, opts) { + + // allow custom promise + if (!fetch.Promise) { + throw new Error('native promise missing, set fetch.Promise to your favorite alternative'); + } + + Body.Promise = fetch.Promise; + + // wrap http.request into fetch + return new fetch.Promise(function (resolve, reject) { + // build request object + const request = new Request(url, opts); + const options = getNodeRequestOptions(request); + + const send = (options.protocol === 'https:' ? https : http).request; + const signal = request.signal; + + let response = null; + + const abort = function abort() { + let error = new AbortError('The user aborted a request.'); + reject(error); + if (request.body && request.body instanceof Stream.Readable) { + request.body.destroy(error); + } + if (!response || !response.body) return; + response.body.emit('error', error); + }; + + if (signal && signal.aborted) { + abort(); + return; + } + + const abortAndFinalize = function abortAndFinalize() { + abort(); + finalize(); + }; + + // send request + const req = send(options); + let reqTimeout; + + if (signal) { + signal.addEventListener('abort', abortAndFinalize); + } + + function finalize() { + req.abort(); + if (signal) signal.removeEventListener('abort', abortAndFinalize); + clearTimeout(reqTimeout); + } + + if (request.timeout) { + req.once('socket', function (socket) { + reqTimeout = setTimeout(function () { + reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout')); + finalize(); + }, request.timeout); + }); + } + + req.on('error', function (err) { + reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err)); + finalize(); + }); + + req.on('response', function (res) { + clearTimeout(reqTimeout); + + const headers = createHeadersLenient(res.headers); + + // HTTP fetch step 5 + if (fetch.isRedirect(res.statusCode)) { + // HTTP fetch step 5.2 + const location = headers.get('Location'); + + // HTTP fetch step 5.3 + const locationURL = location === null ? null : resolve_url(request.url, location); + + // HTTP fetch step 5.5 + switch (request.redirect) { + case 'error': + reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect')); + finalize(); + return; + case 'manual': + // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. + if (locationURL !== null) { + // handle corrupted header + try { + headers.set('Location', locationURL); + } catch (err) { + // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request + reject(err); + } + } + break; + case 'follow': + // HTTP-redirect fetch step 2 + if (locationURL === null) { + break; + } + + // HTTP-redirect fetch step 5 + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 6 (counter increment) + // Create a new Request object. + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + + // HTTP-redirect fetch step 9 + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 11 + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') { + requestOpts.method = 'GET'; + requestOpts.body = undefined; + requestOpts.headers.delete('content-length'); + } + + // HTTP-redirect fetch step 15 + resolve(fetch(new Request(locationURL, requestOpts))); + finalize(); + return; + } + } + + // prepare response + res.once('end', function () { + if (signal) signal.removeEventListener('abort', abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers: headers, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + + // HTTP-network fetch step 12.1.1.3 + const codings = headers.get('Content-Encoding'); + + // HTTP-network fetch step 12.1.1.4: handle content codings + + // in following scenarios we ignore compression support + // 1. compression support is disabled + // 2. HEAD request + // 3. no Content-Encoding header + // 4. no content response (204) + // 5. content not modified response (304) + if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response(body, response_options); + resolve(response); + return; + } + + // For Node v6+ + // Be less strict when decoding compressed responses, since sometimes + // servers send slightly invalid responses that are still accepted + // by common browsers. + // Always using Z_SYNC_FLUSH is what cURL does. + const zlibOptions = { + flush: zlib.Z_SYNC_FLUSH, + finishFlush: zlib.Z_SYNC_FLUSH + }; + + // for gzip + if (codings == 'gzip' || codings == 'x-gzip') { + body = body.pipe(zlib.createGunzip(zlibOptions)); + response = new Response(body, response_options); + resolve(response); + return; + } + + // for deflate + if (codings == 'deflate' || codings == 'x-deflate') { + // handle the infamous raw deflate response from old servers + // a hack for old IIS and Apache servers + const raw = res.pipe(new PassThrough$1()); + raw.once('data', function (chunk) { + // see http://stackoverflow.com/questions/37519828 + if ((chunk[0] & 0x0F) === 0x08) { + body = body.pipe(zlib.createInflate()); + } else { + body = body.pipe(zlib.createInflateRaw()); + } + response = new Response(body, response_options); + resolve(response); + }); + return; + } + + // for br + if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') { + body = body.pipe(zlib.createBrotliDecompress()); + response = new Response(body, response_options); + resolve(response); + return; + } + + // otherwise, use response as-is + response = new Response(body, response_options); + resolve(response); + }); + + writeToStream(req, request); + }); +} +/** + * Redirect code matching * - * _.isObjectLike(null); - * // => false + * @param Number code Status code + * @return Boolean */ -function isObjectLike(value) { - return value != null && typeof value == 'object'; +fetch.isRedirect = function (code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; +}; + +// expose Promise +fetch.Promise = global.Promise; + +module.exports = exports = fetch; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.default = exports; +exports.Headers = Headers; +exports.Request = Request; +exports.Response = Response; +exports.FetchError = FetchError; + + +/***/ }), + +/***/ 1223: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +var wrappy = __nccwpck_require__(2940) +module.exports = wrappy(once) +module.exports.strict = wrappy(onceStrict) + +once.proto = once(function () { + Object.defineProperty(Function.prototype, 'once', { + value: function () { + return once(this) + }, + configurable: true + }) + + Object.defineProperty(Function.prototype, 'onceStrict', { + value: function () { + return onceStrict(this) + }, + configurable: true + }) +}) + +function once (fn) { + var f = function () { + if (f.called) return f.value + f.called = true + return f.value = fn.apply(this, arguments) + } + f.called = false + return f } -module.exports = isObjectLike; +function onceStrict (fn) { + var f = function () { + if (f.called) + throw new Error(f.onceError) + f.called = true + return f.value = fn.apply(this, arguments) + } + var name = fn.name || 'Function wrapped with `once`' + f.onceError = name + " shouldn't be called more than once" + f.called = false + return f +} /***/ }), -/***/ 6403: +/***/ 5118: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var baseGetTag = __nccwpck_require__(7497), - isObjectLike = __nccwpck_require__(5926); +"use strict"; +/* eslint-disable node/no-deprecated-api */ -/** `Object#toString` result references. */ -var symbolTag = '[object Symbol]'; -/** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ -function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && baseGetTag(value) == symbolTag); + +var buffer = __nccwpck_require__(4293) +var Buffer = buffer.Buffer + +var safer = {} + +var key + +for (key in buffer) { + if (!buffer.hasOwnProperty(key)) continue + if (key === 'SlowBuffer' || key === 'Buffer') continue + safer[key] = buffer[key] } -module.exports = isSymbol; +var Safer = safer.Buffer = {} +for (key in Buffer) { + if (!Buffer.hasOwnProperty(key)) continue + if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue + Safer[key] = Buffer[key] +} + +safer.Buffer.prototype = Buffer.prototype + +if (!Safer.from || Safer.from === Uint8Array.from) { + Safer.from = function (value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value) + } + if (value && typeof value.length === 'undefined') { + throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value) + } + return Buffer(value, encodingOrOffset, length) + } +} + +if (!Safer.alloc) { + Safer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size) + } + if (size < 0 || size >= 2 * (1 << 30)) { + throw new RangeError('The value "' + size + '" is invalid for option "size"') + } + var buf = Buffer(size) + if (!fill || fill.length === 0) { + buf.fill(0) + } else if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + return buf + } +} + +if (!safer.kStringMaxLength) { + try { + safer.kStringMaxLength = process.binding('buffer').kStringMaxLength + } catch (e) { + // we can't determine kStringMaxLength in environments where process.binding + // is unsupported, so let's not set it + } +} + +if (!safer.constants) { + safer.constants = { + MAX_LENGTH: safer.kMaxLength + } + if (safer.kStringMaxLength) { + safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength + } +} + +module.exports = safer /***/ }), -/***/ 9885: +/***/ 4294: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var MapCache = __nccwpck_require__(938); +module.exports = __nccwpck_require__(4219); -/** Error message constants. */ -var FUNC_ERROR_TEXT = 'Expected a function'; -/** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided, it determines the cache key for storing the result based on the - * arguments provided to the memoized function. By default, the first argument - * provided to the memoized function is used as the map cache key. The `func` - * is invoked with the `this` binding of the memoized function. - * - * **Note:** The cache is exposed as the `cache` property on the memoized - * function. Its creation may be customized by replacing the `_.memoize.Cache` - * constructor with one whose instances implement the - * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) - * method interface of `clear`, `delete`, `get`, `has`, and `set`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] The function to resolve the cache key. - * @returns {Function} Returns the new memoized function. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * var other = { 'c': 3, 'd': 4 }; - * - * var values = _.memoize(_.values); - * values(object); - * // => [1, 2] - * - * values(other); - * // => [3, 4] - * - * object.a = 2; - * values(object); - * // => [1, 2] - * - * // Modify the result cache. - * values.cache.set(object, ['a', 'b']); - * values(object); - * // => ['a', 'b'] - * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; - */ -function memoize(func, resolver) { - if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { - throw new TypeError(FUNC_ERROR_TEXT); - } - var memoized = function() { - var args = arguments, - key = resolver ? resolver.apply(this, args) : args[0], - cache = memoized.cache; +/***/ }), - if (cache.has(key)) { - return cache.get(key); +/***/ 4219: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +var net = __nccwpck_require__(1631); +var tls = __nccwpck_require__(4016); +var http = __nccwpck_require__(8605); +var https = __nccwpck_require__(7211); +var events = __nccwpck_require__(8614); +var assert = __nccwpck_require__(2357); +var util = __nccwpck_require__(1669); + + +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; + + +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} + +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} + +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} + + +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } } - var result = func.apply(this, args); - memoized.cache = cache.set(key, result) || cache; - return result; - }; - memoized.cache = new (memoize.Cache || MapCache); - return memoized; + socket.destroy(); + self.removeSocket(socket); + }); } +util.inherits(TunnelingAgent, events.EventEmitter); -// Expose `MapCache`. -memoize.Cache = MapCache; +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { + var self = this; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); -module.exports = memoize; + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); -/***/ }), + function onFree() { + self.emit('free', socket, options); + } -/***/ 2931: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); + } + }); +}; -var baseToString = __nccwpck_require__(6792); +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); + + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false, + headers: { + host: options.host + ':' + options.port + } + }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } -/** - * Converts `value` to a string. An empty string is returned for `null` - * and `undefined` values. The sign of `-0` is preserved. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' - * - * _.toString([1, 2, 3]); - * // => '1,2,3' - */ -function toString(value) { - return value == null ? '' : baseToString(value); + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } + + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); + } + + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode !== 200) { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + socket.destroy(); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + if (head.length > 0) { + debug('got illegal response body from proxy'); + socket.destroy(); + var error = new Error('got illegal response body from proxy'); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; + } + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } + + function onError(cause) { + connectReq.removeAllListeners(); + + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + } +}; + +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; + } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); + } +}; + +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); + + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); } -module.exports = toString; + +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} + +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } + } + } + return target; +} + + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; + } else { + args.unshift('TUNNEL:'); + } + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test /***/ }), @@ -4417,6 +14752,160 @@ module.exports = toString; //# sourceMappingURL=underscore.js.map +/***/ }), + +/***/ 5030: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function getUserAgent() { + if (typeof navigator === "object" && "userAgent" in navigator) { + return navigator.userAgent; + } + + if (typeof process === "object" && "version" in process) { + return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`; + } + + return ""; +} + +exports.getUserAgent = getUserAgent; +//# sourceMappingURL=index.js.map + + +/***/ }), + +/***/ 2940: +/***/ ((module) => { + +// Returns a wrapper function that returns a wrapped callback +// The wrapper function should do some stuff, and return a +// presumably different callback function. +// This makes sure that own properties are retained, so that +// decorations and such are not lost along the way. +module.exports = wrappy +function wrappy (fn, cb) { + if (fn && cb) return wrappy(fn)(cb) + + if (typeof fn !== 'function') + throw new TypeError('need wrapper function') + + Object.keys(fn).forEach(function (k) { + wrapper[k] = fn[k] + }) + + return wrapper + + function wrapper() { + var args = new Array(arguments.length) + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i] + } + var ret = fn.apply(this, args) + var cb = args[args.length-1] + if (typeof ret === 'function' && ret !== cb) { + Object.keys(cb).forEach(function (k) { + ret[k] = cb[k] + }) + } + return ret + } +} + + +/***/ }), + +/***/ 1254: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"8740\",\"䏰䰲䘃䖦ä•øš§‰§äµ·ä–³š§²±ä³¢š§³…ć®•äœ¶ä„ä±‡ä±€š¤Šæš£˜—š§’š¦ŗ‹š§ƒ’ä±—šŖ‘䝏䗚䲅š§±¬ä“‡äŖ¤äš”š¦¬£ēˆ„š„©”š”©£š£ø†š£½”ę™å›»\"],[\"8767\",\"ē¶•å¤šØ®¹ć·“霓š§ÆÆåƛš”µžåŖ¤ć˜„š©ŗ°å«‘å®·å³¼ę®č–“š©„…ē‘”ē’ć”µš”µ“š£šžš¦€”滬\"],[\"87a1\",\"š„£žć«µē«¼é¾—š¤…”šØ¤š£‡Ŗš ŖŠš£‰žäŒŠč’„é¾–éÆä¤°č˜“å¢–éŠéˆ˜ē§ēØ²ę™ ęØ©č¢ē‘ŒēÆ…ęž‚ēØ¬å‰é†ć“¦ē„š„¶¹ē“†éæ‡åž³ä¤Æ呌䄱š£šŽå ˜ē©²š§­„č®äš®š¦ŗˆä†š„¶™ē®®š¢’¼é戚¢“š¢“‰š¢“Œéæ‰č”„š£–»ä‚“éæŠä“”šŖ·æꋁē®éæ‹\"],[\"8840\",\"懀\",4,\"š „Œć‡…š ƒ‘š ƒć‡†ć‡‡š ƒ‹š”æØ懈š ƒŠć‡‰ć‡Šć‡‹ć‡Œš „Žć‡ć‡ŽÄ€ĆĒĆ€Ä’Ć‰ÄšĆˆÅŒĆ“Ē‘Ć’ąææƊĢ„įŗ¾ąææƊĢŒį»€ĆŠÄĆ”ĒŽĆ É‘Ä“Ć©Ä›ĆØÄ«Ć­ĒĆ¬ÅĆ³Ē’Ć²Å«ĆŗĒ”Ć¹Ē–Ē˜Ēš\"],[\"88a1\",\"ĒœĆ¼ąææĆŖĢ„įŗæąææĆŖĢŒį»ĆŖÉ”āšā›\"],[\"8940\",\"šŖŽ©š”……\"],[\"8943\",\"ꔊ\"],[\"8946\",\"äø½ę»éµŽé‡Ÿ\"],[\"894c\",\"š§œµę’‘会ä¼Øä¾Ø兖兓农凤劔åŠØ医华发变团声处备夲夓学实実岚åŗ†ę€»ę–‰ęŸ¾ę „ꔄ굎ē‚¼ē”µēŗ¤ēŗ¬ēŗŗē»‡ē»ē»Ÿē¼†ē¼·č‰ŗ苏čÆč§†č®¾čÆ¢č½¦č½§č½®\"],[\"89a1\",\"ē‘ē³¼ē·ę„†ē«‰åˆ§\"],[\"89ab\",\"醌ē¢øé…žč‚¼\"],[\"89b0\",\"č“‹čƒ¶š §§\"],[\"89b5\",\"č‚Ÿé»‡ä³é·‰éøŒä°¾š©·¶š§€ŽéøŠšŖ„³ć—\"],[\"89c1\",\"ęŗščˆ¾ē”™\"],[\"89c5\",\"䤑马éŖé¾™ē¦‡šØ‘¬š”·Šš —š¢«¦äø¤äŗäŗ€äŗ‡äŗæä»«ä¼·ć‘Œä¾½ć¹ˆå€ƒå‚ˆć‘½ć’“ć’„å††å¤…å‡›å‡¼åˆ…äŗ‰å‰¹åŠåŒ§ć—‡åŽ©ć•‘åŽ°ć•“å‚å£ć•­ć•²ćšå’“å’£å’“咹哐å“Æ唘唣å”Ø斘å”æć–„ć–æå——ć—…\"],[\"8a40\",\"š§¶„唄\"],[\"8a43\",\"š ±‚š “•š„„«å–š¢³†ć§¬š č¹†š¤¶øš©“„䁓šØ‚¾ēŗš¢°øćؓ䟕šØ…š¦§²š¤·Ŗꓝš µ¼š ¾“š ³•š”ƒ“ę’č¹¾š ŗ–š °‹š ½¤š¢²©šØ‰–š¤““\"],[\"8a64\",\"š µ†š©©šØƒ©äŸ“š¤ŗ§š¢³‚éŖ²ć©§š©—“ćæ­ć”†š„‹‡š©Ÿ”š§£ˆš¢µ„鵮頕\"],[\"8a76\",\"䏙š¦‚„ę’“å“£š¢µŒš¢ÆŠš”·ć§»š”Æ\"],[\"8aa1\",\"š¦›šš¦œ–š§¦ ę“Ŗš„’š ±ƒč¹Øš¢†”šØ­Œš œ±\"],[\"8aac\",\"䠋š †©ćæŗ唳š¢¶\"],[\"8ab2\",\"š¤—ˆš “¼š¦‚—š ½Œš ¶–啹䂻äŽŗ\"],[\"8abb\",\"äŖ“š¢©¦š”‚č†Ŗ飵š ¶œę¹ć§¾š¢µč·€åš”ę‘¼ć¹ƒ\"],[\"8ac9\",\"šŖ˜š ø‰š¢«š¢³‰\"],[\"8ace\",\"š”ƒˆš£§‚榒ć؆šØŠ›ć•øš„¹‰š¢ƒ‡å™’š ¼±š¢²²š©œ ć’¼ę°½š¤ø»\"],[\"8adf\",\"š§•“š¢ŗ‹š¢ˆˆšŖ™›šØ³š ¹ŗš °“š¦ œē¾“š”ƒš¢ ƒš¢¤¹ć—»š„‡£š ŗŒš ¾š ŗŖć¾“š ¼°š µ‡š”…š ¹Œ\"],[\"8af6\",\"š ŗ«š ®©š µˆš”ƒ€š”„½ć湚¢š–ę²š ¾­\"],[\"8b40\",\"š£“š§˜¹š¢ÆŽš µ¾š µæš¢±‘š¢±•ćؘš ŗ˜š”ƒ‡š ¼®šŖ˜²š¦­šØ³’šØ¶™šØ³Šé–Ŗå“Œč‹„å–¹\"],[\"8b55\",\"š©»ƒé°¦éŖ¶š§žš¢·®ē…€č…­čƒ¬å°œš¦•²č„“ćž—åŸšØ‚½é†¶š »ŗš øš ¹·š »»ć—š¤·«ć˜‰š ³–åšÆš¢žµš”ƒ‰š øš ¹øš”øš”…ˆšØˆ‡š”‘•š ¹¹š¤¹š¢¶¤å©”š”€š”€žš”ƒµš”ƒ¶åžœš ø‘\"],[\"8ba1\",\"š§š”šØ‹š ¾µš ¹»š„…¾ćœƒš ¾¶š”†€š„‹˜šŖŠ½š¤§šš” ŗš¤…·šØ‰¼å¢™å‰Ø昚š„œ½ē®²å­Ø䠀䬬鼧䧧鰟鮍š„­“š£„½å—»ć—²åš‰äøØ夂š”ƁšÆ”ø靑š ‚†ä¹›äŗ»ć”¾å°£å½‘åæ„ć£ŗę‰Œę”µę­ŗę°µę°ŗē¬ēˆ«äø¬ēŠ­š¤£©ē½’ē¤»ē³¹ē½“š¦‰Ŗ擁\"],[\"8bde\",\"š¦‹č€‚č‚€š¦˜’š¦„‘åč”¤č§š§¢²č® č“é’…é•øé•æé—ØšØøéŸ¦é”µé£Žé£žé„£š© é±¼éøŸé»„ę­Æļ¤‡äø·š ‚‡é˜ęˆ·é’¢\"],[\"8c40\",\"å€»ę·¾š©±³é¾¦ć·‰č¢š¤…Žē·å³µä¬ š„‡ć•™š„“°ę„¢šØØ²č¾§é‡¶ē†‘ęœ™ēŽŗš£ŠšŖ„‡ć²‹š”¦€ä¬ē£¤ē‚冮šØœä€‰ę©£šŖŠŗäˆ£č˜š ©ÆēØŖš©„‡šØ«Ŗ靕ēåŒ¤š¢¾é“ē›™šØ§£é¾§ēŸäŗ£äæ°å‚¼äøÆ众é¾Ø吓ē¶‹å¢’壐š”¶¶åŗ’åŗ™åæ‚š¢œ’ę–‹\"],[\"8ca1\",\"š£¹ę¤™ę©ƒš£±£ę³æ\"],[\"8ca7\",\"ēˆ€š¤”…ēŽŒć»›š¤Ø“嬕ē’¹č®ƒš„²¤š„š•ēŖ“ēƬē³ƒē¹¬č‹øč–—é¾©č¢é¾Ŗčŗ¹é¾«čæč•Ÿé§ éˆ”龬šØ¶¹š”æ䁱䊢åؚ\"],[\"8cc9\",\"é”Øę«ä‰¶åœ½\"],[\"8cce\",\"藖š¤„»čŠæš§„ä²š¦µ“åµ»š¦¬•š¦¾¾é¾­é¾®å®–é¾Æꛧē¹›ę¹—ē§Šć¶ˆä“ƒš£‰–š¢ž–䎚䔶\"],[\"8ce6\",\"峕š£¬šč«¹å±øć“’š£•‘åµøé¾²ē…—䕘š¤ƒ¬š”ø£ä±·ć„ø摊š †¤š¦±č«Œä¾“š ˆ¹å¦æ腬锖š©£ŗå¼»\"],[\"8d40\",\"š ®Ÿ\"],[\"8d42\",\"š¢‡šØ„­ä„‚äš»š©¹ć¼‡é¾³šŖ†µäƒøćŸ–ä›·š¦±†ä…¼šØš²š§æä•­ć£”š„’šä•”䔛䶉䱻䵶ä—Ŗć戚¤¬ć™”ä“žä’½ä‡­å“¾åµˆåµ–ć·¼ć å¶¤å¶¹ć  ć ø幂åŗ½å¼„å¾ƒć¤ˆć¤”ć¤æć„ęƒ—ę„½å³„ć¦‰ę†·ę†¹ę‡ć¦øęˆ¬ęŠę‹„ęŒ˜ć§ø嚱\"],[\"8da1\",\"ćØƒę¢ę»ę‡ę‘šć©‹ę“€å“•å˜”é¾ŸćŖ—ę–†ćŖ½ę—æę™“ć«²ęš’ć¬¢ęœ–ć­‚ęž¤ę €ć­˜ę”Šę¢„ć­²ć­±ć­»ę¤‰ę„ƒē‰œę„¤ę¦Ÿę¦…ć®¼ę§–ćÆę©„ę©“ę©±ęŖ‚ćƬęŖ™ćƲęŖ«ęŖµę«”꫶ꮁęƁęÆŖę±µę²Ŗć³‹ę“‚ę“†ę“¦ę¶ć³Æ궤궱ęø•ęø˜ęø©ęŗ†šØ§€ęŗ»ę»¢ę»šé½æę»Øę»©ę¼¤ę¼“ćµ†š£½ę¾ę¾¾ćµŖćµµē†·å²™ć¶Šē€¬ć¶‘ēē”ēÆēæē‚‰š Œ„äć—±š »˜\"],[\"8e40\",\"š£»—åž¾š¦»“ē„¾š„Ÿ ć™Žę¦¢šØÆ©å­“ē©‰š„£”š©“™ē©„ē©½š„¦¬ēŖ»ēŖ°ē«‚ē«ƒē‡‘š¦’ä‡Šē«šē«ē«Ŗä‡Æ咲š„°ē¬‹ē­•ē¬©š„ŒŽš„³¾ē®¢ē­Æ莜š„®“š¦±æēÆč”ē®’ē®øš„“ ć¶­š„±„蒒ēÆŗē°†ē°µš„³ē±„ē²ƒš¤¢‚ē²¦ę™½š¤•øē³‰ē³‡ē³¦ē±“ē³³ē³µē³Ž\"],[\"8ea1\",\"ē¹§ä”š¦¹„ēµš¦»–ē’ē¶‰ē¶«ē„µē¶³ē·’š¤—š¦€©ē·¤ć““ē·µš”Ÿ¹ē·„šØ­ēøš¦„”š¦…šē¹®ēŗ’䌫鑬ēø§ē½€ē½ē½‡ē¤¶š¦‹é§”ē¾—š¦‘ē¾£š”™”š Ø䕜š£¦ä”ƒšØŒŗēæŗš¦’‰č€…č€ˆč€č€Øč€ÆšŖ‚‡š¦³ƒč€»č€¼č”š¢œ”䦉š¦˜¦š£·£š¦›Øęœ„č‚§šØ©ˆč„‡č„šå¢°š¢›¶ę±æš¦’˜š¤¾øꓧš”’Ščˆ˜š””žę©“š¤©„š¤Ŗ•ä‘ŗ舩š ¬š¦©’š£µ¾ä湚”“½č“¢č¢š¦¬Šš¤¦§š£”°š”³š£·øčŠŖꤛšÆ¦”䇛\"],[\"8f40\",\"蕋苐茚š ø–š”ž“曁š£…½š£•šč‰»č‹¢čŒ˜š£ŗ‹š¦¶£š¦¬…š¦®—š£—Žć¶æčŒå—¬čŽ…ä”‹š¦¶„čŽ¬čč“ć‘¾š¦»”ę©—č•šć’–š¦¹‚š¢»Æ葘š„Æ¤č‘±ć·“ä“¤ęŖ§č‘Šš£²µē„˜č’Øš¦®–š¦¹·š¦¹ƒč“žččŽ‘䒠蒓蓤š„²‘䉀š„³€ä•ƒč”“嫲š¦ŗ™ä”§č•³ä”–ęžæ蘖\"],[\"8fa1\",\"šØ˜„šØ˜»č—š§‚ˆč˜‚š”–‚š§ƒšÆ¦²ä•Ŗč˜Ø晈š”¢¢å·š§Žšč™¾č±šŖƒøčŸ®š¢°§čž±čŸšč å™”č™¬ę”–ä˜č”…č”†š§— š£¶¹š§—¤č”žč¢œä™›č¢“č¢µęč£…ē·š§œč¦‡č¦Šč¦¦č¦©č¦§č¦¼šØØ„č§§š§¤¤š§Ŗ½čŖœēž“釾čŖš§©™ē«©š§¬ŗš£¾äœ“š§¬øē…¼č¬Œč¬Ÿš„°š„•„č¬æ譌譍čŖ©š¤©ŗ讐讛čŖÆš”›Ÿä˜•č”č²›š§µ”š§¶šÆ§”ćœ„š§µ“č³–š§¶˜š§¶½č“’č“ƒš”¤č³›ēœč“‘š¤³‰ć»čµ·\"],[\"9040\",\"趩šØ€‚š”€”š¤¦Šć­¼šØ†¼š§„Œē«§čŗ­čŗ¶č»ƒé‹”č¼™č¼­šØ„šØ’č¾„錃šŖŠŸš ©č¾³ä¤ŖšØ§žšØ”½š£¶»å»øš£‰¢č湚Ŗ€”šØš¼šØ”š¢Œ„榀š¦»—逷šØ”¼š§Ŗ¾é”šØ•¬šØ˜‹é‚ؚ؜“郄šØ›¦é‚®éƒ½é…§ć«°é†©é‡„ē²¬šØ¤³š”ŗ‰éˆŽę²Ÿé‰é‰¢š„–¹éŠ¹šØ«†š£²›šØ¬Œš„—›\"],[\"90a1\",\"š “±éŒ¬é«šØ«”šØÆ«ē‚å«ƒšØ«¢šØ«„䄄鉄šØƬšØ°¹šØÆæ鍳鑛čŗ¼é–…閦鐦閠ęæ¶äŠ¹š¢™ŗšØ›˜š”‰¼š£ø®ä§Ÿę°œé™»éš–䅬隣š¦»•ę‡šéš¶ē£µšØ« éš½åŒä¦”š¦²øš ‰“š¦š©‚Æš©ƒ„š¤«‘š”¤•š£ŒŠéœ±č™‚霶ä؏䔽䖅š¤«©ēµå­éœ›éœš©‡•é—å­Šš©‡«éŸé„僐š£‚·š£‚¼éž‰éžŸéž±éž¾éŸ€éŸ’韠š„‘¬éŸ®ēœš©³éŸæ韵š©š§„ŗä«‘é “é ³é”‹é”¦ć¬Žš§…µćµ‘š ˜°š¤…œ\"],[\"9140\",\"š„œ†é£Šé¢·é£ˆé£‡ä«æš¦“§š”›“喰飔飦飬éø餹š¤Ø©ä­²š©”—š©¤…駵é،éØ»éؐ驘š„œ„曄š©‚±š©Æ•é« é«¢š©¬…é«“䰎鬔鬭šØ˜€å€“鬓š¦¦Øć£ƒš£½é­é­€š©“¾å©…š””£é®Žš¤‰‹é°‚éÆæ鰌š©¹Ø鷔š©¾·šŖ†’šŖ†«šŖƒ”šŖ„£šŖ‡Ÿéµ¾é¶ƒšŖ„“éøŽę¢ˆ\"],[\"91a1\",\"鷄š¢…›šŖ†“šŖˆ š”¤»šŖˆ³é“¹šŖ‚¹šŖŠ“éŗéŗ•éŗžéŗ¢ä““éŗŖéŗÆš¤¤é»ć­ ć§„ć“ä¼²ćž¾šØ°«é¼‚鼈䮖鐤š¦¶¢é¼—鼖鼹嚟嚊齅é¦øš©‚‹éŸ²č‘æ齢齩ē«œé¾Žēˆ–䮾š¤„µš¤¦»ē…·š¤§øš¤ˆš¤©‘ēŽžšØƚš”£ŗē¦ŸšØ„¾šØø¶é©é³šØ©„鋬鎁鏋šØ„¬š¤’¹ēˆ—滫ē²ē©ƒēƒš¤‘³š¤øē…¾š”ŸÆē‚£š”¢¾š£–™ć»‡š”¢…š„Æš”Ÿøćœ¢š”›»š” ¹ć›”š”“š”£‘š„½‹ćœ£š”›€å›š¤Ø„š”¾š”ŠØ\"],[\"9240\",\"š”†š”’¶č”ƒš£š¦č”ƒč‘•š¤¦”š§…„š£ø±š„•œš£»»š§’ä““š£›®š©¦š¦¼¦ęŸ¹ćœ³ć°•ć·§å”¬š”¤¢ę ä—š£œæš¤ƒ”š¤‚‹š¤„š¦°”哋嚞š¦š±åš’š æŸš ®Øš øé†šØ¬“鎜ä»øå„«ć ™š¤¶äŗ¼š ‘„š æ佋侊š„™‘å©Øš †«š ‹ć¦™š ŒŠš ”ćµä¼©š ‹€šØŗ³š ‰µč«šš ˆŒäŗ˜\"],[\"92a1\",\"働儍侢伃š¤ØŽš£ŗŠä½‚倮偬傁äæŒäæ„å˜åƒ¼å…™å…›å…å…žę¹¶š£–•š£ø¹š£ŗæęµ²š”¢„š£ŗ‰å†Ø凃š — ä“š ’£š ’’š ’‘čµŗšØŖœš œŽå‰™åŠ¤š ”³å‹”鍮ä™ŗē†Œš¤ŽŒš ° š¤¦¬š”ƒ¤ę§‘š øē‘¹ć»žē’™ē”ē‘–ēŽ˜ä®Žš¤Ŗ¼š¤‚åć–„ēˆš¤ƒ‰å–“š …响š Æ†åœé‰é›“鍦埝垍åæć˜¾å£‹åŖ™šØ©†š”›ŗš”Æš”œåجå¦ø銏婾嫏åؒš„„†š”§³š”””š¤Š•ć›µę“…ē‘ƒåØ”š„ŗƒ\"],[\"9340\",\"åŖšØƗš “鏠ē’Œš”Œƒē„…䄲鐈šØ§»éŽ½ćž å°žå²žå¹žå¹ˆš”¦–š”„¼š£«®å»å­š”¤ƒš”¤„ćœš”¢ ć›š”›¾ć›“č„ŖšØ©‡š”¶ŗš£‘²šØ¦Ø弌弎š”¤§š”ž«å©«š”œ»å­„č˜”š§—½č” ę¾š¢” š¢˜«åæ›ćŗøš¢–Æš¢–¾š©‚ˆš¦½³ę‡€š €¾š †š¢˜›ę†™ę†˜ęµš¢²›š¢“‡š¤›”š©…\"],[\"93a1\",\"ꑱš¤™„š¢­ŖćØ©š¢¬¢š£‘š©£Ŗš¢¹øęŒ·šŖ‘›ę’¶ęŒ±ę‘š¤§£š¢µ§ęŠ¤š¢²”ę»ę•«ę„²ćÆ“š£‚Žš£Š­š¤¦‰š£Š«å”š£‹ š”£™š©æꛎš£Š‰š£†³ć« ä†š„–„šØ¬¢š„–š”›¼š„•›š„„ē£®š£„ƒš” Ŗš£ˆ“摤š£ˆš£†‚š¤‹‰ęšŽš¦“¤ę™«ä®“ę˜°š§”°š”·«ę™£š£‹’š£‹”ꘞš„”²ć£‘š£ ŗš£ž¼ć®™š£ž¢š£¾ē“ć®–꾏š¤˜Ŗę¢¶ę žćƄęŖ¾ć”£š£Ÿ•š¤’‡ęØ³ę©’ę«‰ę¬…š”¤’ę”‘ę¢˜ę©ŒćƗę©ŗꭗš£æ€š£²šéŽ é‹²šØÆŖšØ«‹\"],[\"9440\",\"銉šØ€žšØ§œé‘§ę¶„ę¼‹š¤§¬ęµ§š£½æć¶ęø„š¤€¼åؽęøŠå”‡ę“¤ē”‚ē„»š¤Œšš¤‰¶ēƒ±ē‰ēŠ‡ēŠ”š¤žš¤œ„兹š¤Ŗ¤š —«ē‘ŗš£»øš£™Ÿš¤©Šš¤¤—š„æ”ć¼†ćŗ±š¤«ŸšØ°£š£¼µę‚§ć»³ē“Œē¼éŽ‡ē·ä’Ÿš¦·Ŗ䕑ē–ƒć½£š¤³™š¤“†ć½˜ē••ē™³šŖ—†ć¬™ē‘ؚثŒš¤¦«š¤¦Žć«»\"],[\"94a1\",\"ć·š¤©Žć»æš¤§…š¤£³é‡ŗ圲鍂šØ«£š””¤åƒŸš„ˆ”š„‡§ēøš£ˆ²ēœŽēœē»š¤š—š£žć©žš¤£°ēøē’›ćŗ暤Ŗŗš¤«‡äƒˆš¤Ŗ–š¦†®éŒ‡š„–ē žē¢ē¢ˆē£’ēē„™š§š„›£ä„Žē¦›č’–ē¦„ęØ­š£»ŗēØŗē§“䅮š”›¦ä„²éˆµē§±š µŒš¤¦Œš Š™š£¶ŗš”®ć–—å•«ć•°ćšŖš ‡”š °ē«¢å©™š¢›µš„ŖÆš„Ŗœå؍š ‰›ē£°åØŖš„Ɔē«¾ä‡¹ē±ē±­äˆ‘š„®³š„ŗ¼š„ŗ¦ē³š¤§¹š”ž°ē²Žē±¼ē²®ęŖ²ē·œēø‡ē·“ē½Žš¦‰”\"],[\"9540\",\"š¦…œš§­ˆē¶—š„ŗ‚ä‰Ŗš¦­µš ¤–ęŸ–š Žš£—åŸ„š¦’š¦øš¤„¢ēæē¬§š  ¬š„«©š„µƒē¬Œš„øŽé§¦č™…é©£ę؜š£æć§¢š¤§·š¦–­é؟š¦– č’€š§„§š¦³‘ä“Ŗč„·ä‚čƒ†č„‰č…‚š¦ž“飃š¦©‚č‰¢č‰„š¦©‘č‘“š¦¶§č˜š§ˆ›åŖ†ä…æš””€å¬«š”¢”嫤š”£˜čš šÆ¦¼š£¶č ­š§¢å؂\"],[\"95a1\",\"č”®ä½…č¢‡č¢æč£¦č„„č„š„šƒč„”š§ž…š§ž„šØƵšØƙšØ®œšØ§¹ćŗ­č’£ä›µä›ćŸ²čؽč؜š©‘ˆå½éˆ«š¤Š„ę—”ē„©ēƒ„š””…éµ­č²Ÿč³©š§·œå¦šēŸƒå§°ä®ć›”čøŖčŗ§š¤°‰č¼°č½Šä‹“ę±˜ę¾»š¢Œ”ä¢›ę½¹ęŗ‹š”ŸšéÆ©ćšµš¤¤Æ邻邗啱䤆醻鐄šØ©‹ä¢šØ«¼é§šØ°šØ°»č“„čث閙閧閗閖šØ““ē‘…滂š¤£æš¤©‚š¤Ŗ滧š£ˆ„随šØ»§šØ¹¦šØ¹„ć»Œš¤§­š¤©øš£æ®ē’ē‘«ć»¼éš©‚°\"],[\"9640\",\"ꔇä؝š©‚“š„ŸŸééØšØ¦‰šØ°¦šØ¬Æš¦Ž¾éŠŗå¬‘č­©ä¤¼ē¹š¤ˆ›éž›é±é¤øš ¼¦å·šØƅš¤Ŗ²é Ÿš©“šé‹¶š©——釄䓀šØ­š¤©§šØ­¤é£œšØ©…ć¼€éˆŖä¤„č”é¤»é„š§¬†ć·½é¦›ä­Æé¦Ŗ驜šØ­„š„£ˆęŖéؔ嫾éØÆš©£±ä®š©„ˆé¦¼ä®½ä®—鍽唲š”Œ‚å ¢š¤¦ø\"],[\"96a1\",\"š”“Øē”„š¢œŸš£¶øę£…ćµ½é‘˜ć¤§ę…š¢žš¢„«ę„‡é±é±“鱻鰵鰐é­æéƏš©ø­é®ŸšŖ‡µšŖƒ¾é“”ä²®š¤„„éø˜ä²°é“ŒšŖ†“šŖƒ­šŖƒ³š©¤Æé¶„č’½š¦ø’š¦æŸš¦®‚č—¼ä”³š¦¶¤š¦ŗ„š¦·°č č—®š¦ø€š£Ÿ—š¦¤ē§¢š£–œš£™€ä¤­š¤§žćµ¢é›éŠ¾éˆš Šæē¢¹é‰·é‘äæ¤ć‘€é¤š„•ē ½ē””ē¢¶ē”‹š”—š£‡‰š¤„ćššä½²ęæšęæ™ē€žē€žå”š¤†µåž»å£³åžŠé“–埗ē„“ć’Æš¤†¬ē‡«š¦±€š¤¾—å¬Øš”žµšØ©‰\"],[\"9740\",\"ę„Œå«Žå؋䊼š¤’ˆćœ¬ä­»šØ§¼éŽ»éŽøš”£–š ¼č‘²š¦³€š”“š¤‹ŗš¢°¦š¤å¦”š£¶·š¦ē¶Øš¦…›š¦‚¤š¤¦¹š¤¦‹šØ§ŗé‹„ē¢ć»©ē’“šØ­£š”¢Ÿć»”š¤Ŗ³ę«˜ē³ē»ć»–š¤Ø¾š¤Ŗ”š”Ÿ™š¤©¦š Ž§š”¤š¤§„ē‘ˆš¤¤–ē‚„š¤„¶éŠ„ē¦éŸš “¾éŒ±šØ«ŽšØؖ鎆šØƧš„—•ä¤µšØŖ‚ē…«\"],[\"97a1\",\"š¤„ƒš ³æ嚤š ˜šš Æ«š ²ø唂ē§„š”Ÿŗē·¾š”›‚š¤©š””’ä”®éćœŠšØ«€š¤¦­å¦°š”¢æš”¢ƒš§’„åŖ”ć›¢š£µ›ćš°é‰Ÿå©¹šØŖš””¢é“ć³š Ŗ“äŖ–ć¦Šåƒ“ćµ©ćµŒš”Žœē…µä‹»šØˆ˜ęøš©ƒ¤ä“«ęµ—š§¹ē§ę²Æć³–š£æ­š£ø­ęø‚ę¼ŒćµÆš µē•‘ćš¼ć“ˆäš€ć»šä”±å§„é‰®ä¤¾č½šØ°œš¦Æ€å ’åŸˆć›–š”‘’ēƒ¾š¤¢š¤©±š¢æ£š”Š°š¢Ž½ę¢¹ę„§š”Ž˜š£“„š§Æ“š£›ŸšØŖƒš£Ÿ–š£ŗš¤²Ÿęؚš£š­š¦²·č¾ä“Ÿä“Ž\"],[\"9840\",\"š¦“¦š¦µ‘š¦²‚š¦æžę¼—š§„‰čŒ½š”œŗ菭š¦²€š§“š”Ÿ›å¦‰åŖ‚š”ž³å©”婱š”¤…š¤‡¼ćœ­å§Æš”œ¼ć›‡ē†ŽéŽęššš¤Š„å©®åØ«š¤Š“ęØ«š£»¹š§œ¶š¤‘›š¤‹Šē„š¤‰™šØ§”ä¾°š¦“Ø峂š¤“Žš§¹š¤Ž½ę،š¤‰–š”Œ„ē‚¦ē„³š¤©ć¶„ę³ŸšÆ „š¤©ē¹„姫å“Æć·³å½œš¤©š”ŸŸē¶¤č¦\"],[\"98a1\",\"咅š£«ŗš£Œ€š ˆ”坾š £•š ˜™ćæ„š”¾žšŖŠ¶ē€ƒš©…›åµ°ēŽē³“šØ©™š© äæˆēæ§ē‹ēŒš§«“ēŒøēŒ¹š„›¶ēēˆćŗ©š§¬˜é¬ē‡µš¤£²ē”臶滊ēœŒć»‘ę²¢å›½ē™ēžēŸć»¢ć»°ć»“ć»ŗē““ć¼Žć½“ē•‚ē•­ē•²ē–ć½¼ē—ˆē—œćæ€ē™ćæ—ē™“ćæœē™ŗš¤½œē†ˆå˜£č¦€å”©ä€ēƒä€¹ę”䁅旛ēž˜äŖäÆ属ēž¾ēŸ‹å£²ē ˜ē‚¹ē œä‚Øē ¹ē”‡ē”‘ē”¦č‘ˆš„”µē¤³ę ƒē¤²ä„ƒ\"],[\"9940\",\"䄉ē¦‘ē¦™č¾»ēØ†č¾¼ä…§ēŖ‘䆲ēŖ¼č‰¹ä‡„ē«ē«›ä‡äø”ē­¢ē­¬ē­»ē°’ē°›ä‰ ä‰ŗē±»ē²œäŠŒē²ø䊔ē³­č¾“ēƒ€š ³ē·ē·”ē·ē·½ē¾®ē¾“ēŠŸäŽ—耠耄ē¬¹č€®č€±č”ć·Œåž“ē‚ č‚·čƒ©ä­č„ŒēŒŖ脎脒ē• č„”äć¬¹č…–č…™č…š\"],[\"99a1\",\"䐓å ŗč…¼č†„ä„č†“ä­č†„åŸÆč‡č‡¤č‰”ä’čŠ¦č‰¶č‹Šč‹˜č‹æä’°č—é™©ę¦Šč…ēƒµč‘¤ęƒ£č’ˆä”„č’¾č“”č“ø蔐č”øč•’ä”»č•Æč•°č— ä•·č™²čš’čš²č›Æé™…čž‹ä˜†ä˜—č¢®č£æ褤脇覑š§„§čØ©čØøčŖ”čŖ“č±‘č³”č³²č“œäž˜å”Ÿč·ƒäŸ­ä»®čøŗå—˜å”č¹±å—µčŗ°ä ·č»Žč»¢č»¤č»­č»²č¾·čæčæŠčæŒé€³é§„䢭飠鈓䤞éˆØ鉘鉫銱銮éŠæ\"],[\"9a40\",\"鋣鋫鋳鋓鋽鍃鎄鎭䄅䄑éŗæ鐗匁鐝鐭鐾ä„Ŗé‘”é‘¹é”­é–¢ä¦§é—“é˜³ä§„ęž äؤ靀äص鞲韂噔䫤ęƒØ颹䬙飱唄餎餙冓餜餷鄂鄝鄢䭰駅䮝éؼ鬏ēŖƒé­©é®éƝéƱéÆ“ä±­é° ćÆš”Ƃ鵉é°ŗ\"],[\"9aa1\",\"é»¾å™é¶“é¶½é·€é·¼é“¶č¾¶é¹»éŗ¬éŗ±éŗ½é»†é“œé»¢é»±é»øē«ˆé½„š ‚”š Š·š Ž ę¤šé“ƒå¦¬š “—å”€é“ćž¹š —•š ˜•š ™¶š”šŗ块ē…³š «‚š «š ®æå‘ŖšÆ »š Æ‹å’žš Æ»š °»š ±“š ±„š ±¼ęƒ§š ²å™ŗš ²µš ³š ³­š µÆš ¶²š ·ˆę„•é°Æčž„š ø„š øŽš »—š ¾š ¼­š ¹³å° š ¾¼åø‹š”œš”š”¶ęœžš”»š”‚ˆš”‚–晇š”‚æš”ƒ“š”„Æš”„»å¤č’­š”‹£š”µš”Œ¶č®š”•·š”˜™š”Ÿƒš”Ÿ‡ä¹øē‚»š” ­š”„Ŗ\"],[\"9b40\",\"š”Ø­š”©…š”°Ŗš”±°š”²¬š”»ˆę‹ƒš”»•š”¼•ē†˜ę”•š¢…ę§©ć›ˆš¢‰¼š¢—š¢ŗš¢œŖš¢”±š¢„č‹½š¢„§š¢¦“š¢«•č¦„š¢«Øč¾ š¢¬Žéžøš¢¬æ锇éŖ½š¢±Œ\"],[\"9b62\",\"š¢²ˆš¢²·š„ÆØš¢“ˆš¢“’š¢¶·š¢¶•š¢¹‚š¢½“š¢æŒš£€³š£¦š£ŒŸš£žå¾±ę™ˆęšæš§©¹š£•§š£—³ēˆš¤¦ŗēŸ—š£˜šš£œ–ēŗ‡š †å¢µęœŽ\"],[\"9ba1\",\"ꤘš£Ŗ§š§™—š„梚£ø‘š£ŗ¹š§—¾š¢‚šä£äŖøš¤„™šØŖšš¤‹®š¤Œš¤€»š¤Œ“š¤Ž–š¤©…š —Šå‡’š ˜‘妟š”ŗØć®¾š£³æš¤„š¤“–垈š¤™“榛š¤œÆšØ—Øš©§‰ć¢š¢‡ƒč­žšØ­Žé§–š¤ ’š¤£»š¤Ø•ēˆ‰š¤«€š ±øå„„š¤ŗ„š¤¾†š ¹č»šš„€¬åŠåœæē…±š„Š™š„™š£½Šš¤Ŗ§å–¼š„‘†š„‘®š¦­’é‡”ć‘³š„”暧˜²š„•žäœ˜š„•¢š„•¦š„Ÿ‡š¤¤æš„”å¦ć“»š£Œęƒžš„¤ƒä¼šØ„ˆš„Ŗ®š„®‰š„°†š”¶åž”ē…‘ę¾¶š¦„‚š§°’遖š¦†²š¤¾šč­¢š¦‚š¦‘Š\"],[\"9c40\",\"嵛š¦Æ·č¼¶š¦’„š”¤œč«Ŗš¤§¶š¦’ˆš£æÆš¦”’äƀš¦–暦šµš¢œ›é‘„š„Ÿ”ꆕåاšÆ£ä¾»åš¹š¤””š¦›¼ä¹Ŗš¤¤“é™–ę¶š¦²½ć˜˜č„·š¦ž™š¦”®š¦‘š¦”žē‡Ÿš¦£‡ē­‚š©ƒ€š Ø‘š¦¤¦é„„š¦¤¹ē©…é·°š¦§ŗéئš¦Ø­ć™Ÿš¦‘©š €”ē¦ƒš¦Ø“š¦­›å“¬š£”™čš¦®ä›š¦²¤ē”»č”„š¦¶®å¢¶\"],[\"9ca1\",\"朜š¢–š§‹š§‡ć±”š§Š€š§Š…銁š¢…ŗš§Š‹éŒ°š§‹¦š¤§ę°¹é’Ÿš§‘š »øč §č£µš¢¤¦šØ‘³š”ž±ęŗøš¤ØŖš”  ć¦¤ćš¹å°ē§£ä”æꚶš©²­š©¢¤č„ƒš§ŸŒš§”˜å›–䃟š”˜Šć¦”š£œÆšØƒØš”…ē†­č¦š§§š©†Ø婧䲷š§‚ƚئ«š§§½š§ØŠš§¬‹š§µ¦š¤…ŗē­ƒē„¾šØ€‰ę¾µšŖ‹Ÿę؃šØŒ˜åŽ¢š¦ø‡éŽæę ¶éšØ…ƚ؀£š¦¦µš”­š£ˆÆšØˆå¶…šØ°°šØ‚ƒåœ•é £šØ„‰å¶«š¤¦ˆę–¾ę§•å’š¤Ŗ„š£¾ć°‘ęœ¶šØ‚šØƒ“šØ„®š”¾”šØ…\"],[\"9d40\",\"šØ†‰šØ†ÆšØˆššØŒ†šØŒÆšØŽŠć—ŠšØ‘ؚؚŖä£ŗę¦šØ„–ē ˆé‰•šØ¦ø䏲šØ§§äŸšØ§ØšØ­†šØƔå§øšØ°‰č¼‹šØæ…š©ƒ¬ē­‘š©„š©„¼ć··š©…žš¤«ŠčæēŠåš‹š©“§š©—©š©–°š©–øš©œ²š©£‘š©„‰š©„Ŗš©§ƒš©ØØš©¬Žš©µšš©¶›ēŗŸš©»øš©¼£ä²¤é•‡šŖŠ“ē†¢šŖ‹æ䶑递šŖ—‹ä¶œš ²œč¾¾å—\"],[\"9da1\",\"č¾ŗš¢’°č¾¹š¤Ŗ“䔉ē¹æę½–ęŖ±ä»Ŗ擤šØ¬¬š§¢ćœŗčŗ€š”ŸµšØ€¤šØ­¬šØ®™š§Ø¾š¦šÆć·«š§™•š£²·š„˜µš„„–äŗšš„ŗš¦‰˜åšæš ¹­čøŽå­­š£ŗˆš¤²žęžę‹š”Ÿ¶š””»ę”°å˜­š„±Šåšš„Œ‘ć·†š©¶˜ä±½å˜¢å˜žē½‰š„»˜å„µš£µ€č°äøœš æŖš µ‰š£šŗč„—éµžč“˜ē˜»é±…ē™Žēž¹é…å²č…ˆč‹·å˜„č„²č˜č‚½å—Ŗē„¢å™ƒå–š ŗć—Žå˜…å—±ę›±šØ‹¢ć˜­ē”“嗰å–ŗ咗啲š ±š ²–廐š„…ˆš ¹¶š¢±¢\"],[\"9e40\",\"š ŗ¢éŗ«ēµšå—žš”µęŠé­å’”č³ē‡¶é…¶ę¼ęŽ¹ę¾å•©š¢­ƒé±²š¢ŗ³å†šć“Ÿš ¶§å†§å‘å”žå”“ē™¦čø­š¦¢Šē–±č‚¶č „čž†č£‡č†¶čœš”ƒä“¬ēŒ„š¤œ†å®čŒ‹š¦¢“å™»š¢›“š§“Æš¤†£š§µ³š¦»š§Š¶é…°š”‡™éˆˆš£³¼šŖš©š ŗ¬š »¹ē‰¦š”²¢äŽš¤æ‚š§æ¹š æ«äƒŗ\"],[\"9ea1\",\"é±ę”Ÿš¢¶ ä£³š¤Ÿ š©µ¼š æ¬š øŠę¢š§–£š æ­\"],[\"9ead\",\"š¦ˆš”†‡ē†£ēŗŽéµäøšäø„ć•·å¬ę²²å§ćš¬ć§œå½ćš„š¤˜˜å¢šš¤­®čˆ­å‘‹åžŖš„Ŗ•š „¹\"],[\"9ec5\",\"ć©’š¢‘„ē“š©ŗ¬ä“‰éÆ­š£³¾š©¼°ä±›š¤¾©š©–žš©æžč‘œš£¶¶š§Š²š¦ž³š£œ ęŒ®ē“„š£»·š£ø¬ćØŖé€ˆå‹Œć¹“ć™ŗ䗩š ’Žē™€å«°š ŗ¶ē”ŗš§¼®å¢§ä‚æ噼鮋嵓ē™”šŖ“éŗ…ä³”ē—¹ćŸ»ę„™š£ƒšš¤²\"],[\"9ef5\",\"噝š”Š©åž§š¤„£š©ø†åˆ“š§‚®ć–­ę±Šéµ¼\"],[\"9f40\",\"ē±–鬹埞š”¬å±“ę““š©“š¦Œµš§…¤čš­š “Øš¦“¢š¤«¢š µ±\"],[\"9f4f\",\"凾š”¼å¶Žéœƒš”·‘éŗéŒē¬Ÿé¬‚峑ē®£ę‰ØęŒµé«æēƏé¬Ŗē±¾é¬®ē±‚ē²†é°•ēƼ鬉鼗鰛š¤¤¾é½šå•³åƃäæ½éŗ˜äæ²å‰ ćø†å‹‘坧偖妷åø’éŸˆé¶«č½œå‘©éž“é„€éžŗåŒ¬ę„°\"],[\"9fa1\",\"ę¤¬åšé°Šé“‚ä°»é™ę¦€å‚¦ē•†š”­é§šå‰³\"],[\"9fae\",\"酙隁酜\"],[\"9fb2\",\"酑šØŗ—ęæš¦“£ę«Šå˜‘醎ē•ŗꊅš ¼ēē±°š„°”š£³½\"],[\"9fc1\",\"š¤¤™ē›–鮝äøŖš ³”čŽ¾č”‚\"],[\"9fc9\",\"å±Šę§€åƒ­åŗåˆŸå·µä»Žę°±š ‡²ä¼¹å’œå“šåŠšč¶‚ć—¾å¼Œć—³\"],[\"9fdb\",\"ę­’é…¼é¾„é®—é ®é¢“éŖŗéŗØéŗ„ē…ŗē¬”\"],[\"9fe7\",\"ęÆŗ蠘ē½ø\"],[\"9feb\",\"嘠šŖ™Šč¹·é½“\"],[\"9ff0\",\"č·”č¹éøœčøęŠ‚šØ½čøØč¹µē«“š¤©·ēؾē£˜ę³Ŗ詧ē˜‡\"],[\"a040\",\"šØ©šé¼¦ę³ŽčŸ–ē—ƒšŖŠ²ē”“šÆ”€č“Œē‹¢ē±č¬­ēŒ‚ē“±č³«š¤Ŗ»č˜Æå¾ŗč¢ ä’·\"],[\"a055\",\"š” »š¦ø…\"],[\"a058\",\"č©¾š¢”›\"],[\"a05b\",\"ęƒ½ē™§é«—éµ„é®é®čŸµ\"],[\"a063\",\"č č³·ēŒ¬éœ”é®°ć—–ēŠ²ä°‡ē±‘é„Šš¦…™ę…™ä°„éŗ–ę…½\"],[\"a073\",\"坟ę…ÆęŠ¦ęˆ¹ę‹Žć©œę‡¢åŽŖš£µę¤ę ‚ć—’\"],[\"a0a1\",\"嵗šØƂčæššØø¹\"],[\"a0a6\",\"僙š”µ†ē¤†åŒ²é˜øš ¼»ä„\"],[\"a0ae\",\"ēŸ¾\"],[\"a0b0\",\"ē³‚š„¼šē³šēØ­č¦č£ēµē”…ē“²č¦”čˆšęœŒč¢š§’†č›ē“°č„ƒēœ¤č¦‰š¦ŸŒē•“š¦»‘čž©čŸŽč‡ˆčžŒč©‰č²­č­ƒēœ«ē“øč“šć˜µę¦²č¶¦\"],[\"a0d4\",\"覩ē‘Øę¶¹čŸš¤€‘ē“§ć·›ē…¶ę‚¤ę†œć³‘ē…¢ę·\"],[\"a0e2\",\"ē½±šØ¬­ē‰ęƒ©ä­¾åˆ ć°˜š£³‡š„»—š§™–š„”±š”„„š”‹¾š©¤ƒš¦·œš§‚­å³š¦†­šØ؏š£™·š ƒ®š¦”†š¤¼Žä•¢å¬Ÿš¦Œé½éŗ¦š¦‰«\"],[\"a3c0\",\"ā€\",31,\"ā”\"],[\"c6a1\",\"ā‘ \",9,\"ā‘“\",9,\"ā…°\",9,\"äø¶äøæäŗ…äŗ å†‚冖冫勹åŒø卩厶夊宀巛ā¼³å¹æå»“å½å½”ę”“ę— ē–’ē™¶č¾µéš¶ĀØĖ†ćƒ½ćƒ¾ć‚ć‚žć€ƒä»ć€…ć€†ć€‡ćƒ¼ļ¼»ļ¼½āœ½ć\",23],[\"c740\",\"恙\",58,\"ć‚”ć‚¢ć‚£ć‚¤\"],[\"c7a1\",\"ć‚„\",81,\"Š\",5,\"ŠŠ–\",4],[\"c840\",\"Š›\",26,\"ёŠ¶\",25,\"ā‡§ā†øā†¹ć‡š ƒŒä¹šš ‚Šåˆ‚ä’‘\"],[\"c8a1\",\"龰冈龱š§˜‡\"],[\"c8cd\",\"ļæ¢ļæ¤ļ¼‡ļ¼‚ćˆ±ā„–ā„”悛悜āŗ€āŗ„āŗ†āŗ‡āŗˆāŗŠāŗŒāŗāŗ•āŗœāŗāŗ„āŗ§āŗŖāŗ¬āŗ®āŗ¶āŗ¼āŗ¾ā»†ā»Šā»Œā»ā»ā»–ā»—ā»žā»£\"],[\"c8f5\",\"ŹƒÉÉ›É”ɵœĆøŋŹŠÉŖ\"],[\"f9fe\",\"ļæ­\"],[\"fa40\",\"š •‡é‹›š —Ÿš£æ…č•ŒäŠµēÆå†µć™‰š¤„‚šØ§¤é„š”§›č‹®š£³ˆē ¼ę„ę‹Ÿš¤¤³šØ¦Ŗš Š š¦®³š”Œ…侫š¢“­å€ˆš¦“©š§Ŗ„š£˜€š¤Ŗ±š¢”“倩š ¾å¾¤š Ž€š ‡ę»›š Ÿå½å„ć‘ŗå„Žé”¬ćƒč–š¤¦¤š ’‡å… š£Ž“å…Ŗš Æ暢ƒ¼š ‹„š¢”°š –Žš£ˆ³š”¦ƒå®‚č½š –³š£²™å†²å†ø\"],[\"faa1\",\"é““å‡‰å‡å‡‘ć³œå‡“š¤Ŗ¦å†³å‡¢å‚å‡­čę¤¾š£œ­å½»åˆ‹åˆ¦åˆ¼åŠµå‰—劔効勅ē°•č•‚å‹ č˜š¦¬“包šØ«žå•‰ę»™š£¾€š „”š£æ¬åŒ³å„š Æ¢ę³‹š”œ¦ę ›ē•ęŠćŗŖć£Œš”›Øē‡ä’¢å­å“šØš«å¾åæš”––š”˜“ēŸ¦åŽ“šØŖ›åŽ åŽ«åŽ®ēŽ§š„²ć½™ēŽœåå…ę±‰ä¹‰åŸ¾å™ćŖ«š ®å š£æ«š¢¶£å¶š ±·å“ē¹å”«ę™—ęµ›å‘­š¦­“š µ“啝咏咤䞦š”œš »ć¶“š µ\"],[\"fb40\",\"šØ¦¼š¢š˜å•‡ä³­åÆē—喆喩嘅š”£—š¤€ŗ䕒š¤µęš³š”‚“å˜·ę›š£ŠŠęš¤ęš­å™å™ē£±å›±éž‡å¾åœ€å›Æ园šØ­¦ć˜£š”‰å†š¤†„ę±®ē‚‹å‚ćš±š¦±¾åŸ¦š”–å ƒš”‘”š¤£å ¦š¤Æµå”œå¢Ŗć•”å£ å£œš”ˆ¼å£»åÆæ坃šŖ…š¤‰øé“ć–”å¤Ÿę¢¦ć›ƒę¹™\"],[\"fba1\",\"š”˜¾åؤ啓š”š’č”…å§‰š µŽš¦²š¦“Ŗš”Ÿœå§™š”Ÿ»š”ž²š¦¶¦ęµ±š” Øš”›•å§¹š¦¹…åŖ«å©£ć›¦š¤¦©å©·ćœˆåŖ–ē‘„嫓š¦¾”š¢•”涅š”¤‘ćœ²š”šøåŗƒå‹å­¶ę–ˆå­¼š§ØŽä€„䔝š ˆ„åÆ•ę… š”Ø“š„§Œš –„åƳ宝䓐尅š”­„å°“ēŽå°”š”²„š¦¬Ø屉䣝岅峩å³Æ嶋š”·¹š”ø·å“å“˜åµ†š”ŗ¤å²ŗå·—č‹¼ć ­š¤¤š¢‰š¢…³čŠ‡ć ¶ćƂåø®ęŖŠå¹µå¹ŗš¤’¼š ³“厦äŗ·å»åŽØš”±åø‰å»“šØ’‚\"],[\"fc40\",\"å»¹å»»ć¢ å»¼ę ¾é›å¼š ‡šÆ¢”ć«žä¢®š”Œŗå¼ŗš¦¢ˆš¢å½˜š¢‘±å½£éž½š¦¹®å½²é€šØØ¶å¾§å¶¶ćµŸš„‰š”½Ŗš§ƒøš¢™Ø釖š ŠžšØØ©ę€±ęš…š””·ć„£ć·‡ć˜¹åžš¢ž“ē„±ć¹€ę‚žę‚¤ę‚³š¤¦‚š¤¦š§©“ē’¤åƒ”åŖ ę…¤č¤ę…‚šÆ¢¦š¦»’ę†å‡“š ™–ꆇå®Ŗš£¾·\"],[\"fca1\",\"š¢”Ÿę‡“šØ®š©„ę‡ć¤²š¢¦€š¢£ę€£ę…œę”žęŽ‹š „˜ę‹…š”°ę‹•š¢øę¬š¤§Ÿćؗęøęøš”ŽŽš”Ÿ¼ę’ę¾Šš¢ø¶é ”š¤‚Œš„œę“”꓄鑻橦ęŗć©—ę•ę¼–š¤ØØš¤Ø£ę–…ę•­ę•Ÿš£¾ę–µš¤„€ä¬·ę—‘䃘š” ©ę— ę—£å柚£€ę˜˜š£‡·š£‡øꙄš£†¤š£†„ꙋš ¹µę™§š„‡¦ę™³ę™“š”ø½š£ˆ±šØ—“š£‡ˆš„Œ“ēŸ…š¢£·é¦¤ęœ‚š¤Žœš¤Ø”欫ę§ŗš£Ÿ‚ęžę§ę¢š¤‡š©ƒ­ęŸ—ä“©ę ¢ę¹éˆ¼ę š£¦š¦¶ ę”\"],[\"fd40\",\"š£‘Æ꧔ę؋šØ«Ÿę„³ę£ƒš£—ę¤ę¤€ć“²ć؁š£˜¼ć®€ęž¬ę„”šØ©Šä‹¼ę¤¶ę¦˜ć®”š ‰č£å‚ę§¹š£™™š¢„Ŗę©…š£œƒęŖćÆ³ęž±ę«ˆš©†œć°ę¬š ¤£ęƒžę¬µę­“š¢Ÿęŗµš£«›š Žµš”„˜ć€å”š£­šęÆ”š£»¼ęÆœę°·š¢’‹š¤£±š¦­‘ę±ščˆ¦ę±¹š£¶¼ä“…š£¶½š¤†¤š¤¤Œš¤¤€\"],[\"fda1\",\"š£³‰ć›„ć³«š “²é®ƒš£‡¹š¢’‘ē¾ę ·š¦“„š¦¶”š¦·«ę¶–ęµœę¹¼ę¼„š¤„暤‚…š¦¹²č”³š¦½“å‡‡ę²œęøč®šØ¬”ęøÆš£øÆē‘“š£¾‚ē§Œę¹åŖ‘š£‹ęæøćœę¾š£ø°ę»ŗš”’—š¤€½ä••é°ę½„ę½œćµŽę½“š©…°ć“»ę¾Ÿš¤…„ęæ“š¤‚‘š¤…•š¤€¹š£æ°š£¾“š¤„æ凟š¤…–š¤…—š¤…€š¦‡ē‹ē¾ē‚§ē‚ēƒŒēƒ•ēƒ–ēƒŸä„„ć·Øē†“ē†–š¤‰·ē„«ē……åŖˆē…Šē…®å²œš¤„ē…é¢š¤‹ē„¬š¤‘šš¤Ø§š¤Ø¢ē†ŗšØÆØē‚½ēˆŽ\"],[\"fe40\",\"鑂ēˆ•å¤‘鑃ēˆ¤éš„˜…ēˆ®ē‰€š¤„“ę¢½ē‰•ē‰—ć¹•š£„ę ę¼½ēŠ‚ēŒŖēŒ«š¤ £šØ «ä£­šØ „ēŒØēŒ®ēēŽŖš °ŗš¦Ø®ē‰ē‘‰š¤‡¢š”›§š¤Ø¤ę˜£ć›…š¤¦·š¤¦š¤§»ē·ē•ę¤ƒš¤Ø¦ē¹š —ƒć»—ē‘œš¢¢­ē‘ šØŗ²ē‘‡ē¤ē‘¶čŽ¹ē‘¬ćœ°ē‘“鏱ęجē’‚ä„“š¤ŖŒ\"],[\"fea1\",\"š¤…Ÿš¤©¹šØ®å­†šØ°ƒš”¢žē“ˆš”¦ˆē”Žē“©ē”žšØ»™š”©‹åƗšØŗ¬éŽ…ē•ē•Šē•§ē•®š¤¾‚ć¼„š¤““ē–Žē‘ē–žē–“ē˜‚ē˜¬ē™‘ē™ē™Æē™¶š¦µēšč‡ÆćŸøš¦¤‘š¦¤Žēš”ēš„ēš·ē›Œš¦¾Ÿč‘¢š„‚š„…½š”øœēœžēœ¦ē€ę’Æš„ˆ ē˜š£Š¬ēžÆšØ„¤šØ„Øš”›ēŸ“ē ‰š”¶š¤Ø’ę£Šē¢Æē£‡ē£“éš„ē¤®š„— ē£—ē¤“ē¢±š§˜Œč¾øč¢„šØ¬«š¦‚ƒš¢˜œē¦†č¤€ę¤‚ē¦€š„”—ē¦š§¬¹ē¤¼ē¦©ęøŖš§„¦ćŗØē§†š©„ē§”\"]]"); + +/***/ }), + +/***/ 9040: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"0\",\"\\u0000\",127,\"ā‚¬\"],[\"8140\",\"äø‚äø„äø…äø†äøäø’äø—äøŸäø äø”äø£äø¦äø©äø®äøÆäø±äø³äøµäø·äø¼ä¹€ä¹ä¹‚乄乆乊乑乕乗乚乛乢乣乤乄乧ä¹Øä¹Ŗ\",5,\"乲乓\",9,\"ä¹æ\",6,\"äŗ‡äŗŠ\"],[\"8180\",\"äŗäŗ–äŗ—äŗ™äŗœäŗäŗžäŗ£äŗŖäŗÆäŗ°äŗ±äŗ“äŗ¶äŗ·äŗøäŗ¹äŗ¼äŗ½äŗ¾ä»ˆä»Œä»ä»ä»’仚仛仜仠仢仦仧仩仭仮ä»Æ仱仓ä»ø仹ä»ŗ仼仾伀伂\",6,\"伋伌伒\",4,\"伜伝伔伣ä¼Ø伩伬伭伮伱伳伵伷伹伻伾\",4,\"佄佅佇\",5,\"佒佔佖佔佢佦ä½Øä½Ŗ佫佭佮佱佲併佷ä½øä½¹ä½ŗ佽侀侁侂侅來侇侊侌侎侐侒侓侕侖侘侙侚侜侞侟侔侢\"],[\"8240\",\"侤侫侭侰\",4,\"侶\",8,\"äæ€äæäæ‚äæ†äæ‡äæˆäæ‰äæ‹äæŒäæäæ’\",4,\"äæ™äæ›äæ äæ¢äæ¤äæ„äæ§äæ«äæ¬äæ°äæ²äæ“äæµäæ¶äæ·äæ¹äæ»äæ¼äæ½äææ\",11],[\"8280\",\"個倎倐們倓倕倖倗倛倝倞倠倢倣値倧倫å€Æ\",10,\"倻倽å€æ偀偁偂偄偅偆偉偊偋偍偐\",4,\"偖偗偘偙偛偝\",7,\"偦\",5,\"偭\",8,\"åø偹åŗ偼偽傁傂傃傄傆傇傉傊傋傌傎\",20,\"傤傦å‚Ŗ傫傭\",4,\"傳\",6,\"傼\"],[\"8340\",\"傽\",17,\"僐\",5,\"僗僘僙僛\",10,\"åƒØ僩åƒŖ僫åƒÆ僰僱僲僓僶\",4,\"僼\",9,\"儈\"],[\"8380\",\"儉儊儌\",5,\"儓\",13,\"儢\",28,\"兂兇兊兌兎兏児兒兓兗兘兙兛兝\",4,\"兣兤兦內兩å…Ŗå…Æ兲å…ŗ兾å…æ冃冄円冇冊冋冎冏冐冑冓冔冘冚冝冞冟冔冣冦\",4,\"冭冮冓å†ø冹å†ŗ冾å†æ凁凂凃凅凈凊凍凎凐凒\",5],[\"8440\",\"凘凙凚凜凞凟凢凣凄\",5,\"凬凮凱凲凓凷凾刄刅刉刋刌刏刐刓刔刕刜刞刟刔刢刣刄刦刧åˆŖ刬åˆÆ刱刲刓刵刼刾剄\",5,\"剋剎剏剒剓剕剗剘\"],[\"8480\",\"剙剚剛剝剟剠剢剣剤剦å‰Ø剫剬剭剮剰剱剳\",9,\"剾劀劃\",4,\"劉\",6,\"劑劒劔\",6,\"劜劤劄劦劧劮åŠÆ劰劓\",9,\"勀勁勂勄勅勆勈勊勌勍勎勏勑勓勔動勗務\",5,\"勠勔勢勣勄\",10,\"勱\",7,\"勻勼勽匁匂匃匄匇匉匊匋匌匎\"],[\"8540\",\"匑匒匓匔匘匛匜匞匟匢匤匄匧åŒØ匩匫匬匭åŒÆ\",9,\"匼匽區卂卄卆卋卌卍卐協単卙卛卝卄åØåŖ卬卭卲卶卹卻卼卽卾厀厁厃厇厈厊厎厏\"],[\"8580\",\"厐\",4,\"厖厗厙厛厜厞厠厔厤厧åŽŖ厫厬厭åŽÆ\",6,\"厷åŽø厹åŽŗ厼厽厾叀參\",4,\"収叏叐叒叓叕叚叜叝叞叔叢叧叓åŗ叾åæ吀吂吅吇吋吔吘吙吚吜吢吤各åŖ吰吳吶吷åŗ吽åæ呁呂呄呅呇呉呌呍呎呏呑呚呝\",4,\"呣呄呧呩\",7,\"呓呹å‘ŗ呾å‘æ咁咃咅咇咈咉咊咍咑咓咗咘咜咞咟咠咔\"],[\"8640\",\"咢咄咮咰咲咵咶咷咹å’ŗ咼咾哃哅哊哋哖哘哛哠\",4,\"哫哬å“Æ哰哱哓\",5,\"哻哾唀唂唃唄唅唈唊\",4,\"唒唓唕\",5,\"唜唝唞唟唔唄唦\"],[\"8680\",\"å”Ø唩唫唭唲唓唵唶å”ø唹å”ŗ唻唽啀啂啅啇啈啋\",4,\"啑啒啓啔啗\",4,\"啝啞啟啠啢啣å•Ø啩啫å•Æ\",5,\"啹å•ŗ啽å•æ喅喆喌喍喎喐喒喓喕喖喗喚喛喞喠\",6,\"å–Ø\",8,\"喲喓営å–øå–ŗ喼å–æ\",4,\"嗆嗇嗈嗊嗋嗎嗏嗐嗕嗗\",4,\"嗞嗠嗢嗧嗩嗭嗮嗰嗱嗓嗶å—ø\",4,\"å—æ嘂嘃嘄嘅\"],[\"8740\",\"嘆嘇嘊嘋嘍嘐\",7,\"嘙嘚嘜嘝嘠嘔嘢嘄嘦å˜Ø嘩å˜Ŗ嘫嘮å˜Æ嘰嘳嘵嘷å˜øå˜ŗ嘼嘽嘾噀\",11,\"噏\",4,\"噕噖噚噛噝\",4],[\"8780\",\"噣噄噦噧噭噮å™Æ噰噲噳噓噵噷å™ø噹å™ŗ噽\",7,\"嚇\",6,\"嚐嚑嚒嚔\",14,\"嚤\",10,\"嚰\",6,\"åšø嚹åšŗ嚻嚽\",12,\"囋\",8,\"囕囖囘囙囜団囄\",5,\"囬囮å›Æ囲図囶囷å›ø囻囼圀圁圂圅圇國\",6],[\"8840\",\"園\",9,\"圝圞圠圔圢圤圄圦圧圫圱圲圓\",4,\"圼圽åœæ坁坃坄坅坆坈坉坋坒\",4,\"坘坙坢坣坄坧坬坮坰坱坲坓坵åø坹åŗ坽坾åæ垀\"],[\"8880\",\"垁垇垈垉垊垍\",4,\"垔\",6,\"垜垝垞垟垄åžØåžŖ垬åžÆ垰垱垳垵垶垷垹\",8,\"埄\",6,\"埌埍埐埑埓埖埗埛埜埞埔埢埣埄\",7,\"埮埰埱埲埳埵埶執埻埼埾åŸæ堁堃堄堅堈堉堊堌堎堏堐堒堓堔堖堗堘堚堛堜堝堟堢堣堄\",4,\"å «\",4,\"報堲堳堓堶\",7],[\"8940\",\"å ¾\",5,\"å”…\",6,\"唎唏唐唒唓唕唖唗唙\",4,\"唟\",5,\"唦\",4,\"å”­\",16,\"å”æ墂墄墆墇墈墊墋墌\"],[\"8980\",\"墍\",4,\"墔\",4,\"墛墜墝墠\",7,\"å¢Ŗ\",17,\"墽墾å¢æ壀壂壃壄壆\",10,\"壒壓壔壖\",13,\"壄\",5,\"壭å£Æ壱売壓壵壷å£øå£ŗ\",7,\"夃夅夆夈\",4,\"夎夐夑夒夓夗夘夛夝夞夠夔夢夣夦å¤Ø夬夰夲夳夵夶夻\"],[\"8a40\",\"夽夾å¤æ儀儃儅儆儊儌儍儐儒儓儙儛\",4,\"儔儣儤儦\",12,\"儵儷å„ŗ儻儼儾å„æ妀妅妉妋妌妎妏妐妑妔妕妘妚妛妜妝妟妠妔妢妦\"],[\"8a80\",\"妧妬妭妰妱妳\",5,\"å¦ŗ妼妽å¦æ\",6,\"姇姈姉姌姍姎姏姕姖姙姛姞\",4,\"姤姦姧姩å§Ŗ姫姭\",11,\"å§ŗ姼姽姾å؀å؂å؊å؋å؍å؎å؏åؐåؒåؔåؕåؖåؗåؙåؚå؛å؝å؞åØ”åØ¢åؤåئåاåØØåØŖ\",6,\"åسåصåØ·\",4,\"åؽåؾåØæ婁\",4,\"婇婈婋\",9,\"婖婗婘婙婛\",5],[\"8b40\",\"婔婣婤婄婦å©Øå©©å©«\",8,\"å©ø婹婻婼婽婾åŖ€\",17,\"åŖ“\",6,\"åŖœ\",13,\"åŖ«åŖ¬\"],[\"8b80\",\"åŖ­\",4,\"åŖ“åŖ¶åŖ·åŖ¹\",4,\"åŖæ嫀嫃\",5,\"嫊嫋嫍\",4,\"嫓嫕嫗嫙嫚嫛嫝嫞嫟嫢嫤嫄嫧å«Øå«Ŗ嫬\",4,\"嫲\",22,\"嬊\",11,\"嬘\",25,\"嬳嬵嬶å¬ø\",7,\"孁\",6],[\"8c40\",\"孈\",7,\"孒孖孞孠孔孧å­Øå­«å­­å­®å­Æ孲孓孶孷å­ø孹孻孼孾å­æ宂宆宊宍宎宐宑宒宔宖実宧å®Ø宩宬宭宮å®Æ宱宲宷å®ŗ宻宼åƀåƁåƃåƈåƉåƊåƋåƍåƎåƏ\"],[\"8c80\",\"åƑåƔ\",8,\"åÆ åÆ¢åÆ£åƦåƧåÆ©\",4,\"åÆÆåƱ\",6,\"åƽåƾ尀専尃尅將專尋尌對導尐尒尓尗尙尛尞尟尠尔尣尦å°Øå°©å°Ŗå°«å°­å°®å°Æ尰尲尳尵尶尷屃屄屆屇屌屍屒屓屔屖屗屘屚屛屜屝屟屢層屧\",6,\"å±°å±²\",6,\"屻屼屽屾岀岃\",4,\"岉岊岋岎岏岒岓岕岝\",4,\"岤\",4],[\"8d40\",\"å²Ŗå²®å²Æ岰岲岓岶岹å²ŗ岻岼岾峀峂峃峅\",5,\"峌\",5,\"峓\",5,\"峚\",6,\"峢峣峧峩峫峬峮å³Æå³±\",9,\"å³¼\",4],[\"8d80\",\"品哄哅哈\",5,\"哏\",4,\"哕哗哘哙哚哜哝哟\",4,\"å“„å“Øå“Ŗ哫哬å“Æ\",4,\"哵\",7,\"å“æ\",7,\"嵈嵉嵍\",10,\"嵙嵚嵜嵞\",10,\"åµŖ嵭嵮嵰嵱嵲嵳嵵\",12,\"嶃\",21,\"嶚嶛嶜嶞嶟嶠\"],[\"8e40\",\"嶔\",21,\"å¶ø\",12,\"巆\",6,\"巎\",12,\"巜巟巠巣巤å·Ŗ巬巭\"],[\"8e80\",\"巰巵巶å·ø\",4,\"å·æåø€åø„åø‡åø‰åøŠåø‹åøåøŽåø’åø“åø—åøž\",7,\"åøØ\",4,\"åøÆåø°åø²\",4,\"åø¹åøŗåø¾åøæ幀幁幃幆\",5,\"幍\",6,\"幖\",4,\"幜幝幟幠幣\",14,\"幵幷幹幾åŗåŗ‚åŗƒåŗ…åŗˆåŗ‰åŗŒåŗåŗŽåŗ’åŗ˜åŗ›åŗåŗ”åŗ¢åŗ£åŗ¤åŗØ\",4,\"åŗ®\",4,\"åŗ“åŗŗåŗ»åŗ¼åŗ½åŗæ\",6],[\"8f40\",\"廆廇廈廋\",5,\"廔廕廗廘廙廚廜\",11,\"廩廫\",8,\"廵å»ø廹廻廼廽弅弆弇弉弌弍弎弐弒弔弖弙弚弜弝弞弔弢弣弤\"],[\"8f80\",\"å¼Ø弫弬弮弰弲\",6,\"弻弽弾å¼æ彁\",14,\"彑彔彙彚彛彜彞彟彠彣彄彧å½Ø彫彮å½Æ彲当彵彶å½øå½ŗ彽彾å½æ徃徆徍徎徏徑従徔徖徚徛徝從徟徠徢\",5,\"復徫徬å¾Æ\",5,\"徶å¾øå¾¹å¾ŗ徻徾\",4,\"åæ‡åæˆåæŠåæ‹åæŽåæ“åæ”åæ•åæšåæ›åæœåæžåæŸåæ¢åæ£åæ„åæ¦åæØåæ©åæ¬åæÆåæ°åæ²åæ³åæ“åæ¶åæ·åæ¹åæŗåæ¼ę€‡\"],[\"9040\",\"ę€ˆę€‰ę€‹ę€Œę€ę€‘ę€“ę€—ę€˜ę€šę€žę€Ÿę€¢ę€£ę€¤ę€¬ę€­ę€®ę€°\",4,\"ꀶ\",4,\"ę€½ę€¾ę€ę„\",6,\"ęŒęŽęę‘ę“ę”ę–ę—ę˜ę›ęœęžęŸę ę”ę„ę¦ę®ę±ę²ę“ęµę·ę¾ę‚€\"],[\"9080\",\"ę‚ę‚‚ę‚…ę‚†ę‚‡ę‚ˆę‚Šę‚‹ę‚Žę‚ę‚ę‚‘ę‚“ę‚•ę‚—ę‚˜ę‚™ę‚œę‚žę‚”ę‚¢ę‚¤ę‚„ę‚§ę‚©ę‚Ŗę‚®ę‚°ę‚³ę‚µę‚¶ę‚·ę‚¹ę‚ŗę‚½\",7,\"ꃇꃈꃉꃌ\",4,\"ęƒ’ęƒ“ęƒ”ęƒ–ęƒ—ęƒ™ęƒ›ęƒžęƒ”\",4,\"ęƒŖęƒ±ęƒ²ęƒµęƒ·ęƒøꃻ\",4,\"ꄂꄃꄄꄅꄇꄊꄋꄌꄐ\",4,\"ę„–ę„—ę„˜ę„™ę„›ę„œę„ę„žę„”ę„¢ę„„ę„Øę„©ę„Ŗꄬ\",18,\"ꅀ\",6],[\"9140\",\"ꅇꅉꅋꅍꅏꅐꅒꅓꅔꅖ\",6,\"ę…žę…Ÿę… ę…”ę…£ę…¤ę…„ę…¦ę…©\",6,\"ę…±ę…²ę…³ę…“ę…¶ę…ø\",18,\"ꆌꆍꆏ\",4,\"ꆕ\"],[\"9180\",\"ꆖ\",6,\"ꆞ\",8,\"ę†Ŗꆫꆭ\",9,\"ę†ø\",5,\"ę†æꇀꇁꇃ\",4,\"ꇉꇌ\",4,\"ꇓꇕ\",16,\"ꇧ\",13,\"ꇶ\",8,\"ꈀ\",5,\"ęˆ‡ęˆ‰ęˆ“ęˆ”ęˆ™ęˆœęˆęˆžęˆ ęˆ£ęˆ¦ęˆ§ęˆØꈩꈫꈭęˆÆęˆ°ęˆ±ęˆ²ęˆµęˆ¶ęˆø\",4,\"ꉂꉄꉅꉆꉊ\"],[\"9240\",\"ꉏꉐꉕꉖꉗꉙꉚꉜ\",6,\"ꉤꉄę‰Øę‰±ę‰²ę‰“ę‰µę‰·ę‰øę‰ŗę‰»ę‰½ęŠęŠ‚ęŠƒęŠ…ęŠ†ęŠ‡ęŠˆęŠ‹\",5,\"ęŠ”ęŠ™ęŠœęŠęŠžęŠ£ęŠ¦ęŠ§ęŠ©ęŠŖꊭꊮęŠÆęŠ°ęŠ²ęŠ³ęŠ“ęŠ¶ęŠ·ęŠøęŠŗęŠ¾ę‹€ę‹\"],[\"9280\",\"ę‹ƒę‹‹ę‹ę‹‘ę‹•ę‹ę‹žę‹ ę‹”ę‹¤ę‹Ŗę‹«ę‹°ę‹²ę‹µę‹øę‹¹ę‹ŗę‹»ęŒ€ęŒƒęŒ„ęŒ…ęŒ†ęŒŠęŒ‹ęŒŒęŒęŒęŒęŒ’ęŒ“ęŒ”ęŒ•ęŒ—ęŒ˜ęŒ™ęŒœęŒ¦ęŒ§ęŒ©ęŒ¬ęŒ­ęŒ®ęŒ°ęŒ±ęŒ³\",5,\"ęŒ»ęŒ¼ęŒ¾ęŒæꍀꍁꍄꍇꍈꍊꍑꍒꍓꍔꍖ\",7,\"ę ę¤ę„ę¦ęØęŖę«ę¬ęÆę°ę²ę³ę“ęµęøę¹ę¼ę½ę¾ęæꎁꎃꎄꎅꎆꎋꎍꎑꎓꎔꎕꎗꎙ\",6,\"ꎔꎤꎦꎫęŽÆęŽ±ęŽ²ęŽµęŽ¶ęŽ¹ęŽ»ęŽ½ęŽæꏀ\"],[\"9340\",\"ꏁꏂꏃꏅꏇꏈꏊꏋꏌꏑꏓꏔꏕꏗ\",6,\"ęŸę¢ę¤\",4,\"ę«ę¬ę®ęÆę°ę±ę³ęµę·ę¹ęŗę»ę¼ę¾ęƒę„ę†\",4,\"ꐍꐎꐑꐒꐕ\",5,\"ęęŸę¢ę£ę¤\"],[\"9380\",\"ꐄꐧęØꐩꐫꐮ\",5,\"ꐵ\",4,\"ę»ę¼ę¾ę‘€ę‘‚ę‘ƒę‘‰ę‘‹\",6,\"ꑓꑕꑖꑗꑙ\",4,\"ꑟ\",7,\"ę‘Øę‘Ŗꑫꑬꑮ\",9,\"ę‘»\",6,\"ꒃꒆꒈ\",8,\"꒓꒔꒗꒘꒚꒛꒜꒝꒟\",4,\"ꒄ꒦꒧ę’Øę’Ŗę’«ę’Æę’±ę’²ę’³ę’“ę’¶ę’¹ę’»ę’½ę’¾ę’æ꓁꓃꓄꓆\",6,\"꓏ꓑꓓꓔꓕꓖꓙꓚ\"],[\"9440\",\"ę“›ę“œę“ę“Ÿę“ ę“”ę“£ę“„ę“§\",24,\"ꔁ\",7,\"ꔊ\",7,\"ꔓ\",4,\"ꔙ\",8],[\"9480\",\"ę”¢ę”£ę”¤ę”¦\",4,\"ę”¬ę”­ę”°ę”±ę”²ę”³ę”·ę”ŗę”¼ę”½ę•€\",4,\"ę•†ę•‡ę•Šę•‹ę•ę•Žę•ę•’ę•“ę•”ę•—ę•˜ę•šę•œę•Ÿę• ę•”ę•¤ę•„ę•§ę•Øę•©ę•Ŗę•­ę•®ę•Æę•±ę•³ę•µę•¶ę•ø\",14,\"ę–ˆę–‰ę–Šę–ę–Žę–ę–’ę–”ę–•ę––ę–˜ę–šę–ę–žę– ę–¢ę–£ę–¦ę–Øę–Ŗꖬꖮꖱ\",7,\"ę–ŗę–»ę–¾ę–æꗀꗂꗇꗈꗉꗊꗍꗐꗑꗓꗔꗕꗘ\",7,\"ę—”ę—£ę—¤ę—Ŗę—«\"],[\"9540\",\"ę—²ę—³ę—“ę—µę—øę—¹ę—»\",4,\"ę˜ę˜„ę˜…ę˜‡ę˜ˆę˜‰ę˜‹ę˜ę˜ę˜‘ę˜’ę˜–ę˜—ę˜˜ę˜šę˜›ę˜œę˜žę˜”ę˜¢ę˜£ę˜¤ę˜¦ę˜©ę˜Ŗę˜«ę˜¬ę˜®ę˜°ę˜²ę˜³ę˜·\",4,\"ę˜½ę˜æꙀꙂꙄ\",6,\"ꙍꙎꙐꙑꙘ\"],[\"9580\",\"ę™™ę™›ę™œę™ę™žę™ ę™¢ę™£ę™„ę™§ę™©\",4,\"ę™±ę™²ę™³ę™µę™øę™¹ę™»ę™¼ę™½ę™æꚀꚁꚃꚅꚆꚈꚉꚊꚋꚍꚎꚏꚐꚒꚓꚔꚕꚘ\",4,\"ꚞ\",8,\"ęš©\",4,\"ęšÆ\",4,\"ꚵꚶꚷęšøęšŗęš»ęš¼ęš½ęšæ\",25,\"ꛚꛞ\",7,\"ꛧę›Øę›Ŗ\",5,\"꛱꛵꛶ę›øę›ŗę›»ę›½ęœęœ‚ęœƒ\"],[\"9640\",\"꜄꜅꜆꜇꜌꜎꜏꜑꜒꜓꜖ꜘꜙꜚꜜꜞ꜠\",5,\"ęœ§ęœ©ęœ®ęœ°ęœ²ęœ³ęœ¶ęœ·ęœøęœ¹ęœ»ęœ¼ęœ¾ęœæꝁꝄꝅꝇꝊꝋꝍꝒꝔꝕꝗ\",4,\"ęę¢ę£ę¤ę¦ę§ę«ę¬ę®ę±ę“ę¶\"],[\"9680\",\"ęøę¹ęŗę»ę½ęž€ęž‚ęžƒęž…ęž†ęžˆęžŠęžŒęžęžŽęžęž‘ęž’ęž“ęž”ęž–ęž™ęž›ęžŸęž ęž”ęž¤ęž¦ęž©ęž¬ęž®ęž±ęž²ęž“ęž¹\",7,\"ꟂꟅ\",9,\"ęŸ•ęŸ–ęŸ—ęŸ›ęŸŸęŸ”ęŸ£ęŸ¤ęŸ¦ęŸ§ęŸØęŸŖęŸ«ęŸ­ęŸ®ęŸ²ęŸµ\",7,\"ęŸ¾ę ę ‚ę ƒę „ę †ę ę ę ’ę ”ę •ę ˜\",4,\"ę žę Ÿę  ę ¢\",6,\"ę «\",6,\"ꠓ꠵꠶ę ŗę »ę æę”‡ę”‹ę”ę”ę”’ę”–\",5],[\"9740\",\"ę”œę”ę”žę”Ÿę”Ŗꔬ\",7,\"ꔵę”ø\",8,\"ę¢‚ę¢„ę¢‡\",7,\"ę¢ę¢‘ę¢’ę¢”ę¢•ę¢–ę¢˜\",9,\"ę¢£ę¢¤ę¢„ę¢©ę¢Ŗę¢«ę¢¬ę¢®ę¢±ę¢²ę¢“ę¢¶ę¢·ę¢ø\"],[\"9780\",\"ę¢¹\",6,\"ę£ę£ƒ\",5,\"ę£Šę£Œę£Žę£ę£ę£‘ę£“ę£”ę£–ę£—ę£™ę£›\",4,\"ę£”ę£¢ę£¤\",9,\"ę£Æę£²ę£³ę£“ę£¶ę£·ę£øę£»ę£½ę£¾ę£æ꤀꤂꤃꤄꤆\",4,\"ꤌꤏꤑꤓ\",11,\"ę¤”ę¤¢ę¤£ę¤„\",7,\"꤮ę¤Æę¤±ę¤²ę¤³ę¤µę¤¶ę¤·ę¤øę¤ŗę¤»ę¤¼ę¤¾ę„€ę„ę„ƒ\",16,\"ę„•ę„–ę„˜ę„™ę„›ę„œę„Ÿ\"],[\"9840\",\"ę„”ę„¢ę„¤ę„„ę„§ę„Øę„©ę„Ŗꄬꄭę„Æę„°ę„²\",4,\"ę„ŗę„»ę„½ę„¾ę„æę¦ę¦ƒę¦…ę¦Šę¦‹ę¦Œę¦Ž\",5,\"ę¦–ę¦—ę¦™ę¦šę¦\",9,\"ꦩę¦Ŗꦬꦮę¦Æę¦°ę¦²ę¦³ę¦µę¦¶ę¦øę¦¹ę¦ŗę¦¼ę¦½\"],[\"9880\",\"ę¦¾ę¦æ꧀꧂\",7,\"꧋꧍ꧏ꧑꧒꧓꧕\",5,\"ę§œę§ę§žę§”\",11,\"ꧮę§Æę§°ę§±ę§³\",9,\"ę§¾ę؀\",9,\"ę؋\",11,\"ęؙ\",5,\"ęØ ęØ¢\",5,\"ęØ©ęØ«ęجęØ­ęØ®ęØ°ęزęسęØ“ęض\",6,\"ęØæ\",4,\"ę©…ę©†ę©ˆ\",7,\"ę©‘\",6,\"ę©š\"],[\"9940\",\"ę©œ\",4,\"ę©¢ę©£ę©¤ę©¦\",10,\"ę©²\",6,\"ę©ŗę©»ę©½ę©¾ę©æęŖęŖ‚ęŖƒęŖ…\",8,\"ęŖęŖ’\",4,\"ęŖ˜\",7,\"ęŖ”\",5],[\"9980\",\"ęŖ§ęŖØęŖŖęŖ­\",114,\"ꬄꬦę¬Ø\",6],[\"9a40\",\"ę¬Æę¬°ę¬±ę¬³ę¬“ę¬µę¬¶ę¬øę¬»ę¬¼ę¬½ę¬æꭀꭁꭂꭄꭅꭈꭊꭋꭍ\",11,\"ꭚ\",7,\"ę­Øę­©ę­«\",13,\"ę­ŗę­½ę­¾ę­æę®€ę®…ę®ˆ\"],[\"9a80\",\"ę®Œę®Žę®ę®ę®‘ę®”ę®•ę®—ę®˜ę®™ę®œ\",4,\"ę®¢\",7,\"ꮫ\",7,\"ꮶę®ø\",6,\"ęƀęƃęƄęƆ\",4,\"ęƌęƎęƐęƑęƘęƚęƜ\",4,\"ęÆ¢\",7,\"ęƬęÆ­ęÆ®ęÆ°ęƱęƲęÆ“ęƶęÆ·ęÆøęÆŗęÆ»ęƼęƾ\",6,\"갈\",4,\"ę°Žę°’ę°—ę°œę°ę°žę° ę°£ę°„ę°«ę°¬ę°­ę°±ę°³ę°¶ę°·ę°¹ę°ŗę°»ę°¼ę°¾ę°æę±ƒę±„ę±…ę±ˆę±‹\",4,\"ę±‘ę±’ę±“ę±–ę±˜\"],[\"9b40\",\"ę±™ę±šę±¢ę±£ę±„ę±¦ę±§ę±«\",4,\"ę±±ę±³ę±µę±·ę±øę±ŗę±»ę±¼ę±æę²€ę²„ę²‡ę²Šę²‹ę²ę²Žę²‘ę²’ę²•ę²–ę²—ę²˜ę²šę²œę²ę²žę² ę²¢ę²Øę²¬ę²Æę²°ę²“ę²µę²¶ę²·ę²ŗę³€ę³ę³‚ę³ƒę³†ę³‡ę³ˆę³‹ę³ę³Žę³ę³‘ę³’ę³˜\"],[\"9b80\",\"ę³™ę³šę³œę³ę³Ÿę³¤ę³¦ę³§ę³©ę³¬ę³­ę³²ę³“ę³¹ę³æę“€ę“‚ę“ƒę“…ę“†ę“ˆę“‰ę“Šę“ę“ę“ę“‘ę““ę“”ę“•ę“–ę“˜ę“œę“ę“Ÿ\",5,\"ꓦę“Øꓩꓬꓭę“Æꓰꓓꓶꓷę“øę“ŗę“æęµ€ęµ‚ęµ„ęµ‰ęµŒęµęµ•ęµ–ęµ—ęµ˜ęµ›ęµęµŸęµ”ęµ¢ęµ¤ęµ„ęµ§ęµØęµ«ęµ¬ęµ­ęµ°ęµ±ęµ²ęµ³ęµµęµ¶ęµ¹ęµŗęµ»ęµ½\",4,\"ę¶ƒę¶„ę¶†ę¶‡ę¶Šę¶‹ę¶ę¶ę¶ę¶’ę¶–\",4,\"ę¶œę¶¢ę¶„ę¶¬ę¶­ę¶°ę¶±ę¶³ę¶“ę¶¶ę¶·ę¶¹\",5,\"ę·ę·‚ę·ƒę·ˆę·‰ę·Š\"],[\"9c40\",\"ę·ę·Žę·ę·ę·’ę·“ę·”ę·•ę·—ę·šę·›ę·œę·Ÿę·¢ę·£ę·„ę·§ę·Øę·©ę·Ŗę·­ę·Æę·°ę·²ę·“ę·µę·¶ę·øę·ŗę·½\",7,\"ęø†ęø‡ęøˆęø‰ęø‹ęøęø’ęø“ęø•ęø˜ęø™ęø›ęøœęøžęøŸęø¢ęø¦ęø§ęøØęøŖęø¬ęø®ęø°ęø±ęø³ęøµ\"],[\"9c80\",\"ęø¶ęø·ęø¹ęø»\",7,\"ę¹…\",7,\"ę¹ę¹ę¹‘ę¹’ę¹•ę¹—ę¹™ę¹šę¹œę¹ę¹žę¹ \",10,\"ę¹¬ę¹­ę¹Æ\",14,\"ęŗ€ęŗęŗ‚ęŗ„ęŗ‡ęŗˆęŗŠ\",4,\"ęŗ‘\",6,\"ęŗ™ęŗšęŗ›ęŗęŗžęŗ ęŗ”ęŗ£ęŗ¤ęŗ¦ęŗØęŗ©ęŗ«ęŗ¬ęŗ­ęŗ®ęŗ°ęŗ³ęŗµęŗøęŗ¹ęŗ¼ęŗ¾ęŗæę»€ę»ƒę»„ę»…ę»†ę»ˆę»‰ę»Šę»Œę»ę»Žę»ę»’ę»–ę»˜ę»™ę»›ę»œę»ę»£ę»§ę»Ŗ\",5],[\"9d40\",\"ę»°ę»±ę»²ę»³ę»µę»¶ę»·ę»øę»ŗ\",7,\"ę¼ƒę¼„ę¼…ę¼‡ę¼ˆę¼Š\",4,\"ę¼ę¼‘ę¼’ę¼–\",9,\"ę¼”ę¼¢ę¼£ę¼„ę¼¦ę¼§ę¼Øę¼¬ę¼®ę¼°ę¼²ę¼“ę¼µę¼·\",6,\"ę¼æę½€ę½ę½‚\"],[\"9d80\",\"ę½ƒę½„ę½…ę½ˆę½‰ę½Šę½Œę½Ž\",9,\"ę½™ę½šę½›ę½ę½Ÿę½ ę½”ę½£ę½¤ę½„ę½§\",5,\"ę½Æę½°ę½±ę½³ę½µę½¶ę½·ę½¹ę½»ę½½\",6,\"ę¾…ę¾†ę¾‡ę¾Šę¾‹ę¾\",12,\"ę¾ę¾žę¾Ÿę¾ ę¾¢\",4,\"ę¾Ø\",10,\"ę¾“ę¾µę¾·ę¾øę¾ŗ\",5,\"ęæęæƒ\",5,\"ęæŠ\",6,\"ęæ“\",10,\"ęæŸęæ¢ęæ£ęæ¤ęæ„\"],[\"9e40\",\"ęæ¦\",7,\"ęæ°\",32,\"ē€’\",7,\"ē€œ\",6,\"ē€¤\",6],[\"9e80\",\"ē€«\",9,\"ē€¶ē€·ē€øē€ŗ\",17,\"ēēŽē\",13,\"ēŸ\",11,\"ē®ē±ē²ē³ē“ē·ē¹ēŗē»ē½ē‚ē‚‚ē‚ƒē‚„ē‚†ē‚‡ē‚ˆē‚‹ē‚Œē‚ē‚ē‚ē‚‘ē‚“ē‚—ē‚˜ē‚šē‚›ē‚ž\",12,\"ē‚°ē‚²ē‚“ē‚µē‚¶ē‚ŗē‚¾ē‚æēƒ„ēƒ…ēƒ†ēƒ‡ēƒ‰ēƒ‹\",12,\"ēƒš\"],[\"9f40\",\"ēƒœēƒēƒžēƒ ēƒ”ēƒ¢ēƒ£ēƒ„ēƒŖēƒ®ēƒ°\",6,\"ēƒøēƒŗēƒ»ēƒ¼ēƒ¾\",10,\"ē„‹\",4,\"ē„‘ē„’ē„”ē„—ē„›\",10,\"ē„§\",7,\"ē„²ē„³ē„“\"],[\"9f80\",\"ē„µē„·\",13,\"ē…†ē…‡ē…ˆē…‰ē…‹ē…ē…\",12,\"ē…ē…Ÿ\",4,\"ē…„ē…©\",4,\"ē…Æē…°ē…±ē…“ē…µē…¶ē…·ē…¹ē…»ē…¼ē…¾\",5,\"ē†…\",4,\"ē†‹ē†Œē†ē†Žē†ē†‘ē†’ē†“ē†•ē†–ē†—ē†š\",4,\"ē†”\",6,\"ē†©ē†Ŗē†«ē†­\",5,\"ē†“ē†¶ē†·ē†øē†ŗ\",8,\"ē‡„\",9,\"ē‡\",4],[\"a040\",\"ē‡–\",9,\"ē‡”ē‡¢ē‡£ē‡¤ē‡¦ē‡Ø\",5,\"ē‡Æ\",9,\"ē‡ŗ\",11,\"ēˆ‡\",19],[\"a080\",\"ēˆ›ēˆœēˆž\",9,\"ēˆ©ēˆ«ēˆ­ēˆ®ēˆÆēˆ²ēˆ³ēˆ“ēˆŗēˆ¼ēˆ¾ē‰€\",6,\"ē‰‰ē‰Šē‰‹ē‰Žē‰ē‰ē‰‘ē‰“ē‰”ē‰•ē‰—ē‰˜ē‰šē‰œē‰žē‰ ē‰£ē‰¤ē‰„ē‰Øē‰Ŗē‰«ē‰¬ē‰­ē‰°ē‰±ē‰³ē‰“ē‰¶ē‰·ē‰øē‰»ē‰¼ē‰½ēŠ‚ēŠƒēŠ…\",4,\"ēŠŒēŠŽēŠēŠ‘ēŠ“\",11,\"ēŠ \",11,\"ēŠ®ēŠ±ēŠ²ēŠ³ēŠµēŠŗ\",6,\"ē‹…ē‹†ē‹‡ē‹‰ē‹Šē‹‹ē‹Œē‹ē‹‘ē‹“ē‹”ē‹•ē‹–ē‹˜ē‹šē‹›\"],[\"a1a1\",\"怀态怂Ā·Ė‰Ė‡ĀØ怃怅ā€”ļ½žā€–ā€¦ā€˜ā€™ā€œā€ć€”ć€•ć€ˆ\",7,\"怖怗怐怑Ā±Ć—Ć·āˆ¶āˆ§āˆØāˆ‘āˆāˆŖāˆ©āˆˆāˆ·āˆšāŠ„āˆ„āˆ āŒ’āŠ™āˆ«āˆ®ā‰”ā‰Œā‰ˆāˆ½āˆā‰ ā‰®ā‰Æā‰¤ā‰„āˆžāˆµāˆ“ā™‚ā™€Ā°ā€²ā€³ā„ƒļ¼„Ā¤ļæ ļæ”ā€°Ā§ā„–ā˜†ā˜…ā—‹ā—ā—Žā—‡ā—†ā–”ā– ā–³ā–²ā€»ā†’ā†ā†‘ā†“怓\"],[\"a2a1\",\"ā…°\",9],[\"a2b1\",\"ā’ˆ\",19,\"ā‘“\",19,\"ā‘ \",9],[\"a2e5\",\"戠\",9],[\"a2f1\",\"ā… \",11],[\"a3a1\",\"ļ¼ļ¼‚ļ¼ƒļæ„ļ¼…\",88,\"ļæ£\"],[\"a4a1\",\"恁\",82],[\"a5a1\",\"ć‚”\",85],[\"a6a1\",\"Ī‘\",16,\"Ī£\",6],[\"a6c1\",\"Ī±\",16,\"Ļƒ\",6],[\"a6e0\",\"ļøµļø¶ļø¹ļøŗļøæļ¹€ļø½ļø¾ļ¹ļ¹‚ļ¹ƒļ¹„\"],[\"a6ee\",\"ļø»ļø¼ļø·ļøøļø±\"],[\"a6f4\",\"ļø³ļø“\"],[\"a7a1\",\"Š\",5,\"ŠŠ–\",25],[\"a7d1\",\"Š°\",5,\"ёŠ¶\",25],[\"a840\",\"ĖŠĖ‹Ė™ā€“ā€•ā€„ā€µā„…ā„‰ā†–ā†—ā†˜ā†™āˆ•āˆŸāˆ£ā‰’ā‰¦ā‰§āŠæā•\",35,\"ā–\",6],[\"a880\",\"ā–ˆ\",7,\"ā–“ā–”ā–•ā–¼ā–½ā—¢ā—£ā—¤ā—„ā˜‰āŠ•ć€’ć€ć€ž\"],[\"a8a1\",\"āƔĒŽĆ Ä“Ć©Ä›ĆØÄ«Ć­ĒĆ¬ÅĆ³Ē’Ć²Å«ĆŗĒ”Ć¹Ē–Ē˜ĒšĒœĆ¼ĆŖɑ\"],[\"a8bd\",\"ńň\"],[\"a8c0\",\"É”\"],[\"a8c5\",\"愅\",36],[\"a940\",\"怔\",8,\"ćŠ£ćŽŽćŽćŽœćŽćŽžćŽ”ć„ćŽć‘ć’ć•ļø°ļæ¢ļæ¤\"],[\"a959\",\"ā„”戱\"],[\"a95c\",\"ā€\"],[\"a960\",\"ćƒ¼ć‚›ć‚œćƒ½ćƒ¾ć€†ć‚ć‚žļ¹‰\",9,\"ļ¹”ļ¹•ļ¹–ļ¹—ļ¹™\",8],[\"a980\",\"ļ¹¢\",4,\"ļ¹Øļ¹©ļ¹Ŗļ¹«\"],[\"a996\",\"怇\"],[\"a9a4\",\"ā”€\",75],[\"aa40\",\"ē‹œē‹ē‹Ÿē‹¢\",5,\"ē‹Ŗē‹«ē‹µē‹¶ē‹¹ē‹½ē‹¾ē‹æēŒ€ēŒ‚ēŒ„\",5,\"ēŒ‹ēŒŒēŒēŒēŒēŒ‘ēŒ’ēŒ”ēŒ˜ēŒ™ēŒšēŒŸēŒ ēŒ£ēŒ¤ēŒ¦ēŒ§ēŒØēŒ­ēŒÆēŒ°ēŒ²ēŒ³ēŒµēŒ¶ēŒŗēŒ»ēŒ¼ēŒ½ē€\",8],[\"aa80\",\"ē‰ēŠē‹ēŒēŽēē‘ē“ē”ē•ē–ē˜\",7,\"ē”\",10,\"ē®ē°ē±\"],[\"ab40\",\"ē²\",11,\"ēæ\",4,\"ēŽ…ēŽ†ēŽˆēŽŠēŽŒēŽēŽēŽēŽ’ēŽ“ēŽ”ēŽ•ēŽ—ēŽ˜ēŽ™ēŽšēŽœēŽēŽžēŽ ēŽ”ēŽ£\",5,\"ēŽŖēŽ¬ēŽ­ēŽ±ēŽ“ēŽµēŽ¶ēŽøēŽ¹ēŽ¼ēŽ½ēŽ¾ēŽæēēƒ\",4],[\"ab80\",\"ē‹ēŒēŽē’\",6,\"ēšē›ēœēēŸē”ē¢ē£ē¤ē¦ēØēŖē«ē¬ē®ēÆē°ē±ē³\",4],[\"ac40\",\"ēø\",10,\"ē„ē‡ēˆē‹ēŒēēŽē‘\",8,\"ēœ\",5,\"ē£ē¤ē§ē©ē«ē­ēÆē±ē²ē·\",4,\"ē½ē¾ēæē‘€ē‘‚\",11],[\"ac80\",\"ē‘Ž\",6,\"ē‘–ē‘˜ē‘ē‘ \",12,\"ē‘®ē‘Æē‘±\",4,\"ē‘øē‘¹ē‘ŗ\"],[\"ad40\",\"ē‘»ē‘¼ē‘½ē‘æē’‚ē’„ē’…ē’†ē’ˆē’‰ē’Šē’Œē’ē’ē’‘\",10,\"ē’ē’Ÿ\",7,\"ē’Ŗ\",15,\"ē’»\",12],[\"ad80\",\"ē“ˆ\",9,\"ē““\",8,\"ē“ē“Ÿē“”ē“„ē“§\",6,\"ē“°ē“±ē“²\"],[\"ae40\",\"ē“³ē“µē“ø\",6,\"ē”€ē”ē”‚ē”ƒē”…\",7,\"ē”Žē”ē”’ē””ē”•ē”–ē”—ē”›ē”ē”žē” \",4,\"ē”¦ē”§ē”Ŗē”®ē”“ē”¶ē”¹ē”¼ē”½ē”æē•ē•‚ē•ƒē•„ē•†ē•‡ē•‰ē•Šē•ē•ē•‘ē•’ē•“ē••ē•–ē•—ē•˜\"],[\"ae80\",\"ē•\",7,\"ē•§ē•Øē•©ē•«\",6,\"ē•³ē•µē•¶ē•·ē•ŗ\",4,\"ē–€ē–ē–‚ē–„ē–…ē–‡\"],[\"af40\",\"ē–ˆē–‰ē–Šē–Œē–ē–Žē–ē–“ē–•ē–˜ē–›ē–œē–žē–¢ē–¦\",4,\"ē–­ē–¶ē–·ē–ŗē–»ē–æē—€ē—ē—†ē—‹ē—Œē—Žē—ē—ē—‘ē—“ē——ē—™ē—šē—œē—ē—Ÿē— ē—”ē—„ē—©ē—¬ē—­ē—®ē—Æē—²ē—³ē—µē—¶ē—·ē—øē—ŗē—»ē—½ē—¾ē˜‚ē˜„ē˜†ē˜‡\"],[\"af80\",\"ē˜ˆē˜‰ē˜‹ē˜ē˜Žē˜ē˜‘ē˜’ē˜“ē˜”ē˜–ē˜šē˜œē˜ē˜žē˜”ē˜£ē˜§ē˜Øē˜¬ē˜®ē˜Æē˜±ē˜²ē˜¶ē˜·ē˜¹ē˜ŗē˜»ē˜½ē™ē™‚ē™„\"],[\"b040\",\"ē™…\",6,\"ē™Ž\",5,\"ē™•ē™—\",4,\"ē™ē™Ÿē™ ē™”ē™¢ē™¤\",6,\"ē™¬ē™­ē™®ē™°\",7,\"ē™¹ē™ŗē™¼ē™æēš€ēšēšƒēš…ēš‰ēšŠēšŒēšēšēšēš’ēš”ēš•ēš—ēš˜ēššēš›\"],[\"b080\",\"ēšœ\",7,\"ēš„\",8,\"ēšÆēš°ēš³ēšµ\",9,\"ē›€ē›ē›ƒå•Šé˜æ埃ęŒØ哎唉哀ēš‘ē™Œč”¼ēŸ®č‰¾ē¢ēˆ±éš˜éžę°Ø安äæŗꌉꚗå²øčƒŗę”ˆč‚®ę˜‚ē›Žå‡¹ę•–ē†¬ēæ±č¢„å‚²å„„ę‡Šę¾³čŠ­ęŒę‰’å­å§ē¬†å…«ē–¤å·“ę‹”č·‹é¶ęŠŠč€™åéœøē½¢ēˆøē™½ęŸē™¾ę‘†ä½°č“„ꋜēØ—ę–‘ē­ę¬ę‰³čˆ¬é¢ęæē‰ˆę‰®ę‹Œä¼“ē“£åŠåŠžē»Šé‚¦åø®ę¢†ę¦œč†€ē»‘ę£’ē£…čšŒé•‘å‚č°¤č‹žčƒžåŒ…č¤’å‰„\"],[\"b140\",\"ē›„ē›‡ē›‰ē›‹ē›Œē›“ē›•ē›™ē›šē›œē›ē›žē› \",4,\"ē›¦\",7,\"ē›°ē›³ē›µē›¶ē›·ē›ŗē›»ē›½ē›æēœ€ēœ‚ēœƒēœ…ēœ†ēœŠēœŒēœŽ\",10,\"ēœ›ēœœēœēœžēœ”ēœ£ēœ¤ēœ„ēœ§ēœŖēœ«\"],[\"b180\",\"ēœ¬ēœ®ēœ°\",4,\"ēœ¹ēœ»ēœ½ēœ¾ēœæē‚ē„ē…ē†ēˆ\",7,\"ē’\",7,\"ēœč–„雹äæå ”é„±å®ęŠ±ęŠ„ęš“č±¹é²ēˆ†ęÆē¢‘ę‚²å‘åŒ—č¾ˆčƒŒč“é’”倍ē‹ˆå¤‡ęƒ«ē„™č¢«å„”č‹Æęœ¬ē¬Øå“©ē»·ē”­ę³µč¹¦čæø逼鼻ęƔ鄙ē¬”å½¼ē¢§č“–č”½ęƕęƙęƖåøåŗ‡ē—¹é—­ę•å¼Šåæ…č¾Ÿå£č‡‚éæé™›éž­č¾¹ē¼–蓬ꉁä¾æ变卞č¾Øč¾©č¾«éę ‡å½Ŗ膘č”Øé³–ę†‹åˆ«ē˜Ŗå½¬ę–Œęæ’ę»Øå®¾ę‘ˆå…µå†°ęŸ„äø™ē§‰é„¼ē‚³\"],[\"b240\",\"ēēžēŸē ē¤ē§ē©ēŖē­\",11,\"ēŗē»ē¼ēžēž‚ēžƒēž†\",5,\"ēžēžēž“\",11,\"ēž”ēž£ēž¤ēž¦ēžØēž«ēž­ēž®ēžÆēž±ēž²ēž“ēž¶\",4],[\"b280\",\"ēž¼ēž¾ēŸ€\",12,\"ēŸŽ\",8,\"ēŸ˜ēŸ™ēŸšēŸ\",4,\"ēŸ¤ē—…并ēŽ»č ę’­ę‹Øé’µę³¢åšå‹ƒęé“‚ē®”ä¼Æåø›čˆ¶č„–膊ęø¤ę³Šé©³ę•åœå“ŗč”„åŸ äøåøƒę­„ē°æéƒØꀖꓦēŒœč£ęę‰č“¢ē¬čø©é‡‡å½©čœč””é¤å‚čš•ę®‹ęƒ­ęƒØēæč‹čˆ±ä»“ę²§č—ę“ē³™ę§½ę›¹č‰åŽ•ē­–ä¾§å†Œęµ‹å±‚č¹­ę’å‰čŒ¬čŒ¶ęŸ„ē¢“ę½åƟ岔差čÆ§ę‹†ęŸ“č±ŗꐀęŽŗč‰é¦‹č°—ē¼ é“²äŗ§é˜é¢¤ę˜ŒēŒ–\"],[\"b340\",\"ēŸ¦ēŸØēŸŖēŸÆēŸ°ēŸ±ēŸ²ēŸ“ēŸµēŸ·ēŸ¹ēŸŗēŸ»ēŸ¼ē ƒ\",5,\"ē Šē ‹ē Žē ē ē “ē •ē ™ē ›ē žē  ē ”ē ¢ē ¤ē Øē Ŗē «ē ®ē Æē ±ē ²ē ³ē µē ¶ē ½ē æē”ē”‚ē”ƒē”„ē”†ē”ˆē”‰ē”Šē”‹ē”ē”ē”‘ē”“ē””ē”˜ē”™ē”š\"],[\"b380\",\"ē”›ē”œē”ž\",11,\"ē”Æ\",7,\"ē”øē”¹ē”ŗē”»ē”½\",6,\"åœŗ尝åøøé•æåæč‚ åŽ‚ę•žē•…å”±å€”č¶…ęŠ„é’žęœå˜²ę½®å·¢åµē‚’č½¦ę‰Æę’¤ęŽ£å½»ę¾ˆéƒ“č‡£č¾°å°˜ę™Øåæ±ę²‰é™ˆč¶č”¬ę’‘ē§°åŸŽę©™ęˆå‘ˆä¹˜ēØ‹ęƒ©ę¾„čƚę‰æ逞éŖ‹ē§¤åƒē—“ęŒåŒ™ę± čæŸå¼›é©°č€»é½æ侈å°ŗ赤ēæ…ę–„ē‚½å……å†²č™«å“‡å® ęŠ½é…¬ē•“čøŒēØ ę„ē­¹ä»‡ē»øēž…äø‘č‡­åˆå‡ŗꩱåŽØčŗ‡é”„é›ę»é™¤ę„š\"],[\"b440\",\"ē¢„ē¢…ē¢†ē¢ˆē¢Šē¢‹ē¢ē¢ē¢’ē¢”ē¢•ē¢–ē¢™ē¢ē¢žē¢ ē¢¢ē¢¤ē¢¦ē¢Ø\",7,\"ē¢µē¢¶ē¢·ē¢øē¢ŗē¢»ē¢¼ē¢½ē¢æē£€ē£‚ē£ƒē£„ē£†ē£‡ē£ˆē£Œē£ē£Žē£ē£‘ē£’ē£“ē£–ē£—ē£˜ē£š\",9],[\"b480\",\"ē£¤ē£„ē£¦ē£§ē£©ē£Ŗē£«ē£­\",4,\"ē£³ē£µē£¶ē£øē£¹ē£»\",5,\"ē¤‚ē¤ƒē¤„ē¤†\",6,\"ē”€å‚ØēŸ—ęč§¦å¤„ę£å·ē©æę¤½ä¼ čˆ¹å–˜äø²ē–®ēŖ—å¹¢åŗŠé—Æ创吹ē‚Šę¶é”¤åž‚ę˜„ę¤æé†‡å”‡ę·³ēŗÆč ¢ęˆ³ē»°ē–µčŒØē£é›Œč¾žę…ˆē“·čÆę­¤åˆŗ赐ꬔčŖč‘±å›±åŒ†ä»Žäø›å‡‘ē²—醋ē°‡äæƒč¹æēÆ”ēŖœę‘§å“”å‚¬č„†ē˜ē²¹ę·¬ēæ ę‘å­˜åÆøē£‹ę’®ę“ęŽŖęŒ«é”™ę­č¾¾ē­”ē˜©ę‰“å¤§å‘†ę­¹å‚£ęˆ“åø¦ę®†ä»£č“·č¢‹å¾…逮\"],[\"b540\",\"ē¤\",5,\"ē¤”\",9,\"ē¤Ÿ\",4,\"ē¤„\",14,\"ē¤µ\",4,\"ē¤½ē¤æē„‚ē„ƒē„„ē„…ē„‡ē„Š\",8,\"ē„”ē„•ē„˜ē„™ē„”ē„£\"],[\"b580\",\"ē„¤ē„¦ē„©ē„Ŗē„«ē„¬ē„®ē„°\",6,\"ē„¹ē„»\",4,\"ē¦‚ē¦ƒē¦†ē¦‡ē¦ˆē¦‰ē¦‹ē¦Œē¦ē¦Žē¦ē¦‘ē¦’ę€ č€½ę‹…äø¹å•éƒøęŽøčƒ†ę—¦ę°®ä½†ęƒ®ę·”čÆžå¼¹č›‹å½“ęŒ”å…šč”ę”£åˆ€ę£č¹ˆå€’å²›ē„·åƼ到ēØ»ę‚¼é“ē›—å¾·å¾—ēš„č¹¬ēÆē™»ē­‰ēžŖå‡³é‚“å ¤ä½Žę»“čæŖꕌē¬›ē‹„궤ēæŸå«”ꊵåŗ•åœ°č’‚ē¬¬åøå¼Ÿé€’ē¼”é¢ ęŽ‚ę»‡ē¢˜ē‚¹å…ø靛垫ē”µä½ƒē”øåŗ—ęƒ¦å„ ę·€ę®æē¢‰å¼é›•å‡‹åˆęŽ‰åŠé’“č°ƒč·Œēˆ¹ē¢Ÿč¶čæ­č°å \"],[\"b640\",\"ē¦“\",6,\"ē¦›\",11,\"ē¦Ø\",10,\"ē¦“\",4,\"ē¦¼ē¦æē§‚ē§„ē§…ē§‡ē§ˆē§Šē§Œē§Žē§ē§ē§“ē§”ē§–ē§—ē§™\",5,\"ē§ ē§”ē§¢ē§„ē§Øē§Ŗ\"],[\"b680\",\"ē§¬ē§®ē§±\",6,\"ē§¹ē§ŗē§¼ē§¾ē§æē؁ē؄ē؅ē؇ē؈ē؉ē؊ē،ē؏\",4,\"ēؕēؖēؘēؙē؛ē؜äøē›Æå®é’‰é”¶é¼Žé”­å®šč®¢äø¢äøœå†¬č‘£ę‡‚åŠØę ‹ä¾—ę«å†»ę“žå…œęŠ–ę–—é™”č±†é€—ē—˜éƒ½ē£ęƒēŠŠē‹¬čƻ堵ē¹čµŒęœé•€č‚šåŗ¦ęø”妒ē«ÆēŸ­é”»ę®µę–­ē¼Žå †å…‘队åƹ墩åØč¹²ę•¦é”æ囤钝ē›¾éęŽ‡å“†å¤šå¤ŗ垛čŗ²ęœµč·ŗčˆµå‰ęƒ°å •č›¾å³Ø鹅äæ„é¢č®¹åØ„ę¶åŽ„ę‰¼éé„‚é„æę©č€Œå„æč€³å°”é„µę“±äŗŒ\"],[\"b740\",\"ē؝ē؟ēØ”ēØ¢ēؤ\",14,\"ēØ“ēصēضēØøēØŗēؾē©€\",5,\"ē©‡\",9,\"ē©’\",4,\"ē©˜\",16],[\"b780\",\"ē©©\",6,\"ē©±ē©²ē©³ē©µē©»ē©¼ē©½ē©¾ēŖ‚ēŖ…ēŖ‡ēŖ‰ēŖŠēŖ‹ēŖŒēŖŽēŖēŖēŖ“ēŖ”ēŖ™ēŖšēŖ›ēŖžēŖ”ēŖ¢č“°å‘ē½šē­ä¼ä¹é˜€ę³•ēč—©åø†ē•Ŗēæ»ę؊ēŸ¾é’’ē¹å‡”ēƒ¦åčæ”čŒƒč“©ēŠÆé„­ę³›åŠčŠ³ę–¹č‚Ŗęˆæ防å¦Øä»æč®æēŗŗę”¾č²éžå•”é£žč‚„åŒŖčƽ吠č‚ŗåŗŸę²øč“¹čŠ¬é…šå©ę°›åˆ†ēŗ·åŸē„šę±¾ē²‰å„‹ä»½åææꄤē²Ŗäø°å°ęž«čœ‚峰锋风ē–Æēƒ½é€¢å†Æē¼č®½å„‰å‡¤ä½›å¦å¤«ę•·č‚¤å­µę‰¶ę‹‚č¾å¹…ę°Ÿē¬¦ä¼äæ˜ęœ\"],[\"b840\",\"ēŖ£ēŖ¤ēŖ§ēŖ©ēŖŖēŖ«ēŖ®\",4,\"ēŖ“\",10,\"ē«€\",10,\"ē«Œ\",9,\"ē«—ē«˜ē«šē«›ē«œē«ē«”ē«¢ē«¤ē«§\",5,\"ē«®ē«°ē«±ē«²ē«³\"],[\"b880\",\"ē«“\",4,\"ē«»ē«¼ē«¾ē¬€ē¬ē¬‚ē¬…ē¬‡ē¬‰ē¬Œē¬ē¬Žē¬ē¬’ē¬“ē¬–ē¬—ē¬˜ē¬šē¬œē¬ē¬Ÿē¬”ē¬¢ē¬£ē¬§ē¬©ē¬­ęµ®ę¶Ŗē¦č¢±å¼—ē”«ęŠšč¾…äæÆ釜ꖧč„Æ腑åŗœč…čµ“å‰Æč¦†čµ‹å¤å‚…ä»˜é˜œēˆ¶č…¹č“ŸåÆŒč®£é™„å¦‡ē¼šå’å™¶å˜ŽčÆ„ę”¹ę¦‚é’™ē›–ęŗ‰å¹²ē”˜ę†ęŸ‘ē«æč‚čµ¶ę„Ÿē§†ę•¢čµ£å†ˆåˆšé’¢ē¼ø肛ēŗ²å²—ęøÆꝠēƙēš‹é«˜č†ē¾”ē³•ęžé•ēØæå‘Šå“„ę­Œęęˆˆéø½čƒ³ē–™å‰²é©č‘›ę ¼č›¤é˜éš”铬äøŖ各ē»™ę ¹č·Ÿč€•ę›“åŗšē¾¹\"],[\"b940\",\"ē¬Æē¬°ē¬²ē¬“ē¬µē¬¶ē¬·ē¬¹ē¬»ē¬½ē¬æ\",5,\"ē­†ē­ˆē­Šē­ē­Žē­“ē­•ē­—ē­™ē­œē­žē­Ÿē­”ē­£\",10,\"ē­Æē­°ē­³ē­“ē­¶ē­øē­ŗē­¼ē­½ē­æē®ē®‚ē®ƒē®„ē®†\",6,\"ē®Žē®\"],[\"b980\",\"ē®‘ē®’ē®“ē®–ē®˜ē®™ē®šē®›ē®žē®Ÿē® ē®£ē®¤ē®„ē®®ē®Æē®°ē®²ē®³ē®µē®¶ē®·ē®¹\",7,\"ēƂēƃēƄ埂č€æę¢—å·„ę”»åŠŸę­é¾šä¾›čŗ¬å…¬å®«å¼“å·©ę±žę‹±č“”å…±é’©å‹¾ę²Ÿč‹Ÿē‹—åž¢ęž„č“­å¤Ÿč¾œč‡å’•ē®ä¼°ę²½å­¤å§‘é¼“å¤č›ŠéŖØč°·č‚”ę•…é”¾å›ŗ雇刮ē“œå‰åÆ”ęŒ‚č¤‚ä¹–ę‹ę€Ŗę£ŗå…³å®˜å† č§‚ē®”馆ē½ęƒÆēŒč“Æ光å¹æ逛ē‘°č§„圭ē”…归龟é—ŗč½Ø鬼čÆ”ē™øę”‚ęŸœč·Ŗč“µåˆ½č¾Šę»šę£é”…éƒ­å›½ęžœč£¹čæ‡å“ˆ\"],[\"ba40\",\"ēƅēƈēƉēƊēƋēƍēƎēƏēƐēƒēƔ\",4,\"ēƛēƜēƞēƟēÆ ēÆ¢ēÆ£ēƤēƧēÆØēÆ©ēÆ«ēƬēÆ­ēÆÆēÆ°ēƲ\",4,\"ēÆøēƹēÆŗēÆ»ēƽēÆæ\",7,\"ē°ˆē°‰ē°Šē°ē°Žē°\",5,\"ē°—ē°˜ē°™\"],[\"ba80\",\"ē°š\",4,\"ē° \",5,\"ē°Øē°©ē°«\",12,\"ē°¹\",5,\"ē±‚éŖøå­©ęµ·ę°¦äŗ„害éŖ‡é…£ę†Øé‚ÆéŸ©å«ę¶µåƒ函喊ē½•ēæ°ę’¼ęę—±ę†¾ę‚ē„Šę±—걉å¤ÆꝭčˆŖ壕嚎č±ŖęÆ«éƒå„½č€—å·ęµ©å‘µå–č·čę øē¦¾å’Œä½•åˆē›’č²‰é˜‚ę²³ę¶øčµ«č¤é¹¤č“ŗå˜æ黑ē—•å¾ˆē‹ ęØ哼äŗØęØŖč””ę’č½°å“„ēƒ˜č™¹éøæę“Ŗ宏弘ēŗ¢å–‰ä¾ÆēŒ“吼厚候后呼乎åæ½ē‘šå£¶č‘«čƒ”č“ē‹ē³Šę¹–\"],[\"bb40\",\"ē±ƒ\",9,\"ē±Ž\",36,\"ē±µ\",5,\"ē±¾\",9],[\"bb80\",\"ē²ˆē²Š\",6,\"ē²“ē²”ē²–ē²™ē²šē²›ē² ē²”ē²£ē²¦ē²§ē²Øē²©ē²«ē²¬ē²­ē²Æē²°ē²“\",4,\"ē²ŗē²»å¼§č™Žå”¬ęŠ¤äŗ’ę²Ŗęˆ·čŠ±å“—åŽēŒ¾ę»‘ē”»åˆ’化čÆę§å¾Šę€€ę·®åę¬¢ēŽÆꔓčæ˜ē¼“ę¢ę‚£å”¤ē—Ŗč±¢ē„•ę¶£å®¦å¹»č’ę…Œé»„ē£ŗ蝗ē°§ēš‡å‡°ęƒ¶ē…Œę™ƒå¹Œęč°Žē°ęŒ„č¾‰å¾½ę¢č›”å›žęÆę‚”ę…§å‰ęƒ ę™¦č“æē§½ä¼šēƒ©ę±‡č®³čƲē»˜č¤ę˜å©šé­‚ęµ‘ę··č±ę“»ä¼™ē«čŽ·ęˆ–ęƒ‘éœč“§ē„ø击圾åŸŗęœŗē•øēؽē§Æē®•\"],[\"bc40\",\"ē²æē³€ē³‚ē³ƒē³„ē³†ē³‰ē³‹ē³Ž\",6,\"ē³˜ē³šē³›ē³ē³žē³”\",6,\"ē³©\",5,\"ē³°\",7,\"ē³¹ē³ŗē³¼\",13,\"ē“‹\",5],[\"bc80\",\"ē“‘\",14,\"ē“”ē“£ē“¤ē“„ē“¦ē“Øē“©ē“Ŗē“¬ē“­ē“®ē“°\",6,\"č‚Œé„„čæ¹ęæ€č®„éø”姬ē»©ē¼‰å‰ęžę£˜č¾‘ē±é›†åŠę€„ē–¾ę±²å³å«‰ēŗ§ęŒ¤å‡ č„Šå·±č“ŸęŠ€å†€å­£ä¼Žē„­å‰‚ę‚ø굎åƄåÆ‚č®”č®°ę—¢åæŒé™…妓ē»§ēŗŖå˜‰ęž·å¤¹ä½³å®¶åŠ čšé¢Šč“¾ē”²é’¾å‡ēØ¼ä»·ęž¶é©¾å«ę­¼ē›‘坚尖ē¬ŗé—“ē…Žå…¼č‚©č‰°å„øē¼„čŒ§ę£€ęŸ¬ē¢±ē”·ę‹£ę”ē®€äæ­å‰Ŗå‡čę§›é‰“č·µč“±č§é”®ē®­ä»¶\"],[\"bd40\",\"ē“·\",54,\"ēµÆ\",7],[\"bd80\",\"ēµø\",32,\"å„čˆ°å‰‘é„Æęøęŗ…궧å»ŗåƒµå§œå°†ęµ†ę±Ÿē–†č’‹ę”Øå„–č®²åŒ é…±é™č•‰ę¤’ē¤ē„¦čƒ¶äŗ¤éƒŠęµ‡éŖ„åØ‡åš¼ę…é“°ēŸ«ä¾„脚ē‹”角é„ŗē¼“ē»žå‰æꕙ酵č½æč¾ƒå«ēŖ–ę­ęŽ„ēš†ē§øč”—é˜¶ęˆŖåŠ«čŠ‚ę””ę°ę·ē«ē«­ę“ē»“č§£å§ęˆ’č—‰čŠ„ē•Œå€Ÿä»‹ē–„čƫ届巾ē­‹ę–¤é‡‘ä»Šę“„č„Ÿē“§é”¦ä»…č°Øčæ›é³ę™‹ē¦čæ‘ēƒ¬ęµø\"],[\"be40\",\"ē¶™\",12,\"ē¶§\",6,\"ē¶Æ\",42],[\"be80\",\"ē·š\",32,\"å°½åŠ²č†å…¢čŒŽē›ę™¶é²øäŗ¬ęƒŠē²¾ē²³ē»äŗ•č­¦ę™Æé¢ˆé™å¢ƒę•¬é•œå¾„ē—‰é–ē«Ÿē«žå‡€ē‚ÆēŖ˜ęŖē©¶ēŗ ēŽ–韭久ēøä¹é…’åŽ©ę•‘ę—§č‡¼čˆ…å’Žå°±ē–šéž ę‹˜ē‹™ē–½å±…é©¹čŠå±€å’€ēŸ©äø¾ę²®čšę‹’ę®å·Øå…·č·čøžé”Æäæ±å„ꃧē‚¬å‰§ęé¹ƒå؟倦ēœ·å·ē»¢ę’…ę”«ęŠ‰ęŽ˜å€”ēˆµč§‰å†³čƀē»å‡čŒé’§å†›å›å³»\"],[\"bf40\",\"ē·»\",62],[\"bf80\",\"ēøŗēø¼\",4,\"ē¹‚\",4,\"ē¹ˆ\",21,\"äæŠē«£ęµšéƒ”éŖå–€å’–協å’Æå¼€ę©ę„·å‡Æę…Ø刊å Ŗ勘坎ē ēœ‹åŗ·ę…·ē³ ę‰›ęŠ—äŗ¢ē‚•č€ƒę‹·ēƒ¤é å·č‹›ęŸÆę£µē£•é¢—ē§‘壳咳åÆęø“克刻客čƾč‚Æå•ƒåž¦ę³å‘å­ē©ŗęå­”ęŽ§ęŠ å£ę‰£åƇęžÆ哭ēŖŸč‹¦é…·åŗ“č£¤å¤øåž®ęŒŽč·ØčƒÆ块ē­·ä¾©åæ«å®½ę¬¾åŒ”ē­ē‹‚ꔆēŸæēœ¶ę—·å†µäŗē›”å²æēŖ„č‘µå„Žé­å‚€\"],[\"c040\",\"ē¹ž\",35,\"ēŗƒ\",23,\"ēŗœēŗēŗž\"],[\"c080\",\"ēŗ®ēŗ“ēŗ»ēŗ¼ē»–ē»¤ē»¬ē»¹ē¼Šē¼ē¼žē¼·ē¼¹ē¼»\",6,\"ē½ƒē½†\",9,\"ē½’ē½“é¦ˆę„§ęŗƒå¤ę˜†ę†å›°ę‹¬ę‰©å»“é˜”åžƒę‹‰å–‡čœ”č…Šč¾£å•¦čŽ±ę„čµ–č“å©Ŗę ę‹¦ēÆ®é˜‘å…°ę¾œč°°ę½č§ˆę‡’ē¼†ēƒ‚껄ē…ꦔē‹¼å»ŠéƒŽęœ—ęµŖęžåŠ³ē‰¢č€ä½¬å§„é…Ŗēƒ™ę¶å‹’ä¹é›·é•­č•¾ē£Šē“Æå„”åž’ę“‚č‚‹ē±»ę³Ŗę£±ę„žå†·åŽ˜ę¢ØēŠé»ŽēƱē‹øē¦»ę¼“ē†ęŽé‡Œé²¤ē¤¼čŽ‰č”åę —äø½åŽ‰åŠ±ē ¾åŽ†åˆ©å‚ˆä¾‹äæ\"],[\"c140\",\"ē½–ē½™ē½›ē½œē½ē½žē½ ē½£\",4,\"ē½«ē½¬ē½­ē½Æē½°ē½³ē½µē½¶ē½·ē½øē½ŗē½»ē½¼ē½½ē½æē¾€ē¾‚\",7,\"ē¾‹ē¾ē¾\",4,\"ē¾•\",4,\"ē¾›ē¾œē¾ ē¾¢ē¾£ē¾„ē¾¦ē¾Ø\",6,\"ē¾±\"],[\"c180\",\"ē¾³\",4,\"ē¾ŗē¾»ē¾¾ēæ€ēæ‚ēæƒēæ„ēæ†ēæ‡ēæˆēæ‰ēæ‹ēæēæ\",4,\"ēæ–ēæ—ēæ™\",5,\"ēæ¢ēæ£ē—¢ē«‹ē²’ę²„隶力ē’ƒå“©äæ©č”čŽ²čæžé•°å»‰ę€œę¶Ÿåø˜ę•›č„øé“¾ę‹ē‚¼ē»ƒē²®å‡‰ę¢ē²±č‰Æäø¤č¾†é‡ę™¾äŗ®č°…ę’©čŠåƒšē–—ē‡ŽåÆ„č¾½ę½¦äŗ†ę’‚é•£å»–ę–™åˆ—č£‚ēƒˆåŠ£ēŒŽē³ęž—ē£·éœ–äø“é‚»é³žę·‹å‡›čµåę‹ŽēŽ²č±é›¶é¾„铃伶ē¾šå‡Œēµé™µå²­é¢†å¦ä»¤ęŗœē‰ę¦“ē”«é¦ē•™åˆ˜ē˜¤ęµęŸ³å…­é¾™č‹å’™ē¬¼ēŖæ\"],[\"c240\",\"ēæ¤ēæ§ēæØēæŖēæ«ēæ¬ēæ­ēæÆēæ²ēæ“\",6,\"ēæ½ēæ¾ēææč€‚č€‡č€ˆč€‰č€Šč€Žč€č€‘č€“č€šč€›č€č€žč€Ÿč€”č€£č€¤č€«\",5,\"č€²č€“č€¹č€ŗč€¼č€¾č€čč„č…č‡čˆč‰čŽččč‘č“č•č–č—\"],[\"c280\",\"聙聛\",13,\"聫\",5,\"č²\",11,\"éš†åž„ę‹¢é™‡ę„¼åØ„ę‚ēÆ“ę¼é™‹čŠ¦å¢é¢…åŗē‚‰ęŽ³å¤č™é²éŗ“ē¢Œéœ²č·Æ赂é¹æę½žē¦„å½•é™†ęˆ®é©“å•é“ä¾£ę—…å±„å±”ē¼•č™‘ę°Æ律ēŽ‡ę»¤ē»æå³¦ęŒ›å­Ŗę»¦åµä¹±ęŽ ē•„ęŠ”č½®ä¼¦ä»‘ę²¦ēŗ¶č®ŗ萝čžŗē½—逻锣ē®©éŖ”č£øč½ę“›éŖ†ē»œå¦ˆéŗ»ēŽ›ē čš‚马éŖ‚嘛吗埋买éŗ¦å–čæˆč„‰ēž’é¦’č›®ę»”č”“ę›¼ę…¢ę¼«\"],[\"c340\",\"č¾č‚č‚‚č‚…č‚ˆč‚Šč‚\",5,\"č‚”č‚•č‚—č‚™č‚žč‚£č‚¦č‚§č‚Øč‚¬č‚°č‚³č‚µč‚¶č‚øč‚¹č‚»čƒ…čƒ‡\",4,\"胏\",6,\"čƒ˜čƒŸčƒ čƒ¢čƒ£čƒ¦čƒ®čƒµčƒ·čƒ¹čƒ»čƒ¾čƒæ脀脁脃脄脅脇脈脋\"],[\"c380\",\"脌脕脗脙脛脜脝脟\",12,\"č„­č„®č„°č„³č„“č„µč„·č„¹\",4,\"č„æč°©čŠ’čŒ«ē›²ę°“åæ™čŽ½ēŒ«čŒ…锚ęƛēŸ›é“†åÆčŒ‚å†’åø½č²Œč“ø么ēŽ«ęžšę¢…酶霉ē…¤ę²”ēœ‰åŖ’镁ęƏē¾Žę˜§åƐ妹åŖšé—Øé—·ä»¬čŒč’™ęŖ¬ē›Ÿé”°ēŒ›ę¢¦å­ŸēœÆ醚靔ē³œčæ·č°œå¼„ē±³ē§˜č§…ę³ŒčœœåÆ†å¹‚ę£‰ēœ ē»µå†•å…å‹‰åØ©ē¼…é¢č‹—ęēž„藐ē§’ęøŗåŗ™å¦™č”‘ē­ę°‘ęŠæēšæꕏę‚Æé—½ę˜ŽčžŸéø£é“­åå‘½č°¬ę‘ø\"],[\"c440\",\"腀\",5,\"腇腉腍腎腏腒腖腗腘腛\",4,\"č…”č…¢č…£č…¤č…¦č…Øč…Ŗč…«č…¬č…Æč…²č…³č…µč…¶č…·č…ø膁膃\",4,\"膉膋膌膍膎膐膒\",5,\"膙膚膞\",4,\"膤膄\"],[\"c480\",\"膧膩膫\",7,\"膓\",5,\"č†¼č†½č†¾č†æ臄臅臇臈臉臋臍\",6,\"ę‘¹č˜‘ęØ”č†œē£Øę‘©é­”ęŠ¹ęœ«čŽ«å¢Øé»˜ę²«ę¼ åÆžé™Œč°‹ē‰ŸęŸę‹‡ē‰”äŗ©å§†ęÆå¢“ęš®å¹•å‹Ÿę…•ęœØē›®ē¦ē‰§ē©†ę‹æå“Ŗ呐钠那å؜ēŗ³ę°–ä¹ƒå„¶č€å„ˆå—ē”·éš¾å›ŠęŒ č„‘ę¼é—¹ę·–å‘¢é¦å†…å«©čƒ½å¦®éœ“å€Ŗę³„å°¼ę‹Ÿä½ åŒæ腻逆ęŗŗč”«ę‹ˆå¹“ē¢¾ę’µę»åæµåؘé…æéøŸå°æęč‚å­½å•®é•Šé•ę¶…ę‚Ø꟠ē‹žå‡å®\"],[\"c540\",\"臔\",14,\"臤臄臦č‡Ø臩臫臮\",4,\"臵\",5,\"č‡½č‡æ舃與\",4,\"舎舏舑舓舕\",5,\"čˆčˆ čˆ¤čˆ„čˆ¦čˆ§čˆ©čˆ®čˆ²čˆŗčˆ¼čˆ½čˆæ\"],[\"c580\",\"艀艁艂艃艅艆艈艊艌艍艎艐\",7,\"艙艛艜艝艞艠\",7,\"č‰©ę‹§ę³žē‰›ę‰­é’®ēŗ½č„“ęµ“å†œå¼„å„“åŠŖę€’å„³ęš–č™ē–ŸęŒŖꇦē³ÆčÆŗå“¦ę¬§éø„ę®“č—•å‘•å¶ę²¤å•Ŗ趓ēˆ¬åø•ę€•ē¶ę‹ęŽ’ē‰Œå¾˜ę¹ƒę“¾ę”€ę½˜ē›˜ē£ē›¼ē•”判叛乓åŗžę—č€Ŗčƒ–ęŠ›å’†åˆØē‚®č¢č·‘ę³”å‘øčƒšåŸ¹č£“čµ”é™Ŗé…ä½©ę²›å–·ē›†ē °ęŠØēƒ¹ę¾Žå½­č“¬ę£šē”¼ēÆ·č†Øęœ‹é¹ę§ē¢°åÆē ’éœ¹ę‰¹ęŠ«åŠˆēµęƗ\"],[\"c640\",\"č‰Ŗ艫艬艭艱艵艶艷č‰øč‰»č‰¼čŠ€čŠčŠƒčŠ…čŠ†čŠ‡čŠ‰čŠŒčŠčŠ“čŠ”čŠ•čŠ–čŠščŠ›čŠžčŠ čŠ¢čŠ£čŠ§čŠ²čŠµčŠ¶čŠŗčŠ»čŠ¼čŠæč‹€č‹‚č‹ƒč‹…č‹†č‹‰č‹č‹–č‹™č‹šč‹č‹¢č‹§č‹Øč‹©č‹Ŗč‹¬č‹­č‹®č‹°č‹²č‹³č‹µč‹¶č‹ø\"],[\"c680\",\"č‹ŗč‹¼\",4,\"茊茋茍茐茒茓茖茘茙茝\",9,\"čŒ©čŒŖčŒ®čŒ°čŒ²čŒ·čŒ»čŒ½å•¤č„¾ē–²ēš®åŒ¹ē—žåƒ»å±č­¬ēƇ偏ē‰‡éŖ—é£˜ę¼‚ē“¢ē„Øꒇēž„ę‹¼é¢‘č“«å“č˜ä¹’åŖč‹¹čå¹³å‡­ē“¶čÆ„å±å”ę³¼é¢‡å©†ē “魄čæ«ē²•å‰–ꉑé“ŗä»†čŽ†č‘”č©č’²åŸ”ęœ“åœƒę™®ęµ¦č°±ę›ē€‘ęœŸę¬ŗę –ęˆšå¦»äøƒå‡„ę¼†ęŸ’ę²å…¶ę£‹å„‡ę­§ē•¦å“Žč„é½ę——ē„ˆē„éŖ‘čµ·å²‚ä¹žä¼åÆå„‘ē Œå™Ø갔čæ„å¼ƒę±½ę³£č®«ęŽ\"],[\"c740\",\"čŒ¾čŒæ荁荂荄荅荈荊\",4,\"荓荕\",4,\"čč¢č°\",6,\"č¹čŗč¾\",6,\"čŽ‡čŽˆčŽŠčŽ‹čŽŒčŽčŽčŽčŽ‘čŽ”čŽ•čŽ–čŽ—čŽ™čŽščŽčŽŸčŽ”\",6,\"莬莭莮\"],[\"c780\",\"čŽÆčŽµčŽ»čŽ¾čŽæč‚čƒč„č†čˆč‰č‹ččŽčč‘č’č“č•č—č™čšč›čžč¢č£č¤č¦č§čØč«č¬č­ę°ę“½ē‰µę‰¦é’Žé“…千čæē­¾ä»Ÿč°¦ä¹¾é»”é’±é’³å‰ę½œé£ęµ…č°“å ‘åµŒę¬ ę­‰ęžŖå‘›č…”ē¾Œå¢™č”·å¼ŗęŠ¢ę©‡é”¹ę•²ę‚„ę”„ēž§ä¹”ä¾Øå·§éž˜ę’¬ēæ˜å³­äæēŖåˆ‡čŒ„äø”ę€ÆēŖƒé’¦ä¾µäŗ²ē§¦ē“å‹¤čŠ¹ę“’ē¦½åÆę²é’č½»ę°¢å€¾åæęø…ę“Žę™“ę°°ęƒ…é”·čÆ·åŗ†ē¼ē©·ē§‹äø˜é‚±ēƒę±‚å›šé…‹ę³…č¶‹åŒŗč›†ę›²čŗÆ屈驱ęø \"],[\"c840\",\"č®čÆč³\",4,\"čŗč»č¼č¾čæ萀萂萅萇萈萉萊萐萒\",5,\"萙萚萛萞\",5,\"萩\",7,\"č²\",5,\"č¹čŗč»č¾\",7,\"葇葈葉\"],[\"c880\",\"葊\",6,\"葒\",4,\"č‘˜č‘č‘žč‘Ÿč‘ č‘¢č‘¤\",4,\"č‘Ŗč‘®č‘Æč‘°č‘²č‘“č‘·č‘¹č‘»č‘¼å–åØ¶é¾‹č¶£åŽ»åœˆé¢§ęƒé†›ę³‰å…Øē—Šę‹³ēŠ¬åˆø劝ē¼ŗē‚”ē˜øå“é¹Šę¦·ē”®é›€č£™ē¾¤ē„¶ē‡ƒå†‰ęŸ“ē“¤å£¤ę”˜åš·č®©é„¶ę‰°ē»•ęƒ¹ēƒ­å£¬ä»äŗŗåæéŸ§ä»»č®¤åˆƒå¦Šēŗ«ę‰”ä»ę—„ꈎčŒøč“‰č£čžē†”ęŗ¶å®¹ē»’å†—ę‰ęŸ”č‚‰čŒ¹č •å„’å­ŗå¦‚č¾±ä¹³ę±å…„č¤„č½Æé˜®č•Šē‘žé”é—°ę¶¦č‹„å¼±ę’’ę“’čØč…®é³ƒå”žčµ›äø‰å\"],[\"c940\",\"č‘½\",4,\"蒃蒄蒅蒆蒊蒍蒏\",7,\"č’˜č’šč’›č’č’žč’Ÿč’ č’¢\",12,\"č’°č’±č’³č’µč’¶č’·č’»č’¼č’¾č“€č“‚č“ƒč“…č“†č“‡č“ˆč“‹č“Œč“Žč“č“’č“”č“•č“—\"],[\"c980\",\"蓘\",4,\"č“žč“”č“¢č“¤č“§\",4,\"č“­č“®č“Æ蓱\",10,\"č“½č“¾č”€č”č”‚ä¼žę•£ę”‘å—“äø§ę”éŖšę‰«å«‚ē‘Ÿč‰²ę¶©ę£®åƒ§čŽŽē ‚ę€åˆ¹ę²™ēŗ±å‚»å•„ē…žē­›ę™’ēŠč‹«ę‰å±±åˆ ē…½č”«é—Ŗé™•ę“…čµ”č†³å–„ę±•ę‰‡ē¼®å¢’ä¼¤å•†čµę™ŒäøŠå°šč£³ę¢¢ęŽē؍ēƒ§čŠå‹ŗ韶少å“Ø邵ē»å„¢čµŠč›‡čˆŒčˆčµ¦ę‘„å°„ę…‘ę¶‰ē¤¾č®¾ē ·ē”³å‘»ä¼øčŗ«ę·±åØ ē»…ē„žę²ˆå®”婶ē”šč‚¾ę…Žęø—声ē”Ÿē”„ē‰²å‡ē»³\"],[\"ca40\",\"蔃\",8,\"č”č”Žč”č”č”’č””č”•č”–č”˜č”™č”›č”œč”č”žč” č”¢\",8,\"蔭\",9,\"č”¾\",4,\"蕄蕅蕆蕇蕋\",10],[\"ca80\",\"蕗蕘蕚蕛蕜蕝蕟\",4,\"蕄蕦蕧蕩\",8,\"č•³č•µč•¶č•·č•øč•¼č•½č•æ薀薁ēœē››å‰©čƒœåœ£åøˆå¤±ē‹®ę–½ę¹æčƗå°øč™±åēŸ³ę‹¾ę—¶ä»€é£Ÿčš€å®žčƆ史ēŸ¢ä½æ屎驶始式ē¤ŗ士äø–ęŸæäŗ‹ę‹­čŖ“逝åŠæę˜Æå—œå™¬é€‚ä»•ä¾é‡Šé„°ę°åø‚ęƒå®¤č§†čÆ•ę”¶ę‰‹é¦–å®ˆåÆæęŽˆå”®å—ē˜¦å…½č”¬ęž¢ę¢³ę®ŠęŠ’č¾“å”čˆ’ę·‘ē–ä¹¦čµŽå­°ē†Ÿč–Æꚑꛙē½²čœ€é»é¼ å±žęœÆčæ°ę ‘ęŸęˆē«–墅åŗ¶ę•°ę¼±\"],[\"cb40\",\"薂薃薆薈\",6,\"薐\",10,\"薝\",6,\"薄薦薧薩薫薬薭薱\",5,\"č–øč–ŗ\",6,\"藂\",6,\"藊\",4,\"藑藒\"],[\"cb80\",\"藔藖\",5,\"藝\",6,\"藄藦藧č—Øč—Ŗ\",14,\"ę•åˆ·č€ę‘”č”°ē”©åø…ę “ę‹“霜双ēˆ½č°ę°“ē”ē؎吮ēž¬é”ŗ舜čÆ“ē”•ęœ”ēƒę–Æę’•å˜¶ę€ē§åøäøę­»č‚†åÆŗ嗣四ä¼ŗä¼¼é„²å·³ę¾č€øę€‚é¢‚é€å®‹č®¼čÆµęœč‰˜ę“žå—½č‹é…„äæ—ē“ é€Ÿē²Ÿåƒ³å”‘ęŗÆå®æčÆ‰č‚ƒé…ø蒜ē®—č™½éš‹éšē»„髓ē¢Žå²ē©—遂隧ē„Ÿå­™ęŸē¬‹č“‘ę¢­å”†ē¼©ēē“¢é”ę‰€å”Œä»–它儹唔\"],[\"cc40\",\"č—¹č—ŗč—¼č—½č—¾č˜€\",4,\"蘆\",10,\"蘒蘓蘔蘕蘗\",15,\"č˜Øč˜Ŗ\",13,\"č˜¹č˜ŗč˜»č˜½č˜¾č˜æ虀\"],[\"cc80\",\"虁\",11,\"虒虓處\",4,\"č™›č™œč™č™Ÿč™ č™”č™£\",7,\"ē­ęŒžč¹‹čøčƒŽč‹”ęŠ¬å°ę³°é…žå¤Ŗę€ę±°åę‘Šč“Ŗē˜«ę»©å›ęŖ€ē—°ę½­č°­č°ˆå¦ęÆÆč¢’ē¢³ęŽ¢å¹ē‚­ę±¤å”˜ęŖå ‚ę£ č†›å”ē³–倘čŗŗę·Œč¶Ÿēƒ«ęŽę¶›ę»”ē»¦č„ę”ƒé€ƒę·˜é™¶č®Øå„—ē‰¹č—¤č…¾ē–¼čŖŠę¢Æ剔čø¢é”‘ęé¢˜č¹„å•¼ä½“ę›æåšęƒ•ę¶•å‰ƒå±‰å¤©ę·»å”«ē”°ē”œę¬čˆ”č…†ęŒ‘ę”čæ¢ēœŗč·³č““é“åø–厅听ēƒƒ\"],[\"cd40\",\"虭č™Æč™°č™²\",6,\"蚃\",6,\"蚎\",4,\"蚔蚖\",5,\"蚞\",4,\"čš„čš¦čš«čš­čš®čš²čš³čš·čšøčš¹čš»\",4,\"蛁蛂蛃蛅蛈蛌蛍蛒蛓蛕蛖蛗蛚蛜\"],[\"cd80\",\"č›č› č›”č›¢č›£č›„č›¦č›§č›Øč›Ŗ蛫蛬č›Æ蛵蛶蛷č›ŗč›»č›¼č›½č›æčœčœ„čœ…čœ†čœ‹čœŒčœŽčœčœčœ‘čœ”čœ–ę±€å»·åœäŗ­åŗ­ęŒŗ艇通ꔐ酮ēž³åŒé“œå½¤ē«„ę”¶ę…ē­’ē»Ÿē—›å·ęŠ•å¤“透å‡øē§ƒēŖå›¾å¾’é€”ę¶‚å± åœŸåå…”ę¹å›¢ęŽØ颓č…æ蜕č¤Ŗ退吞å±Æč‡€ę‹–ę‰˜č„±éøµé™€é©®é©¼ę¤­å¦„ę‹“å”¾ęŒ–å“‡č›™ę“¼å؃ē“¦č¢œę­Ŗå¤–č±Œå¼Æę¹¾ēŽ©é”½äøøēƒ·å®Œē¢—ęŒ½ę™šēš–ęƒ‹å®›å©‰äø‡č…•ę±ŖēŽ‹äŗ”꞉ē½‘å¾€ę—ŗꜛåæ˜å¦„å؁\"],[\"ce40\",\"čœ™čœ›čœčœŸčœ čœ¤čœ¦čœ§čœØčœŖčœ«čœ¬čœ­čœÆčœ°čœ²čœ³čœµčœ¶čœøčœ¹čœŗčœ¼čœ½č€\",6,\"蝊蝋蝍蝏蝐蝑蝒蝔蝕蝖蝘蝚\",5,\"č”č¢č¦\",7,\"čÆč±č²č³čµ\"],[\"ce80\",\"č·čøč¹čŗčæ螀螁螄螆螇螉螊螌螎\",4,\"螔螕螖螘\",6,\"螠\",4,\"巍微危韦čæę”…囓å”Æꃟäøŗę½ē»“č‹‡čŽå§”ä¼Ÿä¼Ŗå°¾ēŗ¬ęœŖč”šå‘³ē•čƒƒå–‚魏位ęø­č°“å°‰ę…°å«ē˜Ÿęø©čšŠę–‡é—»ēŗ¹å»ēسē“Šé—®å—”ēæē“®ęŒčœ—궔ēŖęˆ‘ę–”å§ę”ę²ƒå·«å‘œé’Øä¹Œę±”čÆ¬å±‹ę— čŠœę¢§å¾å“ęÆ‹ę­¦äŗ”ę‚åˆčˆžä¼ä¾®åžęˆŠé›¾ę™¤ē‰©å‹æåŠ”ę‚ŸčÆÆꘔē†™ęžč„æē”’ēŸ½ę™°å˜»åøé””ē‰ŗ\"],[\"cf40\",\"螄螦螧螩čžŖčž®čž°čž±čž²čž“čž¶čž·čžøčž¹čž»čž¼čž¾čžæ蟁\",4,\"蟇蟈蟉蟌\",4,\"蟔\",6,\"čŸœčŸčŸžčŸŸčŸ”čŸ¢čŸ£čŸ¤čŸ¦čŸ§čŸØčŸ©čŸ«čŸ¬čŸ­čŸÆ\",9],[\"cf80\",\"čŸŗčŸ»čŸ¼čŸ½čŸæ蠀蠁蠂蠄\",5,\"蠋\",7,\"蠔蠗蠘蠙蠚蠜\",4,\"č £ē؀ęÆåøŒę‚‰č†å¤•ęƒœē†„ēƒÆęŗŖ걐ēŠ€ęŖ„č¢­åø­ä¹ åŖ³å–œé“£ę“—ē³»éš™ęˆē»†ēžŽč™¾åŒ£éœžč¾–ęš‡å³”ä¾ ē‹­äø‹åŽ¦å¤å“ꎀé”Ø先仙鲜ēŗ¤å’øč“¤č””čˆ·é—²ę¶Žå¼¦å«Œę˜¾é™©ēŽ°ēŒ®åŽæč…ŗ馅ē¾”å®Ŗ陷限ēŗæē›ø厢镶香ē®±č„„ę¹˜ä¹”ēæ”ē„„čÆ¦ęƒ³å“äŗ«é”¹å··ę©”åƒå‘č±”č§ē”éœ„å‰Šå“®åš£é”€ę¶ˆå®µę·†ę™“\"],[\"d040\",\"č ¤\",13,\"č ³\",5,\"č ŗč »č ½č ¾č æč”č”‚č”ƒč”†\",5,\"蔎\",5,\"č”•č”–č”˜č”š\",6,\"蔦蔧č”Ŗč”­č”Æč”±č”³č”“č”µč”¶č”øč”¹č”ŗ\"],[\"d080\",\"č”»č”¼č¢€č¢ƒč¢†č¢‡č¢‰č¢Šč¢Œč¢Žč¢č¢č¢‘č¢“č¢”č¢•č¢—\",4,\"č¢\",4,\"č¢£č¢„\",5,\"å°å­ę ”č‚–å•øē¬‘ę•ˆę„”äŗ›ę­‡čŽéž‹åęŒŸęŗé‚Ŗę–œčƒč°å†™ę¢°åøčŸ¹ę‡ˆę³„ę³»č°¢å±‘č–ŖčŠÆé”Œę¬£č¾›ę–°åæ»åæƒäæ”č”…ę˜Ÿč…„ēŒ©ęƒŗå…“åˆ‘åž‹å½¢é‚¢č”Œé†’å¹øęę€§å§“å…„å‡¶čƒøåŒˆę±¹é›„ē†Šä¼‘äæ®ē¾žęœ½å—…锈ē§€č¢–ē»£å¢ŸęˆŒéœ€č™šå˜˜é”»å¾č®øč“„é…—å™ę—­åŗē•œę¤ēµ®å©æē»Ŗē»­č½©å–§å®£ę‚¬ę—‹ēŽ„\"],[\"d140\",\"č¢¬č¢®č¢Æč¢°č¢²\",4,\"č¢øč¢¹č¢ŗč¢»č¢½č¢¾č¢æč£€č£ƒč£„č£‡č£ˆč£Šč£‹č£Œč£č£č£č£‘č£“č£–č£—č£š\",4,\"č£ č£”č£¦č£§č£©\",6,\"č£²č£µč£¶č£·č£ŗč£»č£½č£æ褀褁褃\",5],[\"d180\",\"褉褋\",4,\"褑褔\",4,\"褜\",4,\"č¤¢č¤£č¤¤č¤¦č¤§č¤Ø褩褬褭褮č¤Æč¤±č¤²č¤³č¤µč¤·é€‰ē™£ēœ©ē»šé“č–›å­¦ē©“é›Ŗč”€å‹‹ē†å¾Ŗę—¬čÆ¢åÆ»é©Æå·”ę®‰ę±›č®­č®Æ逊čæ…åŽ‹ęŠ¼éø¦éø­å‘€äø«čŠ½ē‰™čšœå“–č”™ę¶Æ雅哑äŗšč®¶ē„‰å’½é˜‰ēƒŸę·¹ē›äø„ē ”čœ’å²©å»¶č؀颜阎ē‚Žę²æå„„ęŽ©ēœ¼č”ę¼”č‰³å °ē‡•åŽŒē šé›å”å½¦ē„°å®“谚éŖŒę®ƒå¤®éøÆē§§ęØꉬä½Æē–”ē¾Šę“‹é˜³ę°§ä»°ē—’å…»ę ·ę¼¾é‚€č…°å¦–ē‘¶\"],[\"d240\",\"č¤ø\",8,\"č„‚č„ƒč„…\",24,\"č„ \",5,\"脧\",19,\"č„¼\"],[\"d280\",\"č„½č„¾č¦€č¦‚č¦„č¦…č¦‡\",26,\"ę‘‡å°§é„ēŖ‘č°£å§šå’¬čˆ€čÆč¦č€€ę¤°å™Žč€¶ēˆ·é‡Žå†¶ä¹Ÿé”µęŽ–äøšå¶ę›³č…‹å¤œę¶²äø€å£¹åŒ»ę–é“±ä¾ä¼Šč”£é¢å¤·é—ē§»ä»Ŗ胰ē–‘ę²‚å®œå§Øå½ę¤…čšå€šå·²ä¹™ēŸ£ä»„č‰ŗęŠ‘ę˜“é‚‘å±¹äŗæå½¹č‡†é€ø肄ē–«äŗ¦č£”ę„ęƅåæ†ä¹‰ē›Šęŗ¢čÆ£č®®č°ŠčƑ异ēæ¼ēæŒē»ŽčŒµč«å› ę®·éŸ³é˜“å§»åŸé“¶ę·«åƅ鄮尹引隐\"],[\"d340\",\"č¦¢\",30,\"č§ƒč§č§“č§”č§•č§—č§˜č§™č§›č§č§Ÿč§ č§”č§¢č§¤č§§č§Ø觩č§Ŗč§¬č§­č§®č§°č§±č§²č§“\",6],[\"d380\",\"觻\",4,\"č؁\",5,\"č؈\",21,\"å°č‹±ęر婓鹰åŗ”ē¼ØčŽ¹č¤č„č§č‡čæŽčµ¢ē›ˆå½±é¢–ē”¬ę˜ å“Ÿę‹„ä½£č‡ƒē—ˆåŗø雍čøŠč›¹å’ę³³ę¶Œę°øęæ勇ē”Øå¹½ä¼˜ę‚ åæ§å°¤ē”±é‚®é“€ēŠ¹ę²¹ęøøé…‰ęœ‰å‹å³ä½‘é‡‰čƱ又幼čæ‚ę·¤äŗŽē›‚ę¦†č™žę„ščˆ†ä½™äæžé€¾é±¼ę„‰ęøęø”éš…äŗˆåرé›ØäøŽå±æē¦¹å®‡čÆ­ē¾½ēŽ‰åŸŸčŠ‹éƒåé‡å–»å³Ŗå¾”ę„ˆę¬²ē‹±č‚²čŖ‰\"],[\"d440\",\"č؞\",31,\"čØæ\",8,\"詉\",21],[\"d480\",\"č©Ÿ\",25,\"č©ŗ\",6,\"굓åÆ“č£•é¢„č±«é©­éø³ęøŠå†¤å…ƒåž£č¢åŽŸę“č¾•å›­å‘˜åœ†ēŒæęŗē¼˜čæœč‹‘ę„æę€Øé™¢ę›°ēŗ¦č¶Šč·ƒé’„å²³ē²¤ęœˆę‚¦é˜…č€˜äŗ‘郧匀é™Ø允čæč•“é…ę™•éŸµå­•åŒē øę‚ę ½å“‰ē¾å®°č½½å†åœØå’±ę”’ęš‚čµžčµƒč„č‘¬é­ē³Ÿå‡æč—»ęž£ę—©ę¾”čš¤čŗå™Ŗ造ēš‚ē¶ē‡„č“£ę‹©åˆ™ę³½č“¼ę€Žå¢žę†Žę›¾čµ ę‰Žå–³ęø£ęœ­č½§\"],[\"d540\",\"čŖ\",7,\"čŖ‹\",7,\"čŖ”\",46],[\"d580\",\"諃\",32,\"é“”é—øēœØꠅę¦Ø咋乍ē‚øčÆˆę‘˜ę–‹å®…ēŖ„å€ŗåÆØēž»ęÆ”č©¹ē²˜ę²¾ē›ę–©č¾—哭展č˜øę ˆå ęˆ˜ē«™ę¹›ē»½ę؟ē« å½°ę¼³å¼ ęŽŒę¶ØꝖäøˆåøč“¦ä»—čƒ€ē˜“éšœę‹›ę˜­ę‰¾ę²¼čµµē…§ē½©å…†č‚‡å¬é®ęŠ˜å“²č›°č¾™č€…é”—č”—čæ™ęµ™ēę–ŸēœŸē”„ē §č‡»č“žé’ˆä¾¦ęž•ē–¹čƊ震ęŒÆ镇阵č’øęŒ£ēå¾ē‹°äŗ‰ę€”ę•“ę‹Æę­£ę”æ\"],[\"d640\",\"諤\",34,\"謈\",27],[\"d680\",\"謤謄謧\",30,\"åø§ē—‡éƒ‘čÆčŠęžę”Æå±čœ˜ēŸ„č‚¢č„‚ę±ä¹‹ē»‡čŒē›“ę¤ę®–ę‰§å€¼ä¾„å€ęŒ‡ę­¢č¶¾åŖę—Øēŗøåæ—ęŒšęŽ·č‡³č‡“ē½®åøœå³™åˆ¶ę™ŗē§©ēؚč“Øē‚™ē—”ę»žę²»ēŖ’äø­ē›…åæ é’Ÿč”·ē»ˆē§č‚æé‡ä»²ä¼—čˆŸå‘Øå·žę“²čƌē²„č½“č‚˜åøšå’’ēš±å®™ę˜¼éŖ¤ē ę Ŗč››ęœ±ēŒŖčÆøčƛ逐ē«¹ēƒ›ē…®ę‹„ēž©å˜±äø»č‘—ęŸ±åŠ©č›€č“®é“øē­‘\"],[\"d740\",\"譆\",31,\"č­§\",4,\"č­­\",25],[\"d780\",\"讇\",24,\"讬讱讻čƇčƐčÆŖč°‰č°žä½ę³Øē„é©»ęŠ“ēˆŖę‹½äø“ē –č½¬ę’°čµšēÆ†ę”©åŗ„č£…å¦†ę’žå£®ēŠ¶ę¤Žé”„čæ½čµ˜å ē¼€č°†å‡†ę‰ę‹™å“ę”Œē¢čŒé…Œå•„ē€ē¼ęµŠå…¹å’Ø资å§æę»‹ę·„å­œē“«ä»”ē±½ę»“子č‡Ŗęøå­—é¬ƒę£•čøŖ宗ē»¼ę€»ēŗµé‚¹čµ°å„ęē§Ÿč¶³å’ę—ē„–čƅ阻ē»„é’»ēŗ‚嘓醉꜀ē½Ŗ尊遵ę˜Øå·¦ä½ęŸžåšä½œååŗ§\"],[\"d840\",\"č°ø\",8,\"č±‚č±ƒč±„č±…č±ˆč±Šč±‹č±\",7,\"č±–č±—č±˜č±™č±›\",5,\"č±£\",6,\"豬\",6,\"豓豵豶豷豻\",6,\"č²ƒč²„č²†č²‡\"],[\"d880\",\"č²ˆč²‹č²\",6,\"č²•č²–č²—č²™\",20,\"äŗäøŒå…€äøå»æ卅äø•äŗ˜äøžé¬²å­¬å™©äøØē¦ŗäøæ匕乇夭ēˆ»å®ę°å›Ÿčƒ¤é¦—ęƓē¾é¼—äø¶äŗŸé¼ä¹œä¹©äŗ“čŠˆå­›å•¬å˜ä»„åŽåŽåŽ£åŽ„åŽ®é„čµåŒšåµåŒ¦åŒ®åŒ¾čµœå¦å£åˆ‚åˆˆåˆŽåˆ­åˆ³åˆæ剀剌剞剔剜č’Æ剽劂劁劐劓冂ē½”äŗ»ä»ƒä»‰ä»‚ä»Ø仔仫仞伛仳伢佤仵伄伧伉伫佞佧ę”ø佚佝\"],[\"d940\",\"č²®\",62],[\"d980\",\"č³­\",32,\"佟佗伲伽佶体侑侉侃侏佾佻ä¾Ŗ佼侬侔äæ¦äæØäæŖäæ…äæšäæ£äæœäæ‘äæŸäæø倩偌äæ³å€¬å€å€®å€­äæ¾å€œå€Œå€„å€Ø偾偃偕偈偎偬偻傄傧傩å‚ŗåƒ–å„†åƒ­åƒ¬åƒ¦åƒ®å„‡å„‹ä»ę°½ä½˜ä½„äæŽé¾ ę±†ē±“兮巽黉馘冁夔勹匍č؇匐凫夙兕äŗ å…–äŗ³č”®č¢¤äŗµč„”č£’ē¦€å¬“蠃ē¾ø冫冱冽冼\"],[\"da40\",\"č“Ž\",14,\"č“ čµ‘čµ’čµ—čµŸčµ„čµØ赩čµŖ赬赮čµÆčµ±čµ²čµø\",8,\"č¶‚č¶ƒč¶†č¶‡č¶ˆč¶‰č¶Œ\",4,\"趒趓趕\",9,\"趠趔\"],[\"da80\",\"č¶¢č¶¤\",12,\"č¶²č¶¶č¶·č¶¹č¶»č¶½č·€č·č·‚č·…č·‡č·ˆč·‰č·Šč·č·č·’č·“č·”å‡‡å†–å†¢å†„č® č®¦č®§č®Ŗ讓讵讷čƂčƃčƋčƏčƎčƒčƓčƔčƖčƘčƙčƜčƟčÆ čƤčÆØčÆ©čÆ®čÆ°čƳčƶčƹčƼčÆæč°€č°‚č°„č°‡č°Œč°č°‘č°’č°”č°•č°–č°™č°›č°˜č°č°Ÿč° č°”č°„č°§č°Ŗč°«č°®č°Æč°²č°³č°µč°¶å©åŗ阝阢阔阱é˜Ŗ阽阼陂陉陔陟陧陬陲陓隈隍隗隰邗邛邝邙邬邔邓邳邶é‚ŗ\"],[\"db40\",\"č·•č·˜č·™č·œč· č·”č·¢č·„č·¦č·§č·©č·­č·®č·°č·±č·²č·“č·¶č·¼č·¾\",6,\"čø†čø‡čøˆčø‹čøčøŽčøčø‘čø’čø“čø•\",7,\"čø čø”čø¤\",4,\"čø«čø­čø°čø²čø³čø“čø¶čø·čøøčø»čø¼čø¾\"],[\"db80\",\"čøæč¹ƒč¹…č¹†č¹Œ\",4,\"č¹“\",5,\"č¹š\",11,\"č¹§č¹Øč¹Ŗč¹«č¹®č¹±é‚ø邰郏郅邾郐郄郇郓郦郢郜郗郛郫éƒÆ郾鄄鄢鄞鄣鄱é„Æ鄹酃酆刍儂劢劬劭劾å“æ勐勖勰叟ē‡®ēŸå»“凵凼é¬Æ厶弁ē•šå·Æ坌垩垔唾墼壅壑圩圬åœŖ圳圹圮åœÆ坜圻坂坩垅坫垆坼坻åØ坭坶坳垭垤垌垲埏垧垓垓垠埕埘埚埙埒åžø埓åŸÆåŸø埤埝\"],[\"dc40\",\"č¹³č¹µč¹·\",4,\"č¹½č¹¾čŗ€čŗ‚čŗƒčŗ„čŗ†čŗˆ\",6,\"čŗ‘čŗ’čŗ“čŗ•\",6,\"čŗčŗŸ\",11,\"čŗ­čŗ®čŗ°čŗ±čŗ³\",6,\"čŗ»\",7],[\"dc80\",\"軃\",10,\"č»\",21,\"堋堍埽埭堀堞堙唄堠唄唬墁墉墚墀é¦Ø鼙ę‡æč‰¹č‰½č‰æ芏芊čŠØ芄芎芑芗芙芫čŠøčŠ¾čŠ°č‹ˆč‹Šč‹£čŠ˜čŠ·čŠ®č‹‹č‹Œč‹čŠ©čŠ“čŠ”čŠŖčŠŸč‹„č‹ŽčŠ¤č‹”čŒ‰č‹·č‹¤čŒčŒ‡č‹œč‹“č‹’č‹˜čŒŒč‹»č‹“čŒ‘čŒščŒ†čŒ”čŒ•č‹ č‹•čŒœč‘č›čœčŒˆčŽ’čŒ¼čŒ“čŒ±čŽ›čžčŒÆ荏荇荃荟荀茗荠茭čŒŗčŒ³č¦č„\"],[\"dd40\",\"軄\",62],[\"dd80\",\"č¼¤\",32,\"čØčŒ›č©č¬čŖč­č®čŽ°čøčŽ³čŽ“čŽ čŽŖčŽ“čŽœčŽ…č¼čŽ¶čŽ©č½čŽøč»čŽ˜čŽžčŽØčŽŗčŽ¼ččč„č˜å ‡č˜č‹čč½č–čœčø萑萆菔菟萏萃čøč¹čŖč…č€č¦č°č”č‘œč‘‘č‘šč‘™č‘³č’‡č’ˆč‘ŗ蒉č‘øč¼č‘†č‘©č‘¶č’Œč’Žč±č‘­č“č“č“č“¦č’½č““č“Šč’æč’ŗč“ č’”č’¹č’“č’—č“„č“£č”Œē”č”øč“°č”¹č”Ÿč”ŗ\"],[\"de40\",\"č½…\",32,\"č½Ŗč¾€č¾Œč¾’č¾č¾ č¾”č¾¢č¾¤č¾„č¾¦č¾§č¾Ŗč¾¬č¾­č¾®č¾Æč¾²č¾³č¾“č¾µč¾·č¾øč¾ŗč¾»č¾¼č¾æčæ€čæƒčæ†\"],[\"de80\",\"čæ‰\",4,\"čæčæ’čæ–čæ—čæščæ čæ”čæ£čæ§čæ¬čæÆčæ±čæ²čæ“čæµčæ¶čæŗčæ»čæ¼čæ¾čææé€‡é€ˆé€Œé€Žé€“é€•é€˜č•–č”»č“æč“¼č•™č•ˆč•Ø蕤蕞č•ŗēž¢č•ƒč•²č•»č–¤č–Øč–‡č–č•¹č–®č–œč–…č–¹č–·č–°č—“č—č—œč—æč˜§č˜…č˜©č˜–č˜¼å»¾å¼ˆå¤¼å„č€·å„•å„šå„˜åŒå°¢å°„å°¬å°“ę‰Œę‰ŖęŠŸęŠ»ę‹Šę‹šę‹—ę‹®ęŒ¢ę‹¶ęŒ¹ę‹ęƒęŽ­ę¶ę±ęŗęŽŽęŽ“ę­ęŽ¬ęŽŠę©ęŽ®ęŽ¼ę²ęøꏠęæę„ęžęŽę‘’ę†ęŽ¾ę‘…ę‘ę‹ę›ę ęŒę¦ę”ę‘žę’„ę‘­ę’–\"],[\"df40\",\"這逜連逤逄逧\",5,\"逰\",4,\"逷逹é€ŗ逽é€æ遀遃遅遆遈\",4,\"過達違遖遙遚遜\",5,\"遤遦遧適éŖ遫遬éÆ\",4,\"遶\",6,\"遾邁\"],[\"df80\",\"還邅邆邇邉邊邌\",4,\"邒邔邖邘邚邜邞邟邠邤還邧é‚Ø邩邫邭邲邷邼邽é‚æ郀ę‘ŗę’·ę’ø꒙ę’ŗę“€ę“ę“—ę“¤ę“¢ę”‰ę”„ę”®å¼‹åæ’ē”™å¼‘卟叱叽叩åØ叻吒吖吆呋呒呓呔呖呃吔呗呙吣吲咂咔呷呱呤咚咛咄呶呦咝哐咭哂咓哒咧咦哓哔呲咣哕咻å’æ哌哙哚哜咩å’Ŗ咤哝哏哞唛哧唠哽唔哳唢唣唏唑唧å”Ŗ啧喏喵啉啭啁啕å”æ啐唼\"],[\"e040\",\"郂郃郆郈郉郋郌郍郒郔郕郖郘郙郚郞郟郠郣郤郄郩éƒŖ郬郮郰郱郲郳郵郶郷郹éƒŗ郻郼éƒæ鄀鄁鄃鄅\",19,\"鄚鄛鄜\"],[\"e080\",\"鄝鄟鄠鄔鄤\",10,\"鄰鄲\",6,\"é„ŗ\",8,\"酄唷啖啵啶啷唳唰啜喋嗒喃喱喹喈喁喟啾嗖喑啻嗟喽喾喔喙å—Ŗ嗷嗉嘟嗑嗫嗬嗔嗦嗝嗄å—Æ嗄嗲嗳嗌嗍å—Øå—µå—¤č¾”å˜žå˜ˆå˜Œå˜å˜¤å˜£å—¾å˜€å˜§å˜­å™˜å˜¹å™—å˜¬å™å™¢å™™å™œå™Œå™”åš†å™¤å™±å™«å™»å™¼åš…åš“åšÆ囔囗囝囔囵囫囹å›æ圄圊圉圜åøåø™åø”åø‘åø±åø»åø¼\"],[\"e140\",\"酅酇酈酑酓酔酕酖酘酙酛酜酟酠酦酧é…Ø酫酭酳é…ŗ酻酼醀\",4,\"醆醈醊醎醏醓\",6,\"醜\",5,\"醤\",5,\"醫醬醰醱醲醳醶醷é†ø醹醻\"],[\"e180\",\"醼\",10,\"釈釋釐釒\",9,\"針\",8,\"åø·å¹„幔幛幞幔岌å±ŗ岍岐岖岈岘岙岑岚岜岵岢岽岬岫岱岣峁岷峄峒峤峋峄哂哃哧哦哮哤哞哆哛嵘哾哓哽嵬嵛åµÆåµåµ«åµ‹åµŠåµ©åµ“å¶‚å¶™å¶č±³å¶·å·…å½³å½·å¾‚å¾‡å¾‰å¾Œå¾•å¾™å¾œå¾Øå¾­å¾µå¾¼č”¢å½”ēŠ­ēŠ°ēŠ“ēŠ·ēŠøē‹ƒē‹ē‹Žē‹ē‹’ē‹Øē‹Æē‹©ē‹²ē‹“ē‹·ēŒē‹³ēŒƒē‹ŗ\"],[\"e240\",\"釦\",62],[\"e280\",\"鈄\",32,\"ē‹»ēŒ—ēŒ“ēŒ”ēŒŠēŒžēŒēŒ•ēŒ¢ēŒ¹ēŒ„ēŒ¬ēŒøēŒ±ēēē—ē ē¬ēÆē¾čˆ›å¤„飧夤夂鄣鄧\",5,\"鄓鄷鄽馀馄馇馊馍馐馑馓馔馕åŗ€åŗ‘åŗ‹åŗ–åŗ„åŗ åŗ¹åŗµåŗ¾åŗ³čµ“廒廑廛å»Øå»Ŗč†ŗåæ„åæ‰åæ–åæę€ƒåæ®ę€„åæ”åæ¤åæ¾ę€…ꀆåæŖåæ­åæøę€™ę€µę€¦ę€›ę€ę€ę€©ę€«ę€Šę€æꀔęøę¹ę»ęŗꁂ\"],[\"e340\",\"鉆\",45,\"鉵\",16],[\"e380\",\"銆\",7,\"銏\",24,\"ęŖę½ę‚–ę‚šę‚­ę‚ę‚ƒę‚’ę‚Œę‚›ęƒ¬ę‚»ę‚±ęƒęƒ˜ęƒ†ęƒšę‚“ę„ ę„¦ę„•ę„£ęƒ“ę„€ę„Žę„«ę…Šę…µę†¬ę†”ę†§ę†·ę‡”ę‡µåæéš³é—©é—«é—±é—³é—µé—¶é—¼é—¾é˜ƒé˜„阆阈阊阋阌阍阏阒阕阖阗阙阚äø¬ēˆæęˆ•ę°µę±”ę±œę±Šę²£ę²…ę²ę²”ę²Œę±Øę±©ę±“ę±¶ę²†ę²©ę³ę³”ę²­ę³·ę³øę³±ę³—ę²²ę³ ę³–ę³ŗę³«ę³®ę²±ę³“ę³Æę³¾\"],[\"e440\",\"éŠØ\",5,\"éŠÆ\",24,\"鋉\",31],[\"e480\",\"鋩\",32,\"ę“¹ę“§ę“Œęµƒęµˆę“‡ę“„ę“™ę“Žę“«ęµę“®ę“µę“šęµęµ’ęµ”ę“³ę¶‘ęµÆę¶žę¶ ęµžę¶“ę¶”ęµœęµ ęµ¼ęµ£ęøšę·‡ę·…ę·žęøŽę¶æę· ęø‘ę·¦ę·ę·™ęø–궫ęøŒę¶®ęø«ę¹®ę¹Žę¹«ęŗ²ę¹Ÿęŗ†ę¹“ę¹”ęø²ęø„ę¹„ę»Ÿęŗ±ęŗ˜ę» ę¼­ę»¢ęŗ„ęŗ§ęŗ½ęŗ»ęŗ·ę»—ęŗ“ę»ęŗę»‚ęŗŸę½¢ę½†ę½‡ę¼¤ę¼•ę»¹ę¼Æę¼¶ę½‹ę½“ę¼Ŗę¼‰ę¼©ę¾‰ę¾ę¾Œę½øę½²ę½¼ę½ŗęæ‘\"],[\"e540\",\"錊\",51,\"éŒæ\",10],[\"e580\",\"鍊\",31,\"鍫ęæ‰ę¾§ę¾¹ę¾¶ęæ‚ęæ”ęæ®ęæžęæ ęæÆē€šē€£ē€›ē€¹ē€µēēžå®€å®„宕宓宄å®øē”ÆéŖžę“åƤåÆ®č¤°åÆ°č¹‡č¬‡č¾¶čæ“čæ•čæ„čæ®čæ¤čæ©čæ¦čæ³čæØ逅逄逋逦逑逍逖途逵逶逭é€Æ遄遑遒遐éØé˜é¢é›ęš¹é“é½é‚‚é‚ˆé‚ƒé‚‹å½å½—å½–å½˜å°»å’«å±å±™å­±å±£å±¦ē¾¼å¼Ŗå¼©å¼­č‰“å¼¼é¬»å±®å¦å¦ƒå¦å¦©å¦Ŗ妣\"],[\"e640\",\"鍬\",34,\"鎐\",27],[\"e680\",\"鎬\",29,\"鏋鏌鏍妗姊妫妞妤姒妲å¦Æ姗妾å؅å؆姝å؈姣姘姹å،å؉åزåØ“åؑåØ£åؓ婀婧婊婕åØ¼å©¢å©µčƒ¬åŖŖåŖ›å©·å©ŗåŖ¾å««åŖ²å«’å«”åŖø嫠嫣嫱嫖嫦嫘嫜嬉嬗嬖嬲嬷孀尕尜孚孄孳孑孓孢驵驷é©øé©ŗé©æ驽éŖ€éŖéŖ…éŖˆéŖŠéŖéŖ’éŖ“éŖ–éŖ˜éŖ›éŖœéŖéŖŸéŖ éŖ¢éŖ£éŖ„éŖ§ēŗŸēŗ”ēŗ£ēŗ„ēŗØēŗ©\"],[\"e740\",\"鏎\",7,\"鏗\",54],[\"e780\",\"鐎\",32,\"ēŗ­ēŗ°ēŗ¾ē»€ē»ē»‚ē»‰ē»‹ē»Œē»ē»”ē»—ē»›ē» ē»”ē»Øē»«ē»®ē»Æē»±ē»²ē¼ē»¶ē»ŗē»»ē»¾ē¼ē¼‚ē¼ƒē¼‡ē¼ˆē¼‹ē¼Œē¼ē¼‘ē¼’ē¼—ē¼™ē¼œē¼›ē¼Ÿē¼”\",6,\"ē¼Ŗē¼«ē¼¬ē¼­ē¼Æ\",4,\"ē¼µå¹ŗē•æ巛ē”¾é‚•ēŽŽēŽ‘ēŽ®ēŽ¢ēŽŸēē‚ē‘ēŽ·ēŽ³ē€ē‰ēˆē„ē™é”¼ēŠē©ē§ēžēŽŗē²ēēŖē‘›ē¦ē„ēØē°ē®ē¬\"],[\"e840\",\"éÆ\",14,\"éæ\",43,\"鑬鑭鑮é‘Æ\"],[\"e880\",\"鑰\",20,\"钑钖钘铇铏铓铔铚铦铻锜锠ē›ēšē‘ē‘œē‘—ē‘•ē‘™ē‘·ē‘­ē‘¾ē’œē’Žē’€ē’ē’‡ē’‹ē’žē’Øē’©ē’ē’§ē“’ē’ŗéŸŖéŸ«éŸ¬ęŒę“ęžęˆę©ęž„ęž‡ęŖę³ęž˜ęž§ęµęžØęžžęž­ęž‹ę·ę¼ęŸ°ę ‰ęŸ˜ę ŠęŸ©ęž°ę ŒęŸ™ęžµęŸšęž³ęŸę €ęŸƒęžøęŸ¢ę ŽęŸęŸ½ę ²ę ³ę” ę””ę”Žę”¢ę”„ę”¤ę¢ƒę ę”•ę”¦ę”ę”§ę”€ę ¾ę”Šę”‰ę ©ę¢µę¢ę”“ę”·ę¢“ę”«ę£‚ę„®ę£¼ę¤Ÿę¤ ę£¹\"],[\"e940\",\"锧锳锽镃镈镋镕镚镠镮镓镵長\",7,\"門\",42],[\"e980\",\"閫\",32,\"ę¤¤ę£°ę¤‹ę¤ę„—ę££ę¤ę„±ę¤¹ę„ ę„‚ę„ę¦„ę„«ę¦€ę¦˜ę„øę¤“ę§Œę¦‡ę¦ˆę§Žę¦‰ę„¦ę„£ę„¹ę¦›ę¦§ę¦»ę¦«ę¦­ę§”ę¦±ę§ę§Šę§Ÿę¦•ę§ ę¦ę§æęØÆꧭęؗęØ˜ę©„ę§²ę©„ęؾęŖ ę©ę©›ęصęŖŽę©¹ęؽęØØę©˜ę©¼ęŖ‘ęŖęŖ©ęŖ—ęŖ«ēŒ·ē’ę®ę®‚ę®‡ę®„ę®’ę®“ę®ę®šę®›ę®”ę®Ŗč½«č½­č½±č½²č½³č½µč½¶č½øč½·č½¹č½ŗč½¼č½¾č¾č¾‚č¾„č¾‡č¾‹\"],[\"ea40\",\"闌\",27,\"闬é—æ阇阓阘阛阞阠阣\",6,\"阫阬阭é˜Æ阰阷é˜ø阹é˜ŗ阾陁陃陊陎陏陑陒陓陖陗\"],[\"ea80\",\"陘陙陚陜陝陞陠陣附陦陫陭\",4,\"陳é™ø\",12,\"éš‡éš‰éšŠč¾č¾Žč¾č¾˜č¾šč»Žęˆ‹ęˆ—ęˆ›ęˆŸęˆ¢ęˆ”ęˆ„ęˆ¤ęˆ¬č‡§ē“Æē““ē“æē”ē”‘ē”“ꔓꗮę—Æę—°ę˜Šę˜™ę²ę˜ƒę˜•ę˜€ē‚…ę›·ę˜ę˜“ę˜±ę˜¶ę˜µč€†ę™Ÿę™”ę™ę™ę™–ę™”ę™—ę™·ęš„ęšŒęš§ęšęš¾ę››ę›œę›¦ę›©č“²č“³č“¶č“»č“½čµ€čµ…čµ†čµˆčµ‰čµ‡čµčµ•čµ™č§‡č§Šč§‹č§Œč§Žč§č§č§‘ē‰®ēŠŸē‰ē‰¦ē‰Æē‰¾ē‰æēŠ„ēŠ‹ēŠēŠēŠ’ęŒˆęŒ²ęŽ°\"],[\"eb40\",\"隌階隑隒隓隕隖隚際隝\",9,\"éšØ\",7,\"隱隲隓隵隷éšøéšŗ隻éšæ雂雃雈雊雋雐雑雓雔雖\",9,\"é›”\",6,\"雫\"],[\"eb80\",\"雬雭雮雰雱雲雓雵é›øé›ŗ電雼雽é›æ霂霃霅霊霋霌霐霑霒霔霕霗\",4,\"霝霟霠ęæꓘ耄ęÆŖęƳęƽęƵęÆ¹ę°…ę°‡ę°†ę°ę°•ę°˜ę°™ę°šę°”ę°©ę°¤ę°Ŗę°²ę”µę••ę•«ē‰ē‰’ē‰–ēˆ°č™¢åˆ–č‚Ÿč‚œč‚“č‚¼ęœŠč‚½č‚±č‚«č‚­č‚“č‚·čƒ§čƒØ胩čƒŖčƒ›čƒ‚čƒ„čƒ™čƒčƒ—ęœčƒčƒ«čƒ±čƒ“čƒ­č„č„Žčƒ²čƒ¼ęœ•č„’č±šč„¶č„žč„¬č„˜č„²č…ˆč…Œč…“č…“č…™č…šč…±č… č…©č…¼č…½č…­č…§å”åŖµč†ˆč†‚č†‘ę»•č†£č†Ŗč‡Œęœ¦č‡Šč†»\"],[\"ec40\",\"霔\",8,\"霫霬霮éœÆ霱霳\",4,\"éœŗ霻霼霽éœæ\",18,\"靔靕靗靘靚靜靝靟靣靤靦靧éØéŖ\",7],[\"ec80\",\"靲靵靷\",4,\"靽\",7,\"鞆\",4,\"鞌鞎鞏鞐鞓鞕鞖鞗鞙\",4,\"č‡č†¦ę¬¤ę¬·ę¬¹ę­ƒę­†ę­™é£‘é£’é£“é£•é£™é£šę®³å½€ęÆ‚č§³ę–é½‘ę–“ę–¼ę—†ę—„ę—ƒę—Œę—Žę—’ę—–ē‚€ē‚œē‚–ē‚ē‚»ēƒ€ē‚·ē‚«ē‚±ēƒØēƒŠē„ē„“ē„–ē„Æē„±ē…³ē…œē…Øē……ē…²ē…Šē…øē…ŗē†˜ē†³ē†µē†Øē† ē‡ ē‡”ē‡§ē‡¹ēˆēˆØē¬ē„˜ē…¦ē†¹ęˆ¾ęˆ½ę‰ƒę‰ˆę‰‰ē¤»ē„€ē„†ē„‰ē„›ē„œē„“ē„šē„¢ē„—ē„ ē„Æē„§ē„ŗē¦…ē¦Šē¦šē¦§ē¦³åæ‘åæ\"],[\"ed40\",\"鞞鞟鞔鞢鞤\",6,\"鞬鞮鞰鞱鞳鞵\",46],[\"ed80\",\"韤韄éŸØ韮\",4,\"韓韷\",23,\"ę€¼ęęšę§ęę™ę£ę‚«ę„†ę„ę…ę†©ę†ę‡‹ę‡‘ęˆ†č‚€čæę²“ę³¶ę·¼ēŸ¶ēŸøē €ē ‰ē —ē ˜ē ‘ę–«ē ­ē œē ē ¹ē ŗē »ē Ÿē ¼ē „ē ¬ē £ē ©ē”Žē”­ē”–ē”—ē ¦ē”ē”‡ē”Œē”Ŗē¢›ē¢“ē¢šē¢‡ē¢œē¢”ē¢£ē¢²ē¢¹ē¢„ē£”ē£™ē£‰ē£¬ē£²ē¤…ē£“ē¤“ē¤¤ē¤žē¤“龛黹黻黼ē›±ēœ„ēœē›¹ēœ‡ēœˆēœšēœ¢ēœ™ēœ­ēœ¦ēœµēœøēē‘ē‡ēƒēšēØ\"],[\"ee40\",\"頏\",62],[\"ee80\",\"锎\",32,\"ē¢ē„ēæēžē½ēž€ēžŒēž‘ēžŸēž ēž°ēžµēž½ē”ŗē•€ē•Žē•‹ē•ˆē•›ē•²ē•¹ē–ƒē½˜ē½”ē½Ÿč©ˆē½Øē½“ē½±ē½¹ē¾ē½¾ē›ē›„č ²é’…é’†é’‡é’‹é’Šé’Œé’é’é’é’”é’—é’•é’šé’›é’œé’£é’¤é’«é’Ŗ钭钬é’Æ钰钲钓钶\",4,\"钼钽é’æ铄铈\",6,\"铐铑铒铕铖铗铙铘铛铞铟铠铢铤铄铧é“Øé“Ŗ\"],[\"ef40\",\"é”Æ\",5,\"颋颎颒颕颙颣é¢Ø\",37,\"飏飐飔飖飗飛飜飝飠\",4],[\"ef80\",\"飄飦飩\",30,\"铩铫铮é“Æ铳铓铵铷铹铼铽é“æ锃锂锆锇锉锊锍锎锏锒\",4,\"锘锛锝锞锟锢é”Ŗ锫锩锬锱锲锓锶锷é”ø锼锾é”æ镂锵镄镅镆镉镌镎镏镒镓镔镖镗镘镙镛镞镟镝镔镢镤\",8,\"é•Æ镱镲镳é”ŗēŸ§ēŸ¬é›‰ē§•ē§­ē§£ē§«ē؆嵇ē؃ē؂ē؞ēؔ\"],[\"f040\",\"餈\",4,\"餎餏餑\",28,\"é¤Æ\",26],[\"f080\",\"é„Š\",9,\"é„–\",12,\"鄤鄦鄳é„ø鄹鄻鄾馂馃馉ēعēØ·ē©‘黏馄ē©°ēšˆēšŽēš“ēš™ēš¤ē“žē“ ē”¬éø éø¢éøØ\",4,\"éø²éø±éø¶éøøéø·éø¹éøŗéø¾é¹é¹‚鹄鹆鹇鹈鹉鹋鹌鹎鹑鹕鹗鹚鹛鹜鹞鹣鹦\",6,\"鹱鹭鹳ē–’ē–”ē––ē– ē–ē–¬ē–£ē–³ē–“ē–øē—„ē–±ē–°ē—ƒē—‚ē—–ē—ē—£ē—Øē—¦ē—¤ē—«ē—§ē˜ƒē—±ē—¼ē—æē˜ē˜€ē˜…ē˜Œē˜—ē˜Šē˜„ē˜˜ē˜•ē˜™\"],[\"f140\",\"馌馎馚\",10,\"馦馧馩\",47],[\"f180\",\"駙\",32,\"ē˜›ē˜¼ē˜¢ē˜ ē™€ē˜­ē˜°ē˜æē˜µē™ƒē˜¾ē˜³ē™ē™žē™”ē™œē™–ē™«ē™ÆēæŠē«¦ē©øē©¹ēŖ€ēŖ†ēŖˆēŖ•ēŖ¦ēŖ ēŖ¬ēŖØēŖ­ēŖ³č”¤č”©č”²č”½č”æč¢‚č¢¢č£†č¢·č¢¼č£‰č£¢č£Žč££č£„č£±č¤šč£¼č£Øč£¾č£°č¤”č¤™č¤“č¤›č¤Šč¤“č¤«č¤¶č„č„¦č„»ē–‹čƒ„ēš²ēš“ēŸœč€’č€”č€–č€œč€ č€¢č€„耦耧耩č€Øč€±č€‹č€µčƒč†čč’č©č±č¦ƒé”ø颀颃\"],[\"f240\",\"é§ŗ\",62],[\"f280\",\"éع\",32,\"é¢‰é¢Œé¢é¢é¢”é¢šé¢›é¢žé¢Ÿé¢”é¢¢é¢„é¢¦č™č™”č™¬č™®č™æč™ŗč™¼č™»čšØčščš‹čš¬čščš§čš£čšŖ蚓蚩蚶蛄蚵蛎蚰čšŗčš±čšÆč›‰č›čš“č›©č›±č›²č›­č›³č›čœ“č›žč›“č›Ÿč›˜č›‘čœƒčœ‡č›øčœˆčœŠčœčœ‰čœ£čœ»čœžčœ„čœ®čœščœ¾čˆčœ“čœ±čœ©čœ·čœæčž‚čœ¢č½č¾č»č č°čŒč®čž‹č“č£č¼č¤č™č„čž“čžÆčžØ蟒\"],[\"f340\",\"驚\",17,\"驲éŖƒéŖ‰éŖéŖŽéŖ”éŖ•éŖ™éŖ¦éŖ©\",6,\"éŖ²éŖ³éŖ“éŖµéŖ¹éŖ»éŖ½éŖ¾éŖæ髃髄髆\",4,\"髍髎髏髐髒體髕髖髗髙髚髛髜\"],[\"f380\",\"髝髞髠髢髣髤髄髧é«Øé«©é«Ŗ髬髮髰\",8,\"é«ŗ髼\",6,\"é¬„é¬…é¬†čŸ†čžˆčž…čž­čž—čžƒčž«čŸ„čž¬čžµčž³čŸ‹čŸ“čž½čŸ‘čŸ€čŸŠčŸ›čŸŖčŸ čŸ®č –č “čŸ¾č Šč ›č ”č ¹č ¼ē¼¶ē½‚ē½„ē½…čˆē«ŗē«½ē¬ˆē¬ƒē¬„ē¬•ē¬Šē¬«ē¬ē­‡ē¬øē¬Ŗē¬™ē¬®ē¬±ē¬ ē¬„ē¬¤ē¬³ē¬¾ē¬žē­˜ē­šē­…ē­µē­Œē­ē­ ē­®ē­»ē­¢ē­²ē­±ē®ē®¦ē®§ē®øē®¬ē®ē®Øē®…ē®Ŗē®œē®¢ē®«ē®“ēƑēƁēƌēƝēƚēÆ„ēƦēÆŖē°ŒēƾēƼē°ē°–ē°‹\"],[\"f440\",\"鬇鬉\",5,\"鬐鬑鬒鬔\",10,\"鬠鬔鬢鬤\",10,\"鬰鬱鬳\",7,\"鬽鬾é¬æ魀魆魊魋魌魎魐魒魓魕\",5],[\"f480\",\"魛\",32,\"ē°Ÿē°Ŗē°¦ē°øē±ē±€č‡¾čˆčˆ‚čˆ„č‡¬č”„čˆ”čˆ¢čˆ£čˆ­čˆÆčˆØ舫čˆøčˆ»čˆ³čˆ“čˆ¾č‰„č‰‰č‰‹č‰č‰šč‰Ÿč‰Øč”¾č¢…č¢ˆč£˜č£Ÿč„žē¾ē¾Ÿē¾§ē¾Æē¾°ē¾²ē±¼ę•‰ē²‘ē²ē²œē²žē²¢ē²²ē²¼ē²½ē³ē³‡ē³Œē³ē³ˆē³…ē³—ē³Ø艮ęšØē¾æēæŽēæ•ēæ„ēæ”ēæ¦ēæ©ēæ®ēæ³ē³øēµ·ē¶¦ē¶®ē¹‡ēŗ›éŗøéŗ“čµ³č¶„č¶”č¶‘č¶±čµ§čµ­č±‡č±‰é…Šé…é…Žé…é…¤\"],[\"f540\",\"é­¼\",62],[\"f580\",\"é®»\",32,\"酢酔酰酩é…Æ酽酾酲酓酹醌醅醐醍醑醢醣é†Ŗ醭醮é†Æ醵醓é†ŗč±•é¹¾č¶øč·«čø…č¹™č¹©č¶µč¶æč¶¼č¶ŗč·„č·–č·—č·šč·žč·Žč·č·›č·†č·¬č··č·øč·£č·¹č·»č·¤čø‰č·½čø”čøčøŸčø¬čø®čø£čøÆčøŗč¹€čø¹čøµčø½čø±č¹‰č¹č¹‚č¹‘č¹’č¹Šč¹°č¹¶č¹¼č¹Æč¹“čŗ…čŗčŗ”čŗčŗœčŗžč±øč²‚č²Šč²…č²˜č²”ę–›č§–č§žč§šč§œ\"],[\"f640\",\"éƜ\",62],[\"f680\",\"鰛\",32,\"规觫č§ÆčØ¾č¬¦é“é›©é›³é›Æ霆霁霈霏霎éœŖ霭霰霾龀龃龅\",5,\"龌黾鼋鼍隹隼隽雎雒ēžæ雠銎銮鋈錾éŖ鏊鎏鐾鑫é±æ鲂鲅鲆鲇鲈ēأ鲋鲎鲐鲑鲒鲔鲕鲚鲛鲞\",5,\"鲄\",4,\"鲫鲭鲮鲰\",7,\"é²ŗ鲻鲼鲽鳄鳅鳆鳇鳊鳋\"],[\"f740\",\"é°¼\",62],[\"f780\",\"鱻鱽鱾鲀鲃鲄鲉鲊鲌鲏鲓鲖鲗鲘鲙鲝é²Ŗ鲬é²Æ鲹鲾\",4,\"鳈鳉鳑鳒鳚鳛鳠鳔鳌\",4,\"鳓鳔鳕鳗鳘鳙鳜鳝鳟鳢靼鞅鞑鞒鞔éžÆ鞫鞣鞲鞓éŖ±éŖ°éŖ·é¹˜éŖ¶éŖŗéŖ¼é«é«€é«…髂髋髌髑魅魃魇魉魈魍魑é£Ø餍餮鄕鄔髟體髦é«Æ髫髻髭髹鬈鬏鬓鬟鬣éŗ½éŗ¾ēø»éŗ‚éŗ‡éŗˆéŗ‹éŗ’鏖éŗéŗŸé»›é»œé»é» é»Ÿé»¢é»©é»§é»„é»Ŗé»Æ鼢鼬é¼Æ鼹鼷鼽鼾齄\"],[\"f840\",\"é³£\",62],[\"f880\",\"é“¢\",32],[\"f940\",\"鵃\",62],[\"f980\",\"鶂\",32],[\"fa40\",\"鶣\",62],[\"fa80\",\"é·¢\",32],[\"fb40\",\"éøƒ\",27,\"éø¤éø§éø®éø°éø“éø»éø¼é¹€é¹é¹é¹’鹓鹔鹖鹙鹝鹟鹠鹔鹢鹄鹮é¹Æ鹲鹓\",9,\"éŗ€\"],[\"fb80\",\"éŗéŗƒéŗ„éŗ…éŗ†éŗ‰éŗŠéŗŒ\",5,\"éŗ”\",8,\"éŗžéŗ \",5,\"éŗ§éŗØéŗ©éŗŖ\"],[\"fc40\",\"éŗ«\",8,\"éŗµéŗ¶éŗ·éŗ¹éŗŗéŗ¼éŗæ\",4,\"黅黆黇黈黊黋黌黐黒黓黕黖黗黙黚點黔黣黤黦é»Ø黫黬黭黮黰\",8,\"é»ŗ黽é»æ\",6],[\"fc80\",\"鼆\",4,\"鼌鼏鼑鼒鼔鼕鼖鼘鼚\",5,\"鼔鼣\",8,\"鼭鼮鼰鼱\"],[\"fd40\",\"é¼²\",4,\"é¼øé¼ŗé¼¼é¼æ\",4,\"齅\",10,\"齒\",38],[\"fd80\",\"é½¹\",5,\"龁龂龍\",11,\"龜龝龞龔\",4,\"ļ¤¬ļ„¹ļ¦•ļ§§ļ§±\"],[\"fe40\",\"ļ،ļ؍ļ؎ļ؏ļؑļؓļؔļؘļ؟ļØ ļØ”ļØ£ļؤļاļØØļØ©\"]]"); + +/***/ }), + +/***/ 1333: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"0\",\"\\u0000\",127],[\"8141\",\"ź°‚ź°ƒź°…ź°†ź°‹\",4,\"ź°˜ź°žź°Ÿź°”ź°¢ź°£ź°„\",6,\"ź°®ź°²ź°³ź°“\"],[\"8161\",\"ź°µź°¶ź°·ź°ŗź°»ź°½ź°¾ź°æź±\",9,\"ź±Œź±Ž\",5,\"ź±•\"],[\"8181\",\"ź±–ź±—ź±™ź±šź±›ź±\",18,\"ź±²ź±³ź±µź±¶ź±¹ź±»\",4,\"ź²‚ź²‡ź²ˆź²ź²Žź²ź²‘ź²’ź²“ź²•\",6,\"ź²žź²¢\",5,\"ź²«ź²­ź²®ź²±\",6,\"ź²ŗź²¾ź²æź³€ź³‚ź³ƒź³…ź³†ź³‡ź³‰ź³Šź³‹ź³\",7,\"ź³–ź³˜\",7,\"ź³¢ź³£ź³„ź³¦ź³©ź³«ź³­ź³®ź³²ź³“ź³·\",4,\"ź³¾ź³æź“ź“‚ź“ƒź“…ź“‡\",4,\"ź“Žź“ź“’ź““\"],[\"8241\",\"ź“”ź“•ź“–ź“—ź“™ź“šź“›ź“ź“žź“Ÿź“”\",7,\"ź“Ŗź“«ź“®\",5],[\"8261\",\"ź“¶ź“·ź“¹ź“ŗź“»ź“½\",6,\"źµ†źµˆźµŠ\",5,\"źµ‘źµ’źµ“źµ•źµ–źµ—\"],[\"8281\",\"źµ™\",7,\"źµ¢źµ¤\",7,\"źµ®źµÆźµ±źµ²źµ·źµøźµ¹źµŗźµ¾ź¶€ź¶ƒ\",4,\"ź¶Šź¶‹ź¶ź¶Žź¶ź¶‘\",10,\"ź¶ž\",5,\"ź¶„\",17,\"ź¶ø\",7,\"ź·‚ź·ƒź·…ź·†ź·‡ź·‰\",6,\"ź·’ź·”\",7,\"ź·ź·žź·Ÿź·”ź·¢ź·£ź·„\",18],[\"8341\",\"ź·ŗź·»ź·½ź·¾źø‚\",5,\"źøŠźøŒźøŽ\",5,\"źø•\",7],[\"8361\",\"źø\",18,\"źø²źø³źøµźø¶źø¹źø»źø¼\"],[\"8381\",\"źø½źø¾źøæź¹‚ź¹„ź¹‡ź¹ˆź¹‰ź¹‹ź¹ź¹‘ź¹’ź¹“ź¹•ź¹—\",4,\"ź¹žź¹¢ź¹£ź¹¤ź¹¦ź¹§ź¹Ŗź¹«ź¹­ź¹®ź¹Æź¹±\",6,\"ź¹ŗź¹¾\",5,\"źŗ†\",5,\"źŗ\",46,\"źŗæź»ź»‚ź»ƒź»…\",6,\"ź»Žź»’\",5,\"ź»šź»›ź»\",8],[\"8441\",\"ź»¦ź»§ź»©ź»Ŗź»¬ź»®\",5,\"ź»µź»¶ź»·ź»¹ź»ŗź»»ź»½\",8],[\"8461\",\"ź¼†ź¼‰ź¼Šź¼‹ź¼Œź¼Žź¼ź¼‘\",18],[\"8481\",\"ź¼¤\",7,\"ź¼®ź¼Æź¼±ź¼³ź¼µ\",6,\"ź¼¾ź½€ź½„ź½…ź½†ź½‡ź½Š\",5,\"ź½‘\",10,\"ź½ž\",5,\"ź½¦\",18,\"ź½ŗ\",5,\"ź¾ź¾‚ź¾ƒź¾…ź¾†ź¾‡ź¾‰\",6,\"ź¾’ź¾“ź¾”ź¾–\",5,\"ź¾\",26,\"ź¾ŗź¾»ź¾½ź¾¾\"],[\"8541\",\"ź¾æźæ\",5,\"źæŠźæŒźæ\",4,\"źæ•\",6,\"źæ\",4],[\"8561\",\"źæ¢\",5,\"źæŖ\",5,\"źæ²źæ³źæµźæ¶źæ·źæ¹\",6,\"ė€‚ė€ƒ\"],[\"8581\",\"ė€…\",6,\"ė€ė€Žė€ė€‘ė€’ė€“ė€•\",6,\"ė€ž\",9,\"ė€©\",26,\"ė†ė‡ė‰ė‹ėėėė‘ė’ė–ė˜ėšė›ėœėž\",29,\"ė¾ėæė‚ė‚‚ė‚ƒė‚…\",6,\"ė‚Žė‚ė‚’\",5,\"ė‚›ė‚ė‚žė‚£ė‚¤\"],[\"8641\",\"ė‚„ė‚¦ė‚§ė‚Ŗė‚°ė‚²ė‚¶ė‚·ė‚¹ė‚ŗė‚»ė‚½\",6,\"ėƒ†ėƒŠ\",5,\"ėƒ’\"],[\"8661\",\"ėƒ“ėƒ•ėƒ–ėƒ—ėƒ™\",6,\"ėƒ”ėƒ¢ėƒ£ėƒ¤ėƒ¦\",10],[\"8681\",\"ėƒ±\",22,\"ė„Šė„ė„Žė„ė„‘ė„”ė„•ė„–ė„—ė„šė„ž\",4,\"ė„¦ė„§ė„©ė„Ŗė„«ė„­\",6,\"ė„¶ė„ŗ\",5,\"ė…‚ė…ƒė……ė…†ė…‡ė…‰\",6,\"ė…’ė…“ė…–ė…—ė…™ė…šė…›ė…ė…žė…Ÿė…”\",22,\"ė…ŗė…»ė…½ė…¾ė…æė†ė†ƒ\",4,\"ė†Šė†Œė†Žė†ė†ė†‘ė†•ė†–ė†—ė†™ė†šė†›ė†\"],[\"8741\",\"ė†ž\",9,\"ė†©\",15],[\"8761\",\"ė†¹\",18,\"ė‡ė‡Žė‡ė‡‘ė‡’ė‡“ė‡•\"],[\"8781\",\"ė‡–\",5,\"ė‡žė‡ \",7,\"ė‡Ŗė‡«ė‡­ė‡®ė‡Æė‡±\",7,\"ė‡ŗė‡¼ė‡¾\",5,\"ėˆ†ėˆ‡ėˆ‰ėˆŠėˆ\",6,\"ėˆ–ėˆ˜ėˆš\",5,\"ėˆ”\",18,\"ėˆµ\",6,\"ėˆ½\",26,\"ė‰™ė‰šė‰›ė‰ė‰žė‰Ÿė‰”\",6,\"ė‰Ŗ\",4],[\"8841\",\"ė‰Æ\",4,\"ė‰¶\",5,\"ė‰½\",6,\"ėŠ†ėŠ‡ėŠˆėŠŠ\",4],[\"8861\",\"ėŠėŠ’ėŠ“ėŠ•ėŠ–ėŠ—ėŠ›\",4,\"ėŠ¢ėŠ¤ėŠ§ėŠØėŠ©ėŠ«ėŠ­ėŠ®ėŠÆėŠ±ėŠ²ėŠ³ėŠµėŠ¶ėŠ·\"],[\"8881\",\"ėŠø\",15,\"ė‹Šė‹‹ė‹ė‹Žė‹ė‹‘ė‹“\",4,\"ė‹šė‹œė‹žė‹Ÿė‹ ė‹”ė‹£ė‹§ė‹©ė‹Ŗė‹°ė‹±ė‹²ė‹¶ė‹¼ė‹½ė‹¾ėŒ‚ėŒƒėŒ…ėŒ†ėŒ‡ėŒ‰\",6,\"ėŒ’ėŒ–\",5,\"ėŒ\",54,\"ė—ė™ėšėė ė”ė¢ė£\"],[\"8941\",\"ė¦ėØėŖė¬ė­ėÆė²ė³ėµė¶ė·ė¹\",6,\"ėŽ‚ėŽ†\",5,\"ėŽ\"],[\"8961\",\"ėŽŽėŽėŽ‘ėŽ’ėŽ“ėŽ•\",10,\"ėŽ¢\",5,\"ėŽ©ėŽŖėŽ«ėŽ­\"],[\"8981\",\"ėŽ®\",21,\"ė†ė‡ė‰ėŠėėė‘ė’ė“ė–ė˜ėšėœėžėŸė”ė¢ė£ė„ė¦ė§ė©\",18,\"ė½\",18,\"ė‘\",6,\"ė™ėšė›ėėžėŸė”\",6,\"ėŖė¬\",7,\"ėµ\",15],[\"8a41\",\"ė‘…\",10,\"ė‘’ė‘“ė‘•ė‘–ė‘—ė‘™\",6,\"ė‘¢ė‘¤ė‘¦\"],[\"8a61\",\"ė‘§\",4,\"ė‘­\",18,\"ė’ė’‚\"],[\"8a81\",\"ė’ƒ\",4,\"ė’‰\",19,\"ė’ž\",5,\"ė’„ė’¦ė’§ė’©ė’Ŗė’«ė’­\",7,\"ė’¶ė’øė’ŗ\",5,\"ė“ė“‚ė“ƒė“…ė“†ė“‡ė“‰\",6,\"ė“‘ė“’ė““ė“”ė“–\",5,\"ė“žė“Ÿė“”ė“¢ė“„ė“§\",4,\"ė“®ė“°ė“²\",5,\"ė“¹\",26,\"ė”–ė”—ė”™ė”šė”\"],[\"8b41\",\"ė”ž\",5,\"ė”¦ė”«\",4,\"ė”²ė”³ė”µė”¶ė”·ė”¹\",6,\"ė•‚ė•†\"],[\"8b61\",\"ė•‡ė•ˆė•‰ė•Šė•Žė•ė•‘ė•’ė•“ė••\",6,\"ė•žė•¢\",8],[\"8b81\",\"ė•«\",52,\"ė–¢ė–£ė–„ė–¦ė–§ė–©ė–¬ė–­ė–®ė–Æė–²ė–¶\",4,\"ė–¾ė–æė—ė—‚ė—ƒė—…\",6,\"ė—Žė—’\",5,\"ė—™\",18,\"ė—­\",18],[\"8c41\",\"ė˜€\",15,\"ė˜’ė˜“ė˜•ė˜–ė˜—ė˜™\",4],[\"8c61\",\"ė˜ž\",6,\"ė˜¦\",5,\"ė˜­\",6,\"ė˜µ\",5],[\"8c81\",\"ė˜»\",12,\"ė™‰\",26,\"ė™„ė™¦ė™§ė™©\",50,\"ėšžėšŸėš”ėš¢ėš£ėš„\",5,\"ėš­ėš®ėšÆėš°ėš²\",16],[\"8d41\",\"ė›ƒ\",16,\"ė›•\",8],[\"8d61\",\"ė›ž\",17,\"ė›±ė›²ė›³ė›µė›¶ė›·ė›¹ė›ŗ\"],[\"8d81\",\"ė›»\",4,\"ėœ‚ėœƒėœ„ėœ†\",33,\"ėœŖėœ«ėœ­ėœ®ėœ±\",6,\"ėœŗėœ¼\",7,\"ė…ė†ė‡ė‰ėŠė‹ė\",6,\"ė–\",9,\"ė”ė¢ė£ė„ė¦ė§ė©\",6,\"ė²ė“ė¶\",5,\"ė¾ėæėžėž‚ėžƒėž…\",6,\"ėžŽėž“ėž”ėž•ėžšėž›ėžėžž\"],[\"8e41\",\"ėžŸėž”\",6,\"ėžŖėž®\",5,\"ėž¶ėž·ėž¹\",8],[\"8e61\",\"ėŸ‚\",4,\"ėŸˆėŸŠ\",19],[\"8e81\",\"ėŸž\",13,\"ėŸ®ėŸÆėŸ±ėŸ²ėŸ³ėŸµ\",6,\"ėŸ¾ė ‚\",4,\"ė Šė ‹ė ė Žė ė ‘\",6,\"ė šė œė ž\",5,\"ė ¦ė §ė ©ė Ŗė «ė ­\",6,\"ė ¶ė ŗ\",5,\"ė”ė”‚ė”ƒė”…\",11,\"ė”’ė””\",7,\"ė”žė”Ÿė””ė”¢ė”£ė”„\",6,\"ė”®ė”°ė”²\",5,\"ė”¹ė”ŗė”»ė”½\",7],[\"8f41\",\"ė¢…\",7,\"ė¢Ž\",17],[\"8f61\",\"ė¢ \",7,\"ė¢©\",6,\"ė¢±ė¢²ė¢³ė¢µė¢¶ė¢·ė¢¹\",4],[\"8f81\",\"ė¢¾ė¢æė£‚ė£„ė£†\",5,\"ė£ė£Žė£ė£‘ė£’ė£“ė£•\",7,\"ė£žė£ ė£¢\",5,\"ė£Ŗė£«ė£­ė£®ė£Æė£±\",6,\"ė£ŗė£¼ė£¾\",5,\"ė¤…\",18,\"ė¤™\",6,\"ė¤”\",26,\"ė¤¾ė¤æė„ė„‚ė„ƒė„…\",6,\"ė„ė„Žė„ė„’\",5],[\"9041\",\"ė„šė„›ė„ė„žė„Ÿė„”\",6,\"ė„Ŗė„¬ė„®\",5,\"ė„¶ė„·ė„¹ė„ŗė„»ė„½\"],[\"9061\",\"ė„¾\",5,\"ė¦†ė¦ˆė¦‹ė¦Œė¦\",15],[\"9081\",\"ė¦Ÿ\",12,\"ė¦®ė¦Æė¦±ė¦²ė¦³ė¦µ\",6,\"ė¦¾ė§€ė§‚\",5,\"ė§Šė§‹ė§ė§“\",4,\"ė§šė§œė§Ÿė§ ė§¢ė§¦ė§§ė§©ė§Ŗė§«ė§­\",6,\"ė§¶ė§»\",4,\"ė؂\",5,\"ė؉\",11,\"ėؖ\",33,\"ėØŗėØ»ėؽėؾėØæė©ė©ƒė©„ė©…ė©†\"],[\"9141\",\"ė©‡ė©Šė©Œė©ė©ė©‘ė©’ė©–ė©—ė©™ė©šė©›ė©\",6,\"ė©¦ė©Ŗ\",5],[\"9161\",\"ė©²ė©³ė©µė©¶ė©·ė©¹\",9,\"ėŖ†ėŖˆėŖ‰ėŖŠėŖ‹ėŖ\",5],[\"9181\",\"ėŖ“\",20,\"ėŖŖėŖ­ėŖ®ėŖÆėŖ±ėŖ³\",4,\"ėŖŗėŖ¼ėŖ¾\",5,\"ė«…ė«†ė«‡ė«‰\",14,\"ė«š\",33,\"ė«½ė«¾ė«æė¬ė¬‚ė¬ƒė¬…\",7,\"ė¬Žė¬ė¬’\",5,\"ė¬™ė¬šė¬›ė¬ė¬žė¬Ÿė¬”\",6],[\"9241\",\"ė¬Øė¬Ŗė¬¬\",7,\"ė¬·ė¬¹ė¬ŗė¬æ\",4,\"ė­†ė­ˆė­Šė­‹ė­Œė­Žė­‘ė­’\"],[\"9261\",\"ė­“ė­•ė­–ė­—ė­™\",7,\"ė­¢ė­¤\",7,\"ė­­\",4],[\"9281\",\"ė­²\",21,\"ė®‰ė®Šė®‹ė®ė®Žė®ė®‘\",18,\"ė®„ė®¦ė®§ė®©ė®Ŗė®«ė®­\",6,\"ė®µė®¶ė®ø\",7,\"ėƁėƂėƃėƅėƆėƇėƉ\",6,\"ėƑėƒėƔ\",35,\"ėÆŗėÆ»ėƽėƾė°\"],[\"9341\",\"ė°ƒ\",4,\"ė°Šė°Žė°ė°’ė°“ė°™ė°šė° ė°”ė°¢ė°£ė°¦ė°Øė°Ŗė°«ė°¬ė°®ė°Æė°²ė°³ė°µ\"],[\"9361\",\"ė°¶ė°·ė°¹\",6,\"ė±‚ė±†ė±‡ė±ˆė±Šė±‹ė±Žė±ė±‘\",8],[\"9381\",\"ė±šė±›ė±œė±ž\",37,\"ė²†ė²‡ė²‰ė²Šė²ė²\",4,\"ė²–ė²˜ė²›\",4,\"ė²¢ė²£ė²„ė²¦ė²©\",6,\"ė²²ė²¶\",5,\"ė²¾ė²æė³ė³‚ė³ƒė³…\",7,\"ė³Žė³’ė³“ė³”ė³–ė³—ė³™ė³šė³›ė³\",22,\"ė³·ė³¹ė³ŗė³»ė³½\"],[\"9441\",\"ė³¾\",5,\"ė“†ė“ˆė“Š\",5,\"ė“‘ė“’ė““ė“•\",8],[\"9461\",\"ė“ž\",5,\"ė“„\",6,\"ė“­\",12],[\"9481\",\"ė“ŗ\",5,\"ėµ\",6,\"ėµŠėµ‹ėµėµŽėµėµ‘\",6,\"ėµš\",9,\"ėµ„ėµ¦ėµ§ėµ©\",22,\"ė¶‚ė¶ƒė¶…ė¶†ė¶‹\",4,\"ė¶’ė¶”ė¶–ė¶—ė¶˜ė¶›ė¶\",6,\"ė¶„\",10,\"ė¶±\",6,\"ė¶¹\",24],[\"9541\",\"ė·’ė·“ė·–ė·—ė·™ė·šė·›ė·\",11,\"ė·Ŗ\",5,\"ė·±\"],[\"9561\",\"ė·²ė·³ė·µė·¶ė··ė·¹\",6,\"ėøėø‚ėø„ėø†\",5,\"ėøŽėøėø‘ėø’ėø“\"],[\"9581\",\"ėø•\",6,\"ėøžėø \",35,\"ė¹†ė¹‡ė¹‰ė¹Šė¹‹ė¹ė¹\",4,\"ė¹–ė¹˜ė¹œė¹ė¹žė¹Ÿė¹¢ė¹£ė¹„ė¹¦ė¹§ė¹©ė¹«\",4,\"ė¹²ė¹¶\",4,\"ė¹¾ė¹æėŗėŗ‚ėŗƒėŗ…\",6,\"ėŗŽėŗ’\",5,\"ėŗš\",13,\"ėŗ©\",14],[\"9641\",\"ėŗø\",23,\"ė»’ė»“\"],[\"9661\",\"ė»•ė»–ė»™\",6,\"ė»”ė»¢ė»¦\",5,\"ė»­\",8],[\"9681\",\"ė»¶\",10,\"ė¼‚\",5,\"ė¼Š\",13,\"ė¼šė¼ž\",33,\"ė½‚ė½ƒė½…ė½†ė½‡ė½‰\",6,\"ė½’ė½“ė½”ė½–\",44],[\"9741\",\"ė¾ƒ\",16,\"ė¾•\",8],[\"9761\",\"ė¾ž\",17,\"ė¾±\",7],[\"9781\",\"ė¾¹\",11,\"ėæ†\",5,\"ėæŽėæėæ‘ėæ’ėæ“ėæ•\",6,\"ėæėæžėæ ėæ¢\",89,\"ģ€½ģ€¾ģ€æ\"],[\"9841\",\"ģ€\",16,\"ģ’\",5,\"ģ™ģšģ›\"],[\"9861\",\"ģģžģŸģ”\",6,\"ģŖ\",15],[\"9881\",\"ģŗ\",21,\"ģ‚’ģ‚“ģ‚•ģ‚–ģ‚—ģ‚™\",6,\"ģ‚¢ģ‚¤ģ‚¦\",5,\"ģ‚®ģ‚±ģ‚²ģ‚·\",4,\"ģ‚¾ģƒ‚ģƒƒģƒ„ģƒ†ģƒ‡ģƒŠģƒ‹ģƒģƒŽģƒģƒ‘\",6,\"ģƒšģƒž\",5,\"ģƒ¦ģƒ§ģƒ©ģƒŖģƒ«ģƒ­\",6,\"ģƒ¶ģƒøģƒŗ\",5,\"ģ„ģ„‚ģ„ƒģ„…ģ„†ģ„‡ģ„‰\",6,\"ģ„‘ģ„’ģ„“ģ„”ģ„–\",5,\"ģ„”ģ„¢ģ„„ģ„Øģ„©ģ„Ŗģ„«ģ„®\"],[\"9941\",\"ģ„²ģ„³ģ„“ģ„µģ„·ģ„ŗģ„»ģ„½ģ„¾ģ„æģ…\",6,\"ģ…Šģ…Ž\",5,\"ģ…–ģ…—\"],[\"9961\",\"ģ…™ģ…šģ…›ģ…\",6,\"ģ…¦ģ…Ŗ\",5,\"ģ…±ģ…²ģ…³ģ…µģ…¶ģ…·ģ…¹ģ…ŗģ…»\"],[\"9981\",\"ģ…¼\",8,\"ģ††\",5,\"ģ†ģ†‘ģ†’ģ†“ģ†•ģ†—\",4,\"ģ†žģ† ģ†¢ģ†£ģ†¤ģ†¦ģ†§ģ†Ŗģ†«ģ†­ģ†®ģ†Æģ†±\",11,\"ģ†¾\",5,\"ģ‡…ģ‡†ģ‡‡ģ‡‰ģ‡Šģ‡‹ģ‡\",6,\"ģ‡•ģ‡–ģ‡™\",6,\"ģ‡”ģ‡¢ģ‡£ģ‡„ģ‡¦ģ‡§ģ‡©\",6,\"ģ‡²ģ‡“\",7,\"ģ‡¾ģ‡æģˆģˆ‚ģˆƒģˆ…\",6,\"ģˆŽģˆģˆ’\",5,\"ģˆšģˆ›ģˆģˆžģˆ”ģˆ¢ģˆ£\"],[\"9a41\",\"ģˆ¤ģˆ„ģˆ¦ģˆ§ģˆŖģˆ¬ģˆ®ģˆ°ģˆ³ģˆµ\",16],[\"9a61\",\"ģ‰†ģ‰‡ģ‰‰\",6,\"ģ‰’ģ‰“ģ‰•ģ‰–ģ‰—ģ‰™\",6,\"ģ‰”ģ‰¢ģ‰£ģ‰¤ģ‰¦\"],[\"9a81\",\"ģ‰§\",4,\"ģ‰®ģ‰Æģ‰±ģ‰²ģ‰³ģ‰µ\",6,\"ģ‰¾ģŠ€ģŠ‚\",5,\"ģŠŠ\",5,\"ģŠ‘\",6,\"ģŠ™ģŠšģŠœģŠž\",5,\"ģŠ¦ģŠ§ģŠ©ģŠŖģŠ«ģŠ®\",5,\"ģŠ¶ģŠøģŠŗ\",33,\"ģ‹žģ‹Ÿģ‹”ģ‹¢ģ‹„\",5,\"ģ‹®ģ‹°ģ‹²ģ‹³ģ‹“ģ‹µģ‹·ģ‹ŗģ‹½ģ‹¾ģ‹æģŒ\",6,\"ģŒŠģŒ‹ģŒŽģŒ\"],[\"9b41\",\"ģŒģŒ‘ģŒ’ģŒ–ģŒ—ģŒ™ģŒšģŒ›ģŒ\",6,\"ģŒ¦ģŒ§ģŒŖ\",8],[\"9b61\",\"ģŒ³\",17,\"ģ†\",7],[\"9b81\",\"ģŽ\",25,\"ģŖģ«ģ­ģ®ģÆģ±ģ³\",4,\"ģŗģ»ģ¾\",5,\"ģŽ…ģŽ†ģŽ‡ģŽ‰ģŽŠģŽ‹ģŽ\",50,\"ģ\",22,\"ģš\"],[\"9c41\",\"ģ›ģģžģ”ģ£\",4,\"ģŖģ«ģ¬ģ®\",5,\"ģ¶ģ·ģ¹\",5],[\"9c61\",\"ģæ\",8,\"ģ‰\",6,\"ģ‘\",9],[\"9c81\",\"ģ›\",8,\"ģ„\",6,\"ģ­ģ®ģÆģ±ģ²ģ³ģµ\",6,\"ģ¾\",9,\"ģ‘‰\",26,\"ģ‘¦ģ‘§ģ‘©ģ‘Ŗģ‘«ģ‘­\",6,\"ģ‘¶ģ‘·ģ‘øģ‘ŗ\",5,\"ģ’\",18,\"ģ’•\",6,\"ģ’\",12],[\"9d41\",\"ģ’Ŗ\",13,\"ģ’¹ģ’ŗģ’»ģ’½\",8],[\"9d61\",\"ģ“†\",25],[\"9d81\",\"ģ“ \",8,\"ģ“Ŗ\",5,\"ģ“²ģ“³ģ“µģ“¶ģ“·ģ“¹ģ“»ģ“¼ģ“½ģ“¾ģ”‚\",9,\"ģ”ģ”Žģ”ģ”‘ģ”’ģ”“ģ”•\",6,\"ģ”\",10,\"ģ”Ŗģ”«ģ”­ģ”®ģ”Æģ”±\",6,\"ģ”ŗģ”¼ģ”¾\",5,\"ģ•†ģ•‡ģ•‹ģ•ģ•ģ•‘ģ•’ģ•–ģ•šģ•›ģ•œģ•Ÿģ•¢ģ•£ģ•„ģ•¦ģ•§ģ•©\",6,\"ģ•²ģ•¶\",5,\"ģ•¾ģ•æģ–ģ–‚ģ–ƒģ–…ģ–†ģ–ˆģ–‰ģ–Šģ–‹ģ–Žģ–ģ–’ģ–“ģ–”\"],[\"9e41\",\"ģ––ģ–™ģ–šģ–›ģ–ģ–žģ–Ÿģ–”\",7,\"ģ–Ŗ\",9,\"ģ–¶\"],[\"9e61\",\"ģ–·ģ–ŗģ–æ\",4,\"ģ—‹ģ—ģ—ģ—’ģ—“ģ—•ģ—–ģ——ģ—™\",6,\"ģ—¢ģ—¤ģ—¦ģ—§\"],[\"9e81\",\"ģ—Øģ—©ģ—Ŗģ—«ģ—Æģ—±ģ—²ģ—³ģ—µģ—øģ—¹ģ—ŗģ—»ģ˜‚ģ˜ƒģ˜„ģ˜‰ģ˜Šģ˜‹ģ˜ģ˜Žģ˜ģ˜‘\",6,\"ģ˜šģ˜\",6,\"ģ˜¦ģ˜§ģ˜©ģ˜Ŗģ˜«ģ˜Æģ˜±ģ˜²ģ˜¶ģ˜øģ˜ŗģ˜¼ģ˜½ģ˜¾ģ˜æģ™‚ģ™ƒģ™…ģ™†ģ™‡ģ™‰\",6,\"ģ™’ģ™–\",5,\"ģ™žģ™Ÿģ™”\",10,\"ģ™­ģ™®ģ™°ģ™²\",5,\"ģ™ŗģ™»ģ™½ģ™¾ģ™æģš\",6,\"ģšŠģšŒģšŽ\",5,\"ģš–ģš—ģš™ģššģš›ģš\",6,\"ģš¦\"],[\"9f41\",\"ģšØģšŖ\",5,\"ģš²ģš³ģšµģš¶ģš·ģš»\",4,\"ģ›‚ģ›„ģ›†\",5,\"ģ›Ž\"],[\"9f61\",\"ģ›ģ›‘ģ›’ģ›“ģ›•\",6,\"ģ›žģ›Ÿģ›¢\",5,\"ģ›Ŗģ›«ģ›­ģ›®ģ›Æģ›±ģ›²\"],[\"9f81\",\"ģ›³\",4,\"ģ›ŗģ›»ģ›¼ģ›¾\",5,\"ģœ†ģœ‡ģœ‰ģœŠģœ‹ģœ\",6,\"ģœ–ģœ˜ģœš\",5,\"ģœ¢ģœ£ģœ„ģœ¦ģœ§ģœ©\",6,\"ģœ²ģœ“ģœ¶ģœøģœ¹ģœŗģœ»ģœ¾ģœæģģ‚ģƒģ…\",4,\"ģ‹ģŽģģ™ģšģ›ģģžģŸģ”\",6,\"ģ©ģŖģ¬\",7,\"ģ¶ģ·ģ¹ģŗģ»ģæģž€ģžģž‚ģž†ģž‹ģžŒģžģžģž’ģž“ģž•ģž™ģž›\",4,\"ģž¢ģž§\",4,\"ģž®ģžÆģž±ģž²ģž³ģžµģž¶ģž·\"],[\"a041\",\"ģžøģž¹ģžŗģž»ģž¾ģŸ‚\",5,\"ģŸŠģŸ‹ģŸģŸģŸ‘\",6,\"ģŸ™ģŸšģŸ›ģŸœ\"],[\"a061\",\"ģŸž\",5,\"ģŸ„ģŸ¦ģŸ§ģŸ©ģŸŖģŸ«ģŸ­\",13],[\"a081\",\"ģŸ»\",4,\"ģ ‚ģ ƒģ …ģ †ģ ‡ģ ‰ģ ‹\",4,\"ģ ’ģ ”ģ —\",4,\"ģ žģ Ÿģ ”ģ ¢ģ £ģ „\",6,\"ģ ®ģ °ģ ²\",5,\"ģ ¹ģ ŗģ »ģ ½ģ ¾ģ æģ”\",6,\"ģ”Šģ”‹ģ”Ž\",5,\"ģ”•\",26,\"ģ”²ģ”³ģ”µģ”¶ģ”·ģ”¹ģ”»\",4,\"ģ¢‚ģ¢„ģ¢ˆģ¢‰ģ¢Šģ¢Ž\",5,\"ģ¢•\",7,\"ģ¢žģ¢ ģ¢¢ģ¢£ģ¢¤\"],[\"a141\",\"ģ¢„ģ¢¦ģ¢§ģ¢©\",18,\"ģ¢¾ģ¢æģ£€ģ£\"],[\"a161\",\"ģ£‚ģ£ƒģ£…ģ£†ģ£‡ģ£‰ģ£Šģ£‹ģ£\",6,\"ģ£–ģ£˜ģ£š\",5,\"ģ£¢ģ££ģ£„\"],[\"a181\",\"ģ£¦\",14,\"ģ£¶\",5,\"ģ£¾ģ£æģ¤ģ¤‚ģ¤ƒģ¤‡\",4,\"ģ¤Žć€€ć€ć€‚Ā·ā€„ā€¦ĀØ怃Ā­ā€•āˆ„ļ¼¼āˆ¼ā€˜ā€™ā€œā€ć€”ć€•ć€ˆ\",9,\"Ā±Ć—Ć·ā‰ ā‰¤ā‰„āˆžāˆ“Ā°ā€²ā€³ā„ƒā„«ļæ ļæ”ļæ„ā™‚ā™€āˆ āŠ„āŒ’āˆ‚āˆ‡ā‰”ā‰’Ā§ā€»ā˜†ā˜…ā—‹ā—ā—Žā—‡ā—†ā–”ā– ā–³ā–²ā–½ā–¼ā†’ā†ā†‘ā†“ā†”怓ā‰Ŗā‰«āˆšāˆ½āˆāˆµāˆ«āˆ¬āˆˆāˆ‹āŠ†āŠ‡āŠ‚āŠƒāˆŖāˆ©āˆ§āˆØļæ¢\"],[\"a241\",\"ģ¤ģ¤’\",5,\"ģ¤™\",18],[\"a261\",\"ģ¤­\",6,\"ģ¤µ\",18],[\"a281\",\"ģ„ˆ\",7,\"ģ„’ģ„“ģ„•ģ„–ģ„—ģ„™\",6,\"ģ„¢ģ„¤\",7,\"ģ„­ģ„®ģ„Æā‡’ā‡”āˆ€āˆƒĀ“ļ½žĖ‡Ė˜ĖĖšĖ™ĀøĖ›Ā”ĀæĖāˆ®āˆ‘āˆĀ¤ā„‰ā€°ā—ā—€ā–·ā–¶ā™¤ā™ ā™”ā™„ā™§ā™£āŠ™ā—ˆā–£ā—ā—‘ā–’ā–¤ā–„ā–Øā–§ā–¦ā–©ā™Øā˜ā˜Žā˜œā˜žĀ¶ā€ ā€”ā†•ā†—ā†™ā†–ā†˜ā™­ā™©ā™Ŗā™¬ć‰æ戜ā„–ć‡ā„¢ć‚ć˜ā„”ā‚¬Ā®\"],[\"a341\",\"ģ„±ģ„²ģ„³ģ„µ\",6,\"ģ„½\",10,\"ģ¦Šģ¦‹ģ¦ģ¦Žģ¦\"],[\"a361\",\"ģ¦‘\",6,\"ģ¦šģ¦œģ¦ž\",16],[\"a381\",\"ģ¦Æ\",16,\"ģ§‚ģ§ƒģ§…ģ§†ģ§‰ģ§‹\",4,\"ģ§’ģ§”ģ§—ģ§˜ģ§›ļ¼\",58,\"ļæ¦ļ¼½\",32,\"ļæ£\"],[\"a441\",\"ģ§žģ§Ÿģ§”ģ§£ģ§„ģ§¦ģ§Øģ§©ģ§Ŗģ§«ģ§®ģ§²\",5,\"ģ§ŗģ§»ģ§½ģ§¾ģ§æģ؁ģ؂ģ؃ģ؄\"],[\"a461\",\"ģ؅ģ؆ģ؇ģ؊ģ؎\",5,\"ģؕģؖģؗģؙ\",12],[\"a481\",\"ģئģاģØØģØŖ\",28,\"愱\",93],[\"a541\",\"ģ©‡\",4,\"ģ©Žģ©ģ©‘ģ©’ģ©“ģ©•\",6,\"ģ©žģ©¢\",5,\"ģ©©ģ©Ŗ\"],[\"a561\",\"ģ©«\",17,\"ģ©¾\",5,\"ģŖ…ģŖ†\"],[\"a581\",\"ģŖ‡\",16,\"ģŖ™\",14,\"ā…°\",9],[\"a5b0\",\"ā… \",9],[\"a5c1\",\"Ī‘\",16,\"Ī£\",6],[\"a5e1\",\"Ī±\",16,\"Ļƒ\",6],[\"a641\",\"ģŖØ\",19,\"ģŖ¾ģŖæģ«ģ«‚ģ«ƒģ«…\"],[\"a661\",\"ģ«†\",5,\"ģ«Žģ«ģ«’ģ«”ģ«•ģ«–ģ«—ģ«š\",5,\"ģ«”\",6],[\"a681\",\"ģ«Øģ«©ģ«Ŗģ««ģ«­\",6,\"ģ«µ\",18,\"ģ¬‰ģ¬Šā”€ā”‚ā”Œā”ā”˜ā””ā”œā”¬ā”¤ā”“ā”¼ā”ā”ƒā”ā”“ā”›ā”—ā”£ā”³ā”«ā”»ā•‹ā” ā”Æā”Øā”·ā”æā”ā”°ā”„ā”øā•‚ā”’ā”‘ā”šā”™ā”–ā”•ā”Žā”ā”žā”Ÿā””ā”¢ā”¦ā”§ā”©ā”Ŗā”­ā”®ā”±ā”²ā”µā”¶ā”¹ā”ŗā”½ā”¾ā•€ā•ā•ƒ\",7],[\"a741\",\"ģ¬‹\",4,\"ģ¬‘ģ¬’ģ¬“ģ¬•ģ¬–ģ¬—ģ¬™\",6,\"ģ¬¢\",7],[\"a761\",\"ģ¬Ŗ\",22,\"ģ­‚ģ­ƒģ­„\"],[\"a781\",\"ģ­…ģ­†ģ­‡ģ­Šģ­‹ģ­ģ­Žģ­ģ­‘\",6,\"ģ­šģ­›ģ­œģ­ž\",5,\"ģ­„\",7,\"掕掖掗ā„“ćŽ˜ć„ćŽ£ćŽ¤ćŽ„掦掙\",9,\"揊掍掎掏描授掉揈控ćŽØ掰\",9,\"掀\",4,\"ćŽŗ\",5,\"掐\",4,\"ā„¦ć€ććŽŠćŽ‹ćŽŒć–ć…ćŽ­ćŽ®ćŽÆć›ćŽ©ćŽŖćŽ«ćŽ¬ććć“ćƒć‰ćœć†\"],[\"a841\",\"ģ­­\",10,\"ģ­ŗ\",14],[\"a861\",\"ģ®‰\",18,\"ģ®\",6],[\"a881\",\"ģ®¤\",19,\"ģ®¹\",11,\"ƆƐĀŖĦ\"],[\"a8a6\",\"IJ\"],[\"a8a8\",\"ÄæÅĆ˜Å’ĀŗĆžÅ¦ÅŠ\"],[\"a8b1\",\"扠\",27,\"ā“\",25,\"ā‘ \",14,\"Ā½ā…“ā…”Ā¼Ā¾ā…›ā…œā…ā…ž\"],[\"a941\",\"ģƅ\",14,\"ģƕ\",10],[\"a961\",\"ģÆ ģÆ”ģÆ¢ģÆ£ģÆ„ģƦģÆØģÆŖ\",18],[\"a981\",\"ģƽ\",14,\"ģ°Žģ°ģ°‘ģ°’ģ°“ģ°•\",6,\"ģ°žģ°Ÿģ° ģ°£ģ°¤Ć¦Ä‘Ć°Ä§Ä±Ä³ÄøŀłĆøÅ“ĆŸĆ¾Å§Å‹Å‰ćˆ€\",27,\"ā’œ\",25,\"ā‘“\",14,\"Ā¹Ā²Ā³ā“āæā‚ā‚‚ā‚ƒā‚„\"],[\"aa41\",\"ģ°„ģ°¦ģ°Ŗģ°«ģ°­ģ°Æģ°±\",6,\"ģ°ŗģ°æ\",4,\"ģ±†ģ±‡ģ±‰ģ±Šģ±‹ģ±ģ±Ž\"],[\"aa61\",\"ģ±\",4,\"ģ±–ģ±š\",5,\"ģ±”ģ±¢ģ±£ģ±„ģ±§ģ±©\",6,\"ģ±±ģ±²\"],[\"aa81\",\"ģ±³ģ±“ģ±¶\",29,\"恁\",82],[\"ab41\",\"ģ²”ģ²•ģ²–ģ²—ģ²šģ²›ģ²ģ²žģ²Ÿģ²”\",6,\"ģ²Ŗģ²®\",5,\"ģ²¶ģ²·ģ²¹\"],[\"ab61\",\"ģ²ŗģ²»ģ²½\",6,\"ģ³†ģ³ˆģ³Š\",5,\"ģ³‘ģ³’ģ³“ģ³•\",5],[\"ab81\",\"ģ³›\",8,\"ģ³„\",6,\"ģ³­ģ³®ģ³Æģ³±\",12,\"ć‚”\",85],[\"ac41\",\"ģ³¾ģ³æģ“€ģ“‚\",5,\"ģ“Šģ“‹ģ“ģ“Žģ“ģ“‘\",6,\"ģ“šģ“œģ“žģ“Ÿģ“ \"],[\"ac61\",\"ģ“”ģ“¢ģ“£ģ“„ģ“¦ģ“§ģ“©ģ“Ŗģ“«ģ“­\",11,\"ģ“ŗ\",4],[\"ac81\",\"ģ“æ\",28,\"ģµģµžģµŸŠ\",5,\"ŠŠ–\",25],[\"acd1\",\"Š°\",5,\"ёŠ¶\",25],[\"ad41\",\"ģµ”ģµ¢ģµ£ģµ„\",6,\"ģµ®ģµ°ģµ²\",5,\"ģµ¹\",7],[\"ad61\",\"ģ¶\",6,\"ģ¶‰\",10,\"ģ¶–ģ¶—ģ¶™ģ¶šģ¶›ģ¶ģ¶žģ¶Ÿ\"],[\"ad81\",\"ģ¶ ģ¶”ģ¶¢ģ¶£ģ¶¦ģ¶Øģ¶Ŗ\",5,\"ģ¶±\",18,\"ģ·…\"],[\"ae41\",\"ģ·†\",5,\"ģ·ģ·Žģ·ģ·‘\",16],[\"ae61\",\"ģ·¢\",5,\"ģ·©ģ·Ŗģ·«ģ·­ģ·®ģ·Æģ·±\",6,\"ģ·ŗģ·¼ģ·¾\",4],[\"ae81\",\"ģøƒģø…ģø†ģø‡ģø‰ģøŠģø‹ģø\",6,\"ģø•ģø–ģø—ģø˜ģøš\",5,\"ģø¢ģø£ģø„ģø¦ģø§ģø©ģøŖģø«\"],[\"af41\",\"ģø¬ģø­ģø®ģøÆģø²ģø“ģø¶\",19],[\"af61\",\"ģ¹Š\",13,\"ģ¹šģ¹›ģ¹ģ¹žģ¹¢\",5,\"ģ¹Ŗģ¹¬\"],[\"af81\",\"ģ¹®\",5,\"ģ¹¶ģ¹·ģ¹¹ģ¹ŗģ¹»ģ¹½\",6,\"ģŗ†ģŗˆģŗŠ\",5,\"ģŗ’ģŗ“ģŗ•ģŗ–ģŗ—ģŗ™\"],[\"b041\",\"ģŗš\",5,\"ģŗ¢ģŗ¦\",5,\"ģŗ®\",12],[\"b061\",\"ģŗ»\",5,\"ģ»‚\",19],[\"b081\",\"ģ»–\",13,\"ģ»¦ģ»§ģ»©ģ»Ŗģ»­\",6,\"ģ»¶ģ»ŗ\",5,\"ź°€ź°ź°„ź°‡ź°ˆź°‰ź°Šź°\",7,\"ź°™\",4,\"ź° ź°¤ź°¬ź°­ź°Æź°°ź°±ź°øź°¹ź°¼ź±€ź±‹ź±ź±”ź±˜ź±œź±°ź±±ź±“ź±·ź±øź±ŗź²€ź²ź²ƒź²„ź²…ź²†ź²‰ź²Šź²‹ź²Œź²ź²”ź²œź²ź²Ÿź² ź²”ź²Øź²©ź²Ŗź²¬ź²Æź²°ź²øź²¹ź²»ź²¼ź²½ź³ź³„ź³ˆź³Œź³•ź³—ź³ ź³”ź³¤ź³§ź³Øź³Ŗź³¬ź³Æź³°ź³±ź³³ź³µź³¶ź³¼ź³½ź“€ź“„ź“†\"],[\"b141\",\"ģ¼‚ģ¼ƒģ¼…ģ¼†ģ¼‡ģ¼‰\",6,\"ģ¼’ģ¼”ģ¼–\",5,\"ģ¼ģ¼žģ¼Ÿģ¼”ģ¼¢ģ¼£\"],[\"b161\",\"ģ¼„\",6,\"ģ¼®ģ¼²\",5,\"ģ¼¹\",11],[\"b181\",\"ģ½…\",14,\"ģ½–ģ½—ģ½™ģ½šģ½›ģ½\",6,\"ģ½¦ģ½Øģ½Ŗģ½«ģ½¬ź“Œź“ź“ź“‘ź“˜ź“œź“ ź“©ź“¬ź“­ź““ź“µź“øź“¼źµ„źµ…źµ‡źµ‰źµźµ”źµ˜źµ”źµ£źµ¬źµ­źµ°źµ³źµ“źµµźµ¶źµ»źµ¼źµ½źµæź¶ź¶‚ź¶ˆź¶‰ź¶Œź¶ź¶œź¶ź¶¤ź¶·ź·€ź·ź·„ź·ˆź·ź·‘ź·“ź·œź· ź·¤ź·øź·¹ź·¼ź·æźø€źøźøˆźø‰źø‹źøźø”źø°źø±źø“źø·źøøźøŗź¹€ź¹ź¹ƒź¹…ź¹†ź¹Šź¹Œź¹ź¹Žź¹ź¹”ź¹–ź¹œź¹ź¹Ÿź¹ ź¹”ź¹„ź¹Øź¹©ź¹¬ź¹°ź¹ø\"],[\"b241\",\"ģ½­ģ½®ģ½Æģ½²ģ½³ģ½µģ½¶ģ½·ģ½¹\",6,\"ģ¾ģ¾‚ģ¾ƒģ¾„ģ¾†\",5,\"ģ¾\"],[\"b261\",\"ģ¾Ž\",18,\"ģ¾¢\",5,\"ģ¾©\"],[\"b281\",\"ģ¾Ŗ\",5,\"ģ¾±\",18,\"ģæ…\",6,\"ź¹¹ź¹»ź¹¼ź¹½źŗ„źŗ…źŗŒźŗ¼źŗ½źŗ¾ź»€ź»„ź»Œź»ź»ź»ź»‘ź»˜ź»™ź»œź»Øź»«ź»­ź»“ź»øź»¼ź¼‡ź¼ˆź¼ź¼ź¼¬ź¼­ź¼°ź¼²ź¼“ź¼¼ź¼½ź¼æź½ź½‚ź½ƒź½ˆź½‰ź½ź½œź½ź½¤ź½„ź½¹ź¾€ź¾„ź¾ˆź¾ź¾‘ź¾•ź¾œź¾øź¾¹ź¾¼źæ€źæ‡źæˆźæ‰źæ‹źæźæŽźæ”źæœźæØźæ©źæ°źæ±źæ“źæøė€€ė€ė€„ė€Œė€ė€”ė€œė€ė€Øė„ė…ėˆėŠėŒėŽė“ė”ė•ė—ė™\"],[\"b341\",\"ģæŒ\",19,\"ģæ¢ģæ£ģæ„ģæ¦ģæ§ģæ©\"],[\"b361\",\"ģæŖ\",5,\"ģæ²ģæ“ģæ¶\",5,\"ģæ½ģæ¾ģææķ€ķ€‚ķ€ƒķ€…\",5],[\"b381\",\"ķ€‹\",5,\"ķ€’\",5,\"ķ€™\",19,\"ėė¼ė½ė‚€ė‚„ė‚Œė‚ė‚ė‚‘ė‚˜ė‚™ė‚šė‚œė‚Ÿė‚ ė‚”ė‚¢ė‚Øė‚©ė‚«\",4,\"ė‚±ė‚³ė‚“ė‚µė‚øė‚¼ėƒ„ėƒ…ėƒ‡ėƒˆėƒ‰ėƒėƒ‘ėƒ”ėƒ˜ėƒ ėƒ„ė„ˆė„‰ė„‹ė„Œė„ė„’ė„“ė„˜ė„™ė„›ė„œė„ė„£ė„¤ė„„ė„Øė„¬ė„“ė„µė„·ė„øė„¹ė…€ė…ė…„ė…ˆė…ė…‘ė…”ė…•ė…˜ė…œė… ė…øė…¹ė…¼ė†€ė†‚ė†ˆė†‰ė†‹ė†ė†’ė†“ė†”ė†˜ė†œė†Øė‡Œė‡ė‡”ė‡œė‡\"],[\"b441\",\"ķ€®\",5,\"ķ€¶ķ€·ķ€¹ķ€ŗķ€»ķ€½\",6,\"ķ†ķˆķŠ\",5],[\"b461\",\"ķ‘ķ’ķ“ķ•ķ–ķ—ķ™\",6,\"ķ”\",10,\"ķ®ķÆ\"],[\"b481\",\"ķ±ķ²ķ³ķµ\",6,\"ķ¾ķæķ‚€ķ‚‚\",18,\"ė‡Ÿė‡Øė‡©ė‡¬ė‡°ė‡¹ė‡»ė‡½ėˆ„ėˆ…ėˆˆėˆ‹ėˆŒėˆ”ėˆ•ėˆ—ėˆ™ėˆ ėˆ“ėˆ¼ė‰˜ė‰œė‰ ė‰Øė‰©ė‰“ė‰µė‰¼ėŠ„ėŠ…ėŠ‰ėŠėŠ‘ėŠ”ėŠ˜ėŠ™ėŠšėŠ ėŠ”ėŠ£ėŠ„ėŠ¦ėŠŖėŠ¬ėŠ°ėŠ“ė‹ˆė‹‰ė‹Œė‹ė‹’ė‹˜ė‹™ė‹›ė‹ė‹¢ė‹¤ė‹„ė‹¦ė‹Øė‹«\",4,\"ė‹³ė‹“ė‹µė‹·\",4,\"ė‹æėŒ€ėŒėŒ„ėŒˆėŒėŒ‘ėŒ“ėŒ”ėŒ•ėŒœė”ė•ė–ė˜ė›ėœėžėŸė¤ė„\"],[\"b541\",\"ķ‚•\",14,\"ķ‚¦ķ‚§ķ‚©ķ‚Ŗķ‚«ķ‚­\",5],[\"b561\",\"ķ‚³ķ‚¶ķ‚øķ‚ŗ\",5,\"ķƒ‚ķƒƒķƒ…ķƒ†ķƒ‡ķƒŠ\",5,\"ķƒ’ķƒ–\",4],[\"b581\",\"ķƒ›ķƒžķƒŸķƒ”ķƒ¢ķƒ£ķƒ„\",6,\"ķƒ®ķƒ²\",5,\"ķƒ¹\",11,\"ė§ė©ė«ė®ė°ė±ė“ėøėŽ€ėŽėŽƒėŽ„ėŽ…ėŽŒėŽėŽ”ėŽ ėŽ”ėŽØėŽ¬ė„ė…ėˆė‹ėŒėŽėė”ė•ė—ė™ė›ėė ė¤ėØė¼ėė˜ėœė ėØė©ė«ė“ė‘ė‘‘ė‘”ė‘˜ė‘ ė‘”ė‘£ė‘„ė‘¬ė’€ė’ˆė’ė’¤ė’Øė’¬ė’µė’·ė’¹ė“€ė“„ė“ˆė“ė“•ė“œė“ė“ ė“£ė“¤ė“¦ė“¬ė“­ė“Æė“±ė“øė””ė”•ė”˜ė”›ė”œė”¤ė”„ė”§ė”Øė”©ė”Ŗė”°ė”±ė”“ė”ø\"],[\"b641\",\"ķ„…\",7,\"ķ„Ž\",17],[\"b661\",\"ķ„ \",15,\"ķ„²ķ„³ķ„µķ„¶ķ„·ķ„¹ķ„»ķ„¼ķ„½ķ„¾\"],[\"b681\",\"ķ„æķ…‚ķ…†\",5,\"ķ…Žķ…ķ…‘ķ…’ķ…“ķ…•\",6,\"ķ…žķ… ķ…¢\",5,\"ķ…©ķ…Ŗķ…«ķ…­ė•€ė•ė•ƒė•„ė•…ė•‹ė•Œė•ė•ė•”ė•œė•ė•Ÿė• ė•”ė– ė–”ė–¤ė–Øė–Ŗė–«ė–°ė–±ė–³ė–“ė–µė–»ė–¼ė–½ė—€ė—„ė—Œė—ė—ė—ė—‘ė—˜ė—¬ė˜ė˜‘ė˜”ė˜˜ė˜„ė˜¬ė˜“ė™ˆė™¤ė™Øėšœėšėš ėš¤ėš«ėš¬ėš±ė›”ė›°ė›“ė›øėœ€ėœėœ…ėœØėœ©ėœ¬ėœÆėœ°ėœøėœ¹ėœ»ė„ėˆėŒė”ė•ė ė¤ėØė°ė±ė³ėµė¼ė½ėž€ėž„ėžŒėžėžėžėž‘ėž’ėž–ėž—\"],[\"b741\",\"ķ…®\",13,\"ķ…½\",6,\"ķ†…ķ††ķ†‡ķ†‰ķ†Š\"],[\"b761\",\"ķ†‹\",20,\"ķ†¢ķ†£ķ†„ķ†¦ķ†§\"],[\"b781\",\"ķ†©\",6,\"ķ†²ķ†“ķ†¶ķ†·ķ†øķ†¹ķ†»ķ†½ķ†¾ķ†æķ‡\",14,\"ėž˜ėž™ėžœėž ėžØėž©ėž«ėž¬ėž­ėž“ėžµėžøėŸ‡ėŸ‰ėŸ¬ėŸ­ėŸ°ėŸ“ėŸ¼ėŸ½ėŸæė €ė ė ‡ė ˆė ‰ė Œė ė ˜ė ™ė ›ė ė ¤ė „ė Øė ¬ė “ė µė ·ė øė ¹ė”€ė”„ė”‘ė”“ė”œė”ė” ė”¤ė”¬ė”­ė”Æė”±ė”øė”¼ė¢ė¢Øė¢°ė¢“ė¢øė£€ė£ė£ƒė£…ė£Œė£ė£”ė£ė£Ÿė£”ė£Øė£©ė£¬ė£°ė£øė£¹ė£»ė£½ė¤„ė¤˜ė¤ ė¤¼ė¤½ė„€ė„„ė„Œė„ė„‘ė„˜ė„™ė„œė„ ė„Øė„©\"],[\"b841\",\"ķ‡\",7,\"ķ‡™\",17],[\"b861\",\"ķ‡«\",8,\"ķ‡µķ‡¶ķ‡·ķ‡¹\",13],[\"b881\",\"ķˆˆķˆŠ\",5,\"ķˆ‘\",24,\"ė„«ė„­ė„“ė„µė„øė„¼ė¦„ė¦…ė¦‡ė¦‰ė¦Šė¦ė¦Žė¦¬ė¦­ė¦°ė¦“ė¦¼ė¦½ė¦æė§ė§ˆė§‰ė§Œė§Ž\",4,\"ė§˜ė§™ė§›ė§ė§žė§”ė§£ė§¤ė§„ė§Øė§¬ė§“ė§µė§·ė§øė§¹ė§ŗė؀ė؁ė؈ėؕėØøėعėؼė©€ė©‚ė©ˆė©‰ė©‹ė©ė©Žė©“ė©”ė©•ė©˜ė©œė©¤ė©„ė©§ė©Øė©©ė©°ė©±ė©“ė©øėŖƒėŖ„ėŖ…ėŖ‡ėŖŒėŖØėŖ©ėŖ«ėŖ¬ėŖ°ėŖ²ėŖøėŖ¹ėŖ»ėŖ½ė«„ė«ˆė«˜ė«™ė«¼\"],[\"b941\",\"ķˆŖķˆ«ķˆ®ķˆÆķˆ±ķˆ²ķˆ³ķˆµ\",6,\"ķˆ¾ķ‰€ķ‰‚\",5,\"ķ‰‰ķ‰Šķ‰‹ķ‰Œ\"],[\"b961\",\"ķ‰\",14,\"ķ‰\",6,\"ķ‰„ķ‰¦ķ‰§ķ‰Ø\"],[\"b981\",\"ķ‰©\",22,\"ķŠ‚ķŠƒķŠ…ķŠ†ķŠ‡ķŠ‰ķŠŠķŠ‹ķŠŒė¬€ė¬„ė¬ė¬ė¬‘ė¬˜ė¬œė¬ ė¬©ė¬«ė¬“ė¬µė¬¶ė¬øė¬»ė¬¼ė¬½ė¬¾ė­„ė­…ė­‡ė­‰ė­ė­ė­ė­”ė­˜ė­”ė­£ė­¬ė®ˆė®Œė®ė®¤ė®Øė®¬ė®“ė®·ėƀėƄėƈėƐėƓėÆøėƹėƼėÆæė°€ė°‚ė°ˆė°‰ė°‹ė°Œė°ė°ė°‘ė°”\",4,\"ė°›\",4,\"ė°¤ė°„ė°§ė°©ė°­ė°°ė°±ė°“ė°øė±€ė±ė±ƒė±„ė±…ė±‰ė±Œė±ė±ė±ė²„ė²…ė²ˆė²‹ė²Œė²Žė²”ė²•ė²—\"],[\"ba41\",\"ķŠķŠŽķŠķŠ’ķŠ“ķŠ”ķŠ–\",5,\"ķŠķŠžķŠŸķŠ”ķŠ¢ķŠ£ķŠ„\",6,\"ķŠ­\"],[\"ba61\",\"ķŠ®ķŠÆķŠ°ķŠ²\",5,\"ķŠŗķŠ»ķŠ½ķŠ¾ķ‹ķ‹ƒ\",4,\"ķ‹Šķ‹Œ\",5],[\"ba81\",\"ķ‹’ķ‹“ķ‹•ķ‹–ķ‹—ķ‹™ķ‹šķ‹›ķ‹\",6,\"ķ‹¦\",9,\"ķ‹²ķ‹³ķ‹µķ‹¶ķ‹·ķ‹¹ķ‹ŗė²™ė²šė² ė²”ė²¤ė²§ė²Øė²°ė²±ė²³ė²“ė²µė²¼ė²½ė³€ė³„ė³ė³ė³ė³‘ė³•ė³˜ė³œė³“ė³µė³¶ė³øė³¼ė“„ė“…ė“‡ė“‰ė“ė“”ė“¤ė“¬ėµ€ėµˆėµ‰ėµŒėµėµ˜ėµ™ėµ¤ėµØė¶€ė¶ė¶„ė¶‡ė¶ˆė¶‰ė¶Šė¶ė¶‘ė¶“ė¶•ė¶™ė¶šė¶œė¶¤ė¶°ė¶øė·”ė·•ė·˜ė·œė·©ė·°ė·“ė·øėø€ėøƒėø…ėøŒėøėøėø”ėøœėøėøŸė¹„ė¹…ė¹ˆė¹Œė¹Žė¹”ė¹•ė¹—ė¹™ė¹šė¹›ė¹ ė¹”ė¹¤\"],[\"bb41\",\"ķ‹»\",4,\"ķŒ‚ķŒ„ķŒ†\",5,\"ķŒķŒ‘ķŒ’ķŒ“ķŒ•ķŒ—\",4,\"ķŒžķŒ¢ķŒ£\"],[\"bb61\",\"ķŒ¤ķŒ¦ķŒ§ķŒŖķŒ«ķŒ­ķŒ®ķŒÆķŒ±\",6,\"ķŒŗķŒ¾\",5,\"ķ†ķ‡ķˆķ‰\"],[\"bb81\",\"ķŠ\",31,\"ė¹Øė¹Ŗė¹°ė¹±ė¹³ė¹“ė¹µė¹»ė¹¼ė¹½ėŗ€ėŗ„ėŗŒėŗėŗėŗėŗ‘ėŗ˜ėŗ™ėŗØė»ė»‘ė»”ė»—ė»˜ė» ė»£ė»¤ė»„ė»¬ė¼ė¼ˆė¼‰ė¼˜ė¼™ė¼›ė¼œė¼ė½€ė½ė½„ė½ˆė½ė½‘ė½•ė¾”ė¾°ėæ…ėæŒėæėæėæ”ėæœėæŸėæ”ģ€¼ģ‘ģ˜ģœģ ģØģ©ģ‚ģ‚‘ģ‚”ģ‚˜ģ‚ ģ‚”ģ‚£ģ‚„ģ‚¬ģ‚­ģ‚Æģ‚°ģ‚³ģ‚“ģ‚µģ‚¶ģ‚¼ģ‚½ģ‚æģƒ€ģƒģƒ…ģƒˆģƒ‰ģƒŒģƒģƒ˜ģƒ™ģƒ›ģƒœģƒģƒ¤\"],[\"bc41\",\"ķŖ\",17,\"ķ¾ķæķŽķŽ‚ķŽƒķŽ…ķŽ†ķŽ‡\"],[\"bc61\",\"ķŽˆķŽ‰ķŽŠķŽ‹ķŽŽķŽ’\",5,\"ķŽšķŽ›ķŽķŽžķŽŸķŽ”\",6,\"ķŽŖķŽ¬ķŽ®\"],[\"bc81\",\"ķŽÆ\",4,\"ķŽµķŽ¶ķŽ·ķŽ¹ķŽŗķŽ»ķŽ½\",6,\"ķ†ķ‡ķŠ\",5,\"ķ‘\",5,\"ģƒ„ģƒØģƒ¬ģƒ“ģƒµģƒ·ģƒ¹ģ„€ģ„„ģ„ˆģ„ģ„•ģ„œ\",4,\"ģ„£ģ„¤ģ„¦ģ„§ģ„¬ģ„­ģ„Æģ„°ģ„±ģ„¶ģ„øģ„¹ģ„¼ģ…€ģ…ˆģ…‰ģ…‹ģ…Œģ…ģ…”ģ…•ģ…˜ģ…œģ…¤ģ…„ģ…§ģ…Øģ…©ģ…°ģ…“ģ…øģ†…ģ†Œģ†ģ†Žģ†ģ†”ģ†–ģ†œģ†ģ†Ÿģ†”ģ†„ģ†Øģ†©ģ†¬ģ†°ģ†½ģ‡„ģ‡ˆģ‡Œģ‡”ģ‡—ģ‡˜ģ‡ ģ‡¤ģ‡Øģ‡°ģ‡±ģ‡³ģ‡¼ģ‡½ģˆ€ģˆ„ģˆŒģˆģˆģˆ‘ģˆ˜ģˆ™ģˆœģˆŸģˆ ģˆØģˆ©ģˆ«ģˆ­\"],[\"bd41\",\"ķ—ķ™\",7,\"ķ¢ķ¤\",7,\"ķ®ķÆķ±ķ²ķ³ķµķ¶ķ·\"],[\"bd61\",\"ķøķ¹ķŗķ»ķ¾ķ€ķ‚\",5,\"ķ‰\",13],[\"bd81\",\"ķ—\",5,\"ķž\",25,\"ģˆÆģˆ±ģˆ²ģˆ“ģ‰ˆģ‰ģ‰‘ģ‰”ģ‰˜ģ‰ ģ‰„ģ‰¬ģ‰­ģ‰°ģ‰“ģ‰¼ģ‰½ģ‰æģŠģŠˆģŠ‰ģŠģŠ˜ģŠ›ģŠģŠ¤ģŠ„ģŠØģŠ¬ģŠ­ģŠ“ģŠµģŠ·ģŠ¹ģ‹œģ‹ģ‹ ģ‹£ģ‹¤ģ‹«ģ‹¬ģ‹­ģ‹Æģ‹±ģ‹¶ģ‹øģ‹¹ģ‹»ģ‹¼ģŒ€ģŒˆģŒ‰ģŒŒģŒģŒ“ģŒ”ģŒ•ģŒ˜ģŒœģŒ¤ģŒ„ģŒØģŒ©ģ…ģØģ©ģ¬ģ°ģ²ģøģ¹ģ¼ģ½ģŽ„ģŽˆģŽŒģ€ģ˜ģ™ģœģŸģ ģ¢ģØģ©ģ­ģ“ģµģøģˆģģ¤ģ¬ģ°\"],[\"be41\",\"ķø\",7,\"ķ‘ķ‘‚ķ‘ƒķ‘…\",14],[\"be61\",\"ķ‘”\",7,\"ķ‘ķ‘žķ‘Ÿķ‘”ķ‘¢ķ‘£ķ‘„\",7,\"ķ‘®ķ‘°ķ‘±ķ‘²\"],[\"be81\",\"ķ‘³\",4,\"ķ‘ŗķ‘»ķ‘½ķ‘¾ķ’ķ’ƒ\",4,\"ķ’Šķ’Œķ’Ž\",5,\"ķ’•\",8,\"ģ“ģ¼ģ½ģ‘ˆģ‘¤ģ‘„ģ‘Øģ‘¬ģ‘“ģ‘µģ‘¹ģ’€ģ’”ģ’œģ’øģ’¼ģ“©ģ“°ģ“±ģ““ģ“øģ“ŗģ“æģ”€ģ”ģ”Œģ”ģ””ģ”œģ”Øģ”©ģ”¬ģ”°ģ”øģ”¹ģ”»ģ”½ģ•„ģ•…ģ•ˆģ•‰ģ•Šģ•Œģ•ģ•Žģ•“ģ•”ģ••ģ•—ģ•˜ģ•™ģ•ģ•žģ• ģ•”ģ•¤ģ•Øģ•°ģ•±ģ•³ģ•“ģ•µģ•¼ģ•½ģ–€ģ–„ģ–‡ģ–Œģ–ģ–ģ–‘ģ–•ģ–—ģ–˜ģ–œģ– ģ–©ģ–“ģ–µģ–øģ–¹ģ–»ģ–¼ģ–½ģ–¾ģ—„\",6,\"ģ—Œģ—Ž\"],[\"bf41\",\"ķ’ž\",10,\"ķ’Ŗ\",14],[\"bf61\",\"ķ’¹\",18,\"ķ“ķ“Žķ“ķ“‘ķ“’ķ““ķ“•\"],[\"bf81\",\"ķ“–\",5,\"ķ“ķ“žķ“ \",7,\"ķ“©ķ“Ŗķ“«ķ“­ķ“®ķ“Æķ“±\",6,\"ķ“¹ķ“ŗķ“¼ģ—ģ—‘ģ—”ģ—˜ģ— ģ—”ģ—£ģ—„ģ—¬ģ—­ģ—®ģ—°ģ—“ģ—¶ģ—·ģ—¼\",5,\"ģ˜…ģ˜†ģ˜‡ģ˜ˆģ˜Œģ˜ģ˜˜ģ˜™ģ˜›ģ˜œģ˜¤ģ˜„ģ˜Øģ˜¬ģ˜­ģ˜®ģ˜°ģ˜³ģ˜“ģ˜µģ˜·ģ˜¹ģ˜»ģ™€ģ™ģ™„ģ™ˆģ™ģ™‘ģ™“ģ™”ģ™•ģ™œģ™ģ™ ģ™¬ģ™Æģ™±ģ™øģ™¹ģ™¼ģš€ģšˆģš‰ģš‹ģšģš”ģš•ģš˜ģšœģš¤ģš„ģš§ģš©ģš°ģš±ģš“ģšøģš¹ģšŗģ›€ģ›ģ›ƒģ›…ģ›Œģ›ģ›ģ›”ģ›œģ›ģ› ģ›”ģ›Ø\"],[\"c041\",\"ķ“¾\",5,\"ķ”…ķ”†ķ”‡ķ”‰ķ”Šķ”‹ķ”\",6,\"ķ”–ķ”˜\",5],[\"c061\",\"ķ”ž\",25],[\"c081\",\"ķ”øķ”¹ķ”ŗķ”»ķ”¾ķ”æķ•ķ•‚ķ•ƒķ•…\",6,\"ķ•Žķ•ķ•’\",5,\"ķ•šķ•›ķ•ķ•žķ•Ÿķ•”ķ•¢ķ•£ģ›©ģ›¬ģ›°ģ›øģ›¹ģ›½ģœ„ģœ…ģœˆģœŒģœ”ģœ•ģœ—ģœ™ģœ ģœ”ģœ¤ģœØģœ°ģœ±ģœ³ģœµģœ·ģœ¼ģœ½ģ€ģ„ģŠģŒģģģ‘\",7,\"ģœģ ģØģ«ģ“ģµģøģ¼ģ½ģ¾ģžƒģž„ģž…ģž‡ģžˆģž‰ģžŠģžŽģžģž‘ģž”ģž–ģž—ģž˜ģžšģž ģž”ģž£ģž¤ģž„ģž¦ģž¬ģž­ģž°ģž“ģž¼ģž½ģžæģŸ€ģŸģŸˆģŸ‰ģŸŒģŸŽģŸģŸ˜ģŸģŸ¤ģŸØģŸ¬ģ €ģ ģ „ģ ˆģ Š\"],[\"c141\",\"ķ•¤ķ•¦ķ•§ķ•Ŗķ•¬ķ•®\",5,\"ķ•¶ķ•·ķ•¹ķ•ŗķ•»ķ•½\",6,\"ķ–†ķ–Šķ–‹\"],[\"c161\",\"ķ–Œķ–ķ–Žķ–ķ–‘\",19,\"ķ–¦ķ–§\"],[\"c181\",\"ķ–Ø\",31,\"ģ ģ ‘ģ “ģ •ģ –ģ œģ ģ  ģ ¤ģ ¬ģ ­ģ Æģ ±ģ øģ ¼ģ”€ģ”ˆģ”‰ģ”Œģ”ģ””ģ”°ģ”±ģ”“ģ”øģ”ŗģ¢€ģ¢ģ¢ƒģ¢…ģ¢†ģ¢‡ģ¢‹ģ¢Œģ¢ģ¢”ģ¢ģ¢Ÿģ¢”ģ¢Øģ¢¼ģ¢½ģ£„ģ£ˆģ£Œģ£”ģ£•ģ£—ģ£™ģ£ ģ£”ģ£¤ģ£µģ£¼ģ£½ģ¤€ģ¤„ģ¤…ģ¤†ģ¤Œģ¤ģ¤ģ¤‘ģ¤˜ģ¤¬ģ¤“ģ„ģ„‘ģ„”ģ„˜ģ„ ģ„”ģ„£ģ„¬ģ„°ģ„“ģ„¼ģ¦ˆģ¦‰ģ¦Œģ¦ģ¦˜ģ¦™ģ¦›ģ¦ģ§€ģ§ģ§„ģ§‡ģ§ˆģ§Šģ§ģ§‘ģ§“\"],[\"c241\",\"ķ—Šķ—‹ķ—ķ—Žķ—ķ—‘ķ—“\",4,\"ķ—šķ—œķ—ž\",5,\"ķ—¦ķ—§ķ—©ķ—Ŗķ—«ķ—­ķ—®\"],[\"c261\",\"ķ—Æ\",4,\"ķ—¶ķ—øķ—ŗ\",5,\"ķ˜‚ķ˜ƒķ˜…ķ˜†ķ˜‡ķ˜‰\",6,\"ķ˜’\"],[\"c281\",\"ķ˜–\",5,\"ķ˜ķ˜žķ˜Ÿķ˜”ķ˜¢ķ˜£ķ˜„\",7,\"ķ˜®\",9,\"ķ˜ŗķ˜»ģ§•ģ§–ģ§™ģ§šģ§œģ§ģ§ ģ§¢ģ§¤ģ§§ģ§¬ģ§­ģ§Æģ§°ģ§±ģ§øģ§¹ģ§¼ģ؀ģ؈ģ؉ģ؋ģ،ģ؍ģؔģؘģØ©ģ©Œģ©ģ©ģ©”ģ©œģ©ģ©Ÿģ© ģ©”ģ©Øģ©½ģŖ„ģŖ˜ģŖ¼ģŖ½ģ«€ģ«„ģ«Œģ«ģ«ģ«‘ģ«“ģ«˜ģ«™ģ« ģ«¬ģ«“ģ¬ˆģ¬ģ¬”ģ¬˜ģ¬ ģ¬”ģ­ģ­ˆģ­‰ģ­Œģ­ģ­˜ģ­™ģ­ģ­¤ģ­øģ­¹ģ®œģ®øģƔģƤģƧģÆ©ģ°Œģ°ģ°ģ°”ģ°œģ°ģ°”ģ°¢ģ°§ģ°Øģ°©ģ°¬ģ°®ģ°°ģ°øģ°¹ģ°»\"],[\"c341\",\"ķ˜½ķ˜¾ķ˜æķ™ķ™‚ķ™ƒķ™„ķ™†ķ™‡ķ™Šķ™Œķ™Žķ™ķ™ķ™’ķ™“ķ™–ķ™—ķ™™ķ™šķ™›ķ™\",4],[\"c361\",\"ķ™¢\",4,\"ķ™Øķ™Ŗ\",5,\"ķ™²ķ™³ķ™µ\",11],[\"c381\",\"ķšķš‚ķš„ķš†\",5,\"ķšŽķšķš‘ķš’ķš“ķš•\",7,\"ķšžķš ķš¢\",5,\"ķš©ķšŖģ°¼ģ°½ģ°¾ģ±„ģ±…ģ±ˆģ±Œģ±”ģ±•ģ±—ģ±˜ģ±™ģ± ģ±¤ģ±¦ģ±Øģ±°ģ±µģ²˜ģ²™ģ²œģ² ģ²Øģ²©ģ²«ģ²¬ģ²­ģ²“ģ²µģ²øģ²¼ģ³„ģ³…ģ³‡ģ³‰ģ³ģ³”ģ³¤ģ³¬ģ³°ģ“ģ“ˆģ“‰ģ“Œģ“ģ“˜ģ“™ģ“›ģ“ģ“¤ģ“Øģ“¬ģ“¹ģµœģµ ģµ¤ģµ¬ģµ­ģµÆģµ±ģµøģ¶ˆģ¶”ģ¶•ģ¶˜ģ¶œģ¶¤ģ¶„ģ¶§ģ¶©ģ¶°ģ·„ģ·Œģ·ģ·Øģ·¬ģ·°ģ·øģ·¹ģ·»ģ·½ģø„ģøˆģøŒģø”ģø™ģø ģø”ģø¤ģøØģø°ģø±ģø³ģøµ\"],[\"c441\",\"ķš«ķš­ķš®ķšÆķš±\",7,\"ķšŗķš¼\",7,\"ķ›†ķ›‡ķ›‰ķ›Šķ›‹\"],[\"c461\",\"ķ›ķ›Žķ›ķ›ķ›’ķ›“ķ›•ķ›–ķ›˜ķ›š\",5,\"ķ›”ķ›¢ķ›£ķ›„ķ›¦ķ›§ķ›©\",4],[\"c481\",\"ķ›®ķ›Æķ›±ķ›²ķ›³ķ›“ķ›¶\",5,\"ķ›¾ķ›æķœķœ‚ķœƒķœ…\",11,\"ķœ’ķœ“ķœ”ģ¹˜ģ¹™ģ¹œģ¹Ÿģ¹ ģ¹”ģ¹Øģ¹©ģ¹«ģ¹­ģ¹“ģ¹µģ¹øģ¹¼ģŗ„ģŗ…ģŗ‡ģŗ‰ģŗģŗ‘ģŗ”ģŗ˜ģŗ ģŗ”ģŗ£ģŗ¤ģŗ„ģŗ¬ģŗ­ģ»ģ»¤ģ»„ģ»Øģ»«ģ»¬ģ»“ģ»µģ»·ģ»øģ»¹ģ¼€ģ¼ģ¼„ģ¼ˆģ¼ģ¼‘ģ¼“ģ¼•ģ¼œģ¼ ģ¼¤ģ¼¬ģ¼­ģ¼Æģ¼°ģ¼±ģ¼øģ½”ģ½•ģ½˜ģ½œģ½¤ģ½„ģ½§ģ½©ģ½°ģ½±ģ½“ģ½øģ¾€ģ¾…ģ¾Œģ¾”ģ¾Øģ¾°ģæ„ģæ ģæ”ģæ¤ģæØģæ°ģæ±ģæ³ģæµģæ¼ķ€€ķ€„ķ€‘ķ€˜ķ€­ķ€“ķ€µķ€øķ€¼\"],[\"c541\",\"ķœ•ķœ–ķœ—ķœšķœ›ķœķœžķœŸķœ”\",6,\"ķœŖķœ¬ķœ®\",5,\"ķœ¶ķœ·ķœ¹\"],[\"c561\",\"ķœŗķœ»ķœ½\",6,\"ķ…ķ†ķˆķŠ\",5,\"ķ’ķ“ķ•ķš\",4],[\"c581\",\"ķŸķ¢ķ¤ķ¦ķ§ķØķŖķ«ķ­ķ®ķÆķ±ķ²ķ³ķµ\",6,\"ķ¾ķæķž€ķž‚\",5,\"ķžŠķž‹ķ„ķ…ķ‡ķ‰ķķ”ķ˜ķ ķ¬ķ­ķ°ķ“ķ¼ķ½ķ‚ķ‚¤ķ‚„ķ‚Øķ‚¬ķ‚“ķ‚µķ‚·ķ‚¹ķƒ€ķƒķƒ„ķƒˆķƒ‰ķƒķƒ‘ķƒ“ķƒ”ķƒ•ķƒœķƒķƒ ķƒ¤ķƒ¬ķƒ­ķƒÆķƒ°ķƒ±ķƒøķ„ķ„°ķ„±ķ„“ķ„øķ„ŗķ…€ķ…ķ…ƒķ…„ķ……ķ…Œķ…ķ…ķ…”ķ…œķ…ķ…Ÿķ…”ķ…Øķ…¬ķ…¼ķ†„ķ†ˆķ† ķ†”ķ†¤ķ†Øķ†°ķ†±ķ†³ķ†µķ†ŗķ†¼ķ‡€ķ‡˜ķ‡“ķ‡øķˆ‡ķˆ‰ķˆķˆ¬ķˆ­ķˆ°ķˆ“ķˆ¼ķˆ½ķˆæķ‰ķ‰ˆķ‰œ\"],[\"c641\",\"ķžķžŽķžķž‘\",6,\"ķžšķžœķžž\",5],[\"c6a1\",\"ķ‰¤ķŠ€ķŠķŠ„ķŠˆķŠķŠ‘ķŠ•ķŠœķŠ ķŠ¤ķŠ¬ķŠ±ķŠøķŠ¹ķŠ¼ķŠæķ‹€ķ‹‚ķ‹ˆķ‹‰ķ‹‹ķ‹”ķ‹˜ķ‹œķ‹¤ķ‹„ķ‹°ķ‹±ķ‹“ķ‹øķŒ€ķŒķŒƒķŒ…ķŒŒķŒķŒŽķŒķŒ”ķŒ–ķŒœķŒķŒŸķŒ ķŒ”ķŒ„ķŒØķŒ©ķŒ¬ķŒ°ķŒøķŒ¹ķŒ»ķŒ¼ķŒ½ķ„ķ…ķ¼ķ½ķŽ€ķŽ„ķŽŒķŽķŽķŽķŽ‘ķŽ˜ķŽ™ķŽœķŽ ķŽØķŽ©ķŽ«ķŽ­ķŽ“ķŽøķŽ¼ķ„ķ…ķˆķ‰ķķ˜ķ”ķ£ķ¬ķ­ķ°ķ“ķ¼ķ½ķæķ\"],[\"c7a1\",\"ķˆķķ‘€ķ‘„ķ‘œķ‘ ķ‘¤ķ‘­ķ‘Æķ‘øķ‘¹ķ‘¼ķ‘æķ’€ķ’‚ķ’ˆķ’‰ķ’‹ķ’ķ’”ķ’©ķ“Œķ“ķ“”ķ“œķ“Ÿķ“Øķ“¬ķ“°ķ“øķ“»ķ“½ķ”„ķ”ˆķ”Œķ””ķ”•ķ”—ķ”¼ķ”½ķ•€ķ•„ķ•Œķ•ķ•ķ•‘ķ•˜ķ•™ķ•œķ• ķ•„ķ•Øķ•©ķ•«ķ•­ķ•“ķ•µķ•øķ•¼ķ–„ķ–…ķ–‡ķ–ˆķ–‰ķ–ķ–„ķ—ˆķ—‰ķ—Œķ—ķ—’ķ—˜ķ—™ķ—›ķ—ķ—¤ķ—„ķ—Øķ—¬ķ—“ķ—µķ—·ķ—¹ķ˜€ķ˜ķ˜„ķ˜ˆķ˜ķ˜‘ķ˜“ķ˜”ķ˜•ķ˜œķ˜ \"],[\"c8a1\",\"ķ˜¤ķ˜­ķ˜øķ˜¹ķ˜¼ķ™€ķ™…ķ™ˆķ™‰ķ™‹ķ™ķ™‘ķ™”ķ™•ķ™˜ķ™œķ™§ķ™©ķ™°ķ™±ķ™“ķšƒķš…ķšŒķšķšķš”ķšķšŸķš”ķšØķš¬ķš°ķš¹ķš»ķ›„ķ›…ķ›ˆķ›Œķ›‘ķ›”ķ›—ķ›™ķ› ķ›¤ķ›Øķ›°ķ›µķ›¼ķ›½ķœ€ķœ„ķœ‘ķœ˜ķœ™ķœœķœ ķœØķœ©ķœ«ķœ­ķœ“ķœµķœøķœ¼ķ„ķ‡ķ‰ķķ‘ķ”ķ–ķ—ķ˜ķ™ķ ķ”ķ£ķ„ķ©ķ¬ķ°ķ“ķ¼ķ½ķžķžˆķž‰ķžŒķžķž˜ķž™ķž›ķž\"],[\"caa1\",\"伽佳假價加åÆå‘µå“„å˜‰å«å®¶ęš‡ęž¶ęž·ęŸÆꭌē‚ē—‚ēØ¼č‹›čŒ„č”—č¢ˆčØ¶č³ˆč·č»»čæ¦é§•åˆ»å“各ęŖę…¤ę®¼ēč„šč¦ŗč§’é–£ä¾ƒåˆŠå¢¾å„øå§¦å¹²å¹¹ę‡‡ę€ę†ęŸ¬ę”æę¾—ē™Žēœ‹ē£µē؈ē«æē°”č‚č‰®č‰±č««é–“ä¹«å–ę›·ęø“ē¢£ē«­č‘›č¤čŽéžØ勘坎å ŖåµŒę„Ÿę†¾ęˆ”ę•¢ęŸ‘ę©„ęø›ē”˜ē–³ē›£ēž°ē“ŗé‚Æ鑑鑒龕\"],[\"cba1\",\"匣岬ē”²čƒ›é‰€é–˜å‰›å ˆå§œå²”å“—åŗ·å¼ŗå½Šę…·ę±Ÿē•ŗē–†ē³ ēµ³ē¶±ē¾Œč…”čˆ”č–‘č„č¬›é‹¼é™é±‡ä»‹ä»·å€‹å‡±å”ę„·ę„¾ę…Øę”¹ę§Ŗę¼‘ē–„ēš†ē›–ē®‡čŠ„蓋ļ¤€éŽ§é–‹å–€å®¢å‘ļ¤ē²³ē¾¹é†µå€Ø去居å·Øę‹’ę®ę“šę“§ęø ē‚¬ē„›č·čøžļ¤‚遽鉅é‹ø乾件偄巾å»ŗę„†ę„—č…±č™”č¹‡éµéØ«ä¹žå‚‘ę°ę”€å„‰åŠåŠ’ęŖ¢\"],[\"cca1\",\"ēž¼éˆé»”劫ę€Æčæ²åˆę†©ę­ę“Šę ¼ęŖ„ęæ€č†ˆč¦”隔堅ē‰½ēŠ¬ē”„ēµ¹ē¹­č‚©č¦‹č­“é£éµ‘ęŠ‰ę±ŗę½”ēµē¼ŗčØ£å…¼ę…Šē®č¬™é‰—鎌äŗ¬äæ“倞傾儆勁勍åæ坰境åŗšå¾‘ꅶꆬ꓎ꕬę™Æęš»ę›“ę¢—ę¶‡ē‚…ēƒ±ē’Ÿē’„ē“Šē—™ē”¬ē£¬ē«Ÿē«¶ēµ…ē¶“耕č€æč„›čŽ–č­¦č¼•é€•é”é ƒé ø驚éÆØäæ‚å•“å ŗ儑季屆ę‚øęˆ’ę”‚ę¢°\"],[\"cda1\",\"ę£ØęŗŖē•Œē™øē£Žēؽē³»ē¹«ē¹¼č؈čŖ”č°æ階鷄古叩告呱å›ŗ姑孤尻åŗ«ę‹·ę”·ę•…ę•²ęš ęžÆę§ę²½ē—¼ēšē¾ēØæē¾”č€ƒč‚”č†č‹¦č‹½č°č—č ±č¢“čŖ„ļ¤ƒč¾œéŒ®é›‡é”§é«˜é¼“å“­ę–›ę›²ę¢ē©€č°·éµ å›°å¤å“‘ę˜†ę¢±ę£ę»¾ēØč¢žéƤę±Øļ¤„éŖØä¾›å…¬å…±åŠŸå­”å·„ęę­ę‹±ęŽ§ę”»ē™ē©ŗčš£č²¢éžäø²åÆ”ęˆˆęžœē“œ\"],[\"cea1\",\"ē§‘č“čŖ‡čŖ²č·Ø過鍋锆廓ę§Øč—æ郭ļ¤…冠官åÆ¬ę…£ę£ŗę¬¾ēŒēÆē“˜ē®”ē½č…č§€č²«é—œé¤Øåˆ®ęę‹¬é€‚ä¾Šå…‰åŒ”å£™å»£ę› ę“øē‚šē‹‚ē–ē­čƒ±é‘›å¦ęŽ›ē½«ä¹–傀唊壞ę€Ŗę„§ę‹ę§é­å®ē“˜č‚±č½Ÿäŗ¤åƒ‘咬喬嬌嶠巧ę”Ŗꕎꠔꩋē‹”ēšŽēŸÆēµžēæ¹č† č•Žč›Ÿč¼ƒč½ŽéƒŠé¤ƒé©•é®«äø˜ä¹…九仇äæ±å…·å‹¾\"],[\"cfa1\",\"區口叄咎嘔坵垢åÆ‡å¶‡å»ę‡¼ę‹˜ę•‘ęžøęŸ©ę§‹ę­ęƆęÆ¬ę±‚ęŗēøē‹—ēŽ–ēƒēžæēŸ©ē©¶ēµæč€‰č‡¼čˆ…čˆŠč‹Ÿč”¢č¬³č³¼č»€é€‘é‚±é‰¤éŠ¶é§’é©…é³©é·—é¾œåœ‹å±€čŠéž éž«éŗ“君ēŖ˜ē¾¤č£™č»éƒ”å €å±ˆęŽ˜ēŖŸå®®å¼“ē©¹ēŖ®čŠŽčŗ¬å€¦åˆøå‹øå·åœˆę‹³ę²ę¬Šę·ƒēœ·åŽ„ē—č•Øč¹¶é—•ęœŗę«ƒę½°č©­č»Œé„‹ļ¤†ę™·ę­øč²“\"],[\"d0a1\",\"鬼ļ¤‡å«åœ­å„Žę†ę§»ēŖē”…ēŖŗē«…ē³¾č‘µč¦čµ³é€µé–Ø勻均ē•‡ē­ čŒéˆžļ¤ˆę©˜å…‹å‰‹åŠ‡ęˆŸę£˜ę„µéš™åƒ…åŠ¤å‹¤ę‡ƒę–¤ę ¹ę§æē‘¾ē­‹čŠ¹č«č¦²č¬¹čæ‘鄉ļ¤‰ä»Šå¦—ę“’ę˜‘ęŖŽē“ē¦ē¦½čŠ©č”¾č”æč„Ÿļ¤ŠéŒ¦ä¼‹åŠę€„ę‰±ę±²ē“šēµ¦äŗ˜å…¢ēŸœč‚Æ企伎其冀嗜å™Ø圻åŸŗ埼夔儇妓åƄ岐哎己幾åæŒęŠ€ę——ę—£\"],[\"d1a1\",\"ęœžęœŸęžę£‹ę£„ę©Ÿę¬ŗę°£ę±½ę²‚ę·‡ēŽ˜ē¦ēŖē’‚ē’£ē•øē•æē¢ē£Æē„ē„‡ē„ˆē„ŗē®•ē“€ē¶ŗē¾ˆč€†č€­č‚ŒčØ˜č­č±ˆčµ·éŒ”éŒ¤é£¢é„‘é؎é؏驄éŗ’ē·Šä½¶å‰ę‹®ę””金喫å„ŗļ¤‹ļ¤ŒåØœę‡¦ļ¤ę‹ę‹æļ¤Ž\",5,\"那ļ¤”\",4,\"č«¾ļ¤™ļ¤šļ¤›ļ¤œęš–ļ¤ē…–ļ¤žļ¤Ÿé›£ļ¤ ęęŗ南ļ¤”ęžę„ ę¹³ļ¤¢ē”·ļ¤£ļ¤¤ļ¤„\"],[\"d2a1\",\"ē“ļ¤¦ļ¤§č”²å›Šåؘļ¤Ø\",4,\"乃ļ¤­å…§å„ˆęŸ°č€ļ¤®å„³å¹“꒚ē§Šåæµę¬ę‹ˆę»åƧåƗåŠŖļ¤Æå„“å¼©ę€’ļ¤°ļ¤±ļ¤²ē‘™ļ¤³\",5,\"駑ļ¤¹\",10,\"ęæƒļ„„ļ„…č†æč¾²ęƒ±ļ„†ļ„‡č…¦ļ„ˆļ„‰å°æļ„Š\",7,\"å«©čØ„ę»ē“ļ„’\",5,\"čƒ½ļ„˜ļ„™å°¼ę³„åŒæęŗŗå¤ščŒ¶\"],[\"d3a1\",\"äø¹äŗ¶ä½†å–®åœ˜å£‡å½–ę–·ę—¦ęŖ€ę®µę¹ēŸ­ē«Æē°žē·žč›‹č¢’é„²é›ę’»ę¾¾ēŗē–ø達啖坍ę†ŗę“”ę›‡ę·”ę¹›ę½­ę¾¹ē—°čƒč†½č•č¦ƒč«‡č­šéŒŸę²“ē•“ē­”čøéå”å ‚å”˜å¹¢ęˆ‡ę’žę£ ē•¶ē³–čž³é»Ø代垈坮大對岱åø¶å¾…ęˆ“ę“”ēŽ³č‡ŗč¢‹č²øéšŠé»›å®…å¾·ę‚³å€’åˆ€åˆ°åœ–å µå”—å°Žå± å³¶å¶‹åŗ¦å¾’ę‚¼ęŒ‘ęŽ‰ę—ę”ƒ\"],[\"d4a1\",\"ę£¹ę«‚ę·˜ęø”ę»”ęæ¤ē‡¾ē›œē¹ē¦±ēØ»č„č¦©č³­č·³č¹ˆé€ƒé€”é“éƒ½éé™¶éŸœęƒē€†ē‰˜ēŠ¢ēØē£ē¦æēƤēŗ›č®€å¢©ęƒ‡ę•¦ę—½ęš¾ę²Œē„žē‡‰č±šé “ä¹­ēŖä»å†¬å‡å‹•åŒę†§ę±ę”ę£Ÿę“žę½¼ē–¼ēž³ē«„čƒ“č‘£éŠ…å…œę–—ęœęž“ē—˜ē«‡č³ļ„šč±†é€—é ­å±Æ臀芚遁éÆéˆå¾—å¶ę©™ē‡ˆē™»ē­‰č—¤č¬„鄧éØ°å–‡ę‡¶ļ„›ē™©ē¾…\"],[\"d5a1\",\"č˜æčžŗč£ø邏ļ„œę“›ēƒ™ēžēµ”č½ļ„é…Ŗ駱ļ„žäŗ‚åµę¬„ę¬’ē€¾ēˆ›č˜­éøžå‰Œč¾£åµę“„ꔬꬖęæ«ē±ƒēŗœč—č„¤č¦½ę‹‰č‡˜č Ÿå»Šęœ—ęµŖē‹¼ē…ē‘Æčž‚éƒžä¾†å“å¾ čŠå†·ęŽ ē•„äŗ®å€†å…©å‡‰ę¢ęؑē²®ē²±ē³§č‰Æč«’č¼›é‡ä¾¶å„·å‹µå‘‚å»¬ę…®ęˆ¾ę—…ę«šęæ¾ē¤Ŗč—œč £é–­é©¢é©Ŗéŗ—é»ŽåŠ›ę›†ę­·ē€ē¤«č½¢é‚ę†ęˆ€ę”£ę¼£\"],[\"d6a1\",\"ē…‰ē’‰ē·“čÆč“®č¼¦é€£éŠå†½åˆ—åŠ£ę“Œēƒˆč£‚å»‰ę–‚ę®®ęæ‚ē°¾ēµä»¤ä¼¶å›¹ļ„Ÿå²ŗå¶ŗꀜēŽ²ē¬­ē¾šēæŽč†é€žéˆ“é›¶éˆé ˜é½”ä¾‹ę¾§ē¦®é†“隷勞ļ„ ę’ˆę“„ę«“ę½žē€˜ēˆē›§č€č˜†č™œč·Æč¼…éœ²é­Æé·ŗé¹µē¢Œē„æē¶ č‰éŒ„é¹æéŗ“č«–å£Ÿå¼„ęœ§ē€§ē“ē± č¾å„”ē€Øē‰¢ē£Šč³‚č³šč³“雷äŗ†åƒšåÆ®å»–ę–™ē‡Žē™‚ēž­čŠč“¼\"],[\"d7a1\",\"遼鬧龍壘婁屢ęØ“ę·šę¼ē˜»ē“Æēø·č”žč¤øé¤é™‹åŠ‰ę—’ęŸ³ę¦“ęµęŗœē€ē‰ē‘ ē•™ē˜¤ē”«č¬¬é”žå…­ęˆ®é™ø侖倫哙ę·Ŗē¶øč¼Ŗå¾‹ę…„ę —ļ„”éš†å‹’č‚‹å‡œå‡Œę„žē؜ē¶¾č±é™µäæšåˆ©åŽ˜åå”Žå±„ꂧꝎę¢Ø구ēŠē‹øē†ē’ƒļ„¢ē—¢ē±¬ē½¹ē¾øčŽ‰č£č£”é‡Œé‡é›¢éÆ‰åę½¾ē‡ē’˜č—ŗčŗŖ隣鱗éŗŸęž—ę·‹ē³č‡Ø霖ē ¬\"],[\"d8a1\",\"ē«‹ē¬ ē²’ę‘©ē‘Ŗē—²ē¢¼ē£Ø馬魔éŗ»åÆžå¹•ę¼ č†œčŽ«é‚ˆäø‡ååØ©å·’å½Žę…¢ęŒ½ę™©ę›¼ę»æę¼«ē£ēžžč¬č”“č »č¼“é„…é°»å”œęŠ¹ęœ«ę²«čŒ‰č„Ŗéŗäŗ”妄åæ˜åæ™ęœ›ē¶²ē½”čŠ’čŒ«čŽ½č¼žé‚™åŸ‹å¦¹åŖ’åÆę˜§ęžšę¢…ęƏē…¤ē½µč²·č³£é‚é­…č„ˆč²Šé™Œé©€éŗ„å­Ÿę°“ēŒ›ē›²ē›ŸčŒå†Ŗč¦“å…å†•å‹‰ę£‰ę²”ēœ„ēœ ē¶æē·¬é¢éŗµę»…\"],[\"d9a1\",\"č”‘å†„åå‘½ę˜Žęšę¤§ęŗŸēšæēž‘čŒ—č“‚čžŸé…©éŠ˜é³“č¢‚ä¾®å†’å‹Ÿå§†åø½ę…•ę‘øę‘¹ęš®ęŸęØ”ęƍęƛē‰Ÿē‰”ē‘ēœøēŸ›č€—čŠ¼čŒ…č¬€č¬Øč²ŒęœØę²ē‰§ē›®ē¦ē©†é¶©ę­æę²’å¤¢ęœ¦č’™åÆå¢“å¦™å»Ÿęę˜“ę³ęøŗēŒ«ē«—č‹—éŒØå‹™å·«ę†®ę‡‹ęˆŠę‹‡ę’«ę— ę„™ę­¦ęƋē„”ē·ē•ē¹†čˆžčŒ‚č•ŖčŖ£č²æ霧鵔å¢Øé»˜å€‘åˆŽå»å•ę–‡\"],[\"daa1\",\"걶ē“Šē“‹čžčšŠé–€é›Æå‹æę²•ē‰©å‘³åŖšå°¾åµ‹å½Œå¾®ęœŖę¢¶ę„£ęø¼ę¹„ēœ‰ē±³ē¾Žč–‡č¬Žčæ·é”é»“å²·ę‚¶ę„ę†«ę•ę—»ę—¼ę°‘ę³ÆēŽŸē‰ē·”閔åÆ†čœœč¬å‰åšę‹ęę’²ęœ“ęØøę³Šē€ē’žē®”ē²•ēø›č†Ščˆ¶č–„čæ«é›¹é§ä¼“åŠåå›ę‹Œę¬ę”€ę–‘ę§ƒę³®ę½˜ē­ē•”ē˜¢ē›¤ē›¼ē£ē£»ē¤¬ēµ†čˆ¬čŸ čæ”é ’é£Æå‹ƒę‹”ę’„ęø¤ę½‘\"],[\"dba1\",\"ē™¼č·‹é†±é‰¢é«®é­ƒå€£å‚åŠå¦Øå°Ø幇彷ęˆæę”¾ę–¹ę—ę˜‰ęž‹ę¦œę»‚ē£…ē“”č‚Ŗč†€čˆ«čŠ³č’”čšŒčØŖč¬—é‚¦é˜²é¾å€äæ³ļ„£åŸ¹å¾˜ę‹œęŽ’ęÆę¹ƒē„™ē›ƒčƒŒčƒšč£“č£µč¤™č³ č¼©é…é™Ŗä¼Æä½°åø›ęŸę ¢ē™½ē™¾é­„å¹”ę؊ē…©ē‡”ē•Ŗļ„¤ē¹č•ƒč—©é£œä¼ē­ē½°é–„凔åø†ę¢µę°¾ę±Žę³›ēŠÆēÆ„čŒƒę³•ēŗåƒ»åŠˆå£ę“˜ęŖ—ē’§ē™–\"],[\"dca1\",\"ē¢§č˜—闢霹ļ„„åžå¼č®Šč¾Øč¾Æ邊刄ēž„鱉鼈äø™å€‚å…µå±›å¹·ę˜žę˜ŗęŸ„ę£…ē‚³ē”ē—…ē§‰ē«č¼§é¤ é؈äæå ”å ±åÆ¶ę™®ę­„ę“‘ę¹ŗę½½ē¤ē”«č©č£œč¤“č­œč¼”ä¼åƒ•åŒåœå®“å¾©ęœē¦č…¹čŒÆč””č¤‡č¦†č¼¹č¼»é¦„é°’ęœ¬ä¹¶äæø儉封å³Æå³°ę§ę£’ēƒ½ē†¢ē«ēø«č“¬čœ‚逢鋒鳳äøä»˜äæÆ傅剖å‰Æ否咐埠夫婦\"],[\"dda1\",\"孚孵åƌåŗœļ„¦ę‰¶ę•·ę–§ęµ®ęŗ„ēˆ¶ē¬¦ē°æē¼¶č…č…‘膚艀芙莩čØƒč² č³¦č³»čµ“č¶ŗéƒØ釜阜附駙鳧北分吩噓墳儔儮åææę†¤ę‰®ę˜ę±¾ē„šē›†ē²‰ē³žē“›čŠ¬č³é›°ļ„§ä½›å¼—å½æę‹‚å“©ęœ‹ę£šē”¼ē¹ƒéµ¬äø•å‚™åŒ•åŒŖ卑妃婢åŗ‡ę‚²ę†Šę‰‰ę‰¹ę–ęž‡ę¦§ęƔęƖęƗęƘę²øļ„Øēµē—ŗē ’ē¢‘ē§•ē§˜ē²ƒē·‹ēæ”č‚„\"],[\"dea1\",\"č„¾č‡‚č²čœšč£ØčŖ¹č­¬č²»é„™éžé£›é¼»åš¬å¬Ŗå½¬ę–ŒęŖ³ę®Æęµœęæ±ē€•ē‰ēŽ­č²§č³“é »ę†‘ę°·č˜é؁乍äŗ‹äŗ›ä»•ä¼ŗä¼¼ä½æäæŸåƒæ史åø唆嗣四士儢åؑåÆ«åÆŗ射巳åø«å¾™ę€ęØꖜę–ÆęŸ¶ęŸ»ę¢­ę­»ę²™ę³—ęø£ē€‰ē…ē ‚ē¤¾ē„€ē„ ē§ēÆ©ē“—ēµ²č‚†čˆčŽŽč“‘č›‡č£Ÿč©č©žč¬č³œčµ¦č¾­é‚Ŗ飼駟éŗå‰Šļ„©ęœ”ļ„Ŗ\"],[\"dfa1\",\"傘åˆŖå±±ę•£ę±•ēŠē”£ē–ē®—č’œé…øéœ°ä¹·ę’’ę®ŗē…žč–©äø‰ļ„«ę‰ę£®ęø—čŠŸč”˜č”«ę·ę¾éˆ’é¢ÆäøŠå‚·åƒå„Ÿå•†å–Ŗ嘗孀尙峠åøøåŗŠåŗ å»‚ęƒ³ę”‘ę©”ę¹˜ēˆ½ē‰€ē‹€ē›øē„„ē®±ēæ”č£³č§“č©³č±”č³žéœœå”žē’½č³½å—‡ļ„¬ē©”ē“¢č‰²ē‰²ē”Ÿē”„ļ„­ē¬™å¢…壻嶼åŗåŗ¶å¾ę•ęŠ’ęæꕍꚑꛙę›øę –ę£²ēŠ€ē‘žē­®ēµ®ē·–ē½²\"],[\"e0a1\",\"čƒ„čˆ’č–Æč„æčŖ“逝鋤黍鼠夕儭åø­ęƒœę˜”ę™³ęžę±ę·…ę½ŸēŸ³ē¢©č“†é‡‹éŒ«ä»™åƒŠå…ˆå–„å¬‹å®£ę‰‡ę•¾ę—‹ęø²ē…½ēē‘„ē’‡ē’æē™¬ē¦Ŗē·šē¹•ē¾Øč…ŗč†³čˆ¹č˜ščŸ¬č©µč·£éø銑鐄鄍鮮åØå±‘ę„”ę³„ę“©ęø«čˆŒč–›č¤»čØ­čŖŖé›Ŗé½§å‰”ęš¹ę®²ēŗ–čŸ¾č“é–ƒé™ę”ę¶‰ē‡®ļ„®åŸŽå§“å®¬ę€§ęƒŗꈐꘟꙟēŒ©ē¹ē››ēœē­¬\"],[\"e1a1\",\"č–č²č…„čŖ é†’äø–å‹¢ę­²ę“—ē؅ē¬¹ē“°ļ„Æč²°å¬å˜Æå”‘å®µå°å°‘å·¢ę‰€ęŽƒę”ę˜­ę¢³ę²¼ę¶ˆęŗÆē€Ÿē‚¤ē‡’ē”¦ē–ē–Žē˜™ē¬‘ēÆ ē°«ē“ ē“¹č”¬č•­č˜‡čؓ逍達邵銷韶éØ·äæ—å±¬ęŸę¶‘ē²ŸēŗŒč¬–č“–é€Ÿå­«å·½ęč“€éœé£”ēŽ‡å®‹ę‚šę¾ę·žč؟čŖ¦é€é Œåˆ·ļ„°ē‘ē¢ŽéŽ–蔰釗äæ®å—嗽囚垂壽嫂守岫峀åø„ꄁ\"],[\"e2a1\",\"ęˆę‰‹ęŽˆęœę”¶ę•øęØ¹ę®Šę°“ę“™ę¼±ē‡§ē‹©ēøē‡ē’²ē˜¦ē”ē§€ē©—ē«Ŗē²¹ē¶ē¶¬ē¹”ē¾žč„©čŒ±č’č“šč—Ŗč¢–čŖ°č®č¼ø遂邃酬銖銹隋隧éšØ雖需須首髓鬚叔唾夙孰å®æę·‘ę½šē†Ÿē”ē’¹č‚…č½å·”徇å¾Ŗꁂꗬꠒę„Æę©“ę®‰ę“µę·³ē£ē›¾ēž¬ē­ē“”č„£čˆœč€č““č•£č©¢č«„é†‡éŒžé †é¦“ęˆŒč”“čæ°é‰„哇哧\"],[\"e3a1\",\"嵩ē‘Ÿč†čØęæ•ę‹¾ēæ’č¤¶č„²äøžä¹˜åƒ§å‹å‡ę‰æꘇē¹©č …陞侍匙嘶始åŖ¤å°ø屎屍åø‚å¼‘ęƒę–½ę˜Æę™‚ęž¾ęŸ“ēŒœēŸ¢ē¤ŗēæ…č’”č“č¦–č©¦č©©č«”豕č±ŗ埓åƔ式ęÆę‹­ę¤ę®–ę¹œē†„ēÆ’č•č­˜č»¾é£Ÿé£¾ä¼ø侁äæ”呻åØ å®øę„¼ę–°ę™Øē‡¼ē”³ē„žē“³č…Žč‡£čŽ˜č–Ŗ藎蜃č؊čŗ«č¾›ļ„±čæ…失室åÆ¦ę‚‰åƩ尋åæƒę²\"],[\"e4a1\",\"ļ„²ę·±ē€‹ē”ščŠÆč«¶ä»€åļ„³é›™ę°äŗžäæ„å…’å•žåØ„å³Øꈑē‰™čŠ½čŽŖč›¾č”™č؝é˜æé›…é¤“é“‰éµå Šå²³å¶½å¹„ęƒ”ę„•ę”ę؂ęø„鄂鍔锎鰐齷安å²øęŒ‰ę™ę”ˆēœ¼é›éžé””é®Ÿę–”č¬č»‹é–¼å”µå²©å·–åŗµęš—ē™Œč“é—‡å£“ęŠ¼ē‹Žé“Øä»°å¤®ę€ę˜»ę®ƒē§§é“¦åŽ“å“€åŸƒå“–ę„›ę›–ę¶Æē¢č‰¾éš˜é„åŽ„ę‰¼ęŽ–ę¶²ēøŠč…‹é”\"],[\"e5a1\",\"ę«»ē½Œé¶Æéøšä¹Ÿå€»å†¶å¤œęƒ¹ę¶ę¤°ēˆŗ耶ļ„“野弱ļ„µļ„¶ē“„č‹„č‘Æ蒻藄čŗļ„·ä½Æļ„øļ„¹å£¤å­ƒę™ęšę”˜ę•­ęš˜ļ„ŗę„ŠęØ£ę“‹ē€ē…¬ē—’ē˜ē¦³ē©°ļ„»ē¾Šļ„¼č„„ļ„½č®“釀陽ļ„¾é¤Šåœ„å¾”ę–¼ę¼ē˜€ē¦¦čŖžé¦­é­šé½¬å„„ꆶꊑęŖč‡†åƒå °å½¦ē„‰č؀č«ŗå­¼č˜–äæŗå„¼åš“å„„ęŽ©ę·¹å¶Ŗę„­å††äŗˆä½™ļ„æļ¦€ļ¦å¦‚ļ¦‚\"],[\"e6a1\",\"ļ¦ƒę­Ÿę±ļ¦„ē’µē¤–ļ¦…čˆ‡č‰…čŒ¹č¼æč½ļ¦†é¤˜ļ¦‡ļ¦ˆļ¦‰äŗ¦ļ¦ŠåŸŸå½¹ę˜“ļ¦‹ļ¦Œē–«ē¹¹č­Æļ¦é€†é©›åš„å §å§øå؟宓ļ¦Žå»¶ļ¦ļ¦ęęŒ»ļ¦‘ę¤½ę²‡ę²æę¶Žę¶“ę·µę¼”ļ¦’ēƒŸē„¶ē…™ļ¦“ē‡ƒē‡•ļ¦”ē”ē”Æļ¦•ē­µē·£ļ¦–ēøÆļ¦—č”č»Ÿļ¦˜ļ¦™ļ¦šé‰›ļ¦›é³¶ļ¦œļ¦ļ¦žę‚…궅ļ¦Ÿē†±ļ¦ ļ¦”閱厭ļ¦¢ļ¦£ļ¦¤ęŸ“ļ¦„ē‚Žē„°ē°č‰¶č‹’\"],[\"e7a1\",\"ļ¦¦é–»é«„é¹½ę›„ļ¦§ē‡č‘‰ļ¦Øļ¦©å”‹ļ¦Ŗļ¦«å¶øå½±ļ¦¬ę˜ ęšŽę„¹ę¦®ę°øę³³ęø¶ę½ęæšē€›ē€Æē…ē‡Ÿē°ļ¦­ē‘›ļ¦®ē“”ē›ˆē©Žēŗ“ļ¦Æļ¦°č‹±č© čæŽļ¦±éˆļ¦²éœ™ļ¦³ļ¦“乂å€Ŗļ¦µåˆˆå”ę›³ę±­ęæŠēŒŠēæē©¢čŠ®č—č˜‚ļ¦¶č£”č©£č­½č±«ļ¦·éŠ³ļ¦ø霓預äŗ”伍äæ‰å‚²åˆå¾å³å—šå”¢å¢ŗ儧å؛åÆ¤ę‚Ÿļ¦¹ę‡Šę•–ę—æę™¤ę¢§ę±šę¾³\"],[\"e8a1\",\"ēƒē†¬ē’ē­½čœˆčŖ¤é°²é¼‡å±‹ę²ƒē„ēŽ‰éˆŗęŗ«ē‘„ē˜Ÿē©©ēø•č˜Šå…€å£…꓁ē“®ē”•ē™°ēæé‚•é›é„”ęø¦ē“¦ēŖ©ēŖŖ臄蛙čøčØ›å©‰å®Œå®›ę¢”ę¤€ęµ£ēŽ©ē“ē¬ē¢—ē·©ēæ«č„˜č…•čŽžč±Œé˜®é ‘ę›°å¾€ę—ŗ꞉ę±ŖēŽ‹å€­å؃ę­ŖēŸ®å¤–嵬巍ēŒ„ē•ļ¦ŗļ¦»åƒ„凹å Æ夭妖姚åÆ„ļ¦¼ļ¦½å¶¢ę‹—ę–ę’“ę“¾ļ¦¾ę›œļ¦æꩈļ§€ē‡æē‘¤ļ§\"],[\"e9a1\",\"ēŖˆēŖÆē¹‡ē¹žč€€č…°ļ§‚čŸÆ要謠遙ļ§ƒé‚€é„’ę…¾ę¬²ęµ“ēøŸč¤„č¾±äæ‘傭冗勇埇墉容åŗøę…‚ę¦•ę¶Œę¹§ęŗ¶ē†”ē‘¢ē”Øē”¬č³čŒø蓉čøŠéŽ”鏞ļ§„äŗŽä½‘偶å„Ŗ又友右宇åÆ“å°¤ę„šę†‚ę—“ē‰›ēŽ—ē‘€ē›‚ē„ē¦‘ē¦¹ē“†ē¾½čŠ‹č—•č™žčæ‚遇郵é‡Ŗ隅é›Øé›©å‹–å½§ę—­ę˜±ę Æē…œēض郁頊äŗ‘ļ§…ę©’ę®žę¾ē†‰č€˜čŠø蕓\"],[\"eaa1\",\"é‹éš•é›²éŸ»č”šé¬±äŗē†Šé›„元原哔圓園垣åŖ›å«„åƃę€Øę„æę“ę²…ę“¹ę¹²ęŗēˆ°ēŒæē‘—č‹‘č¢č½…é ļ§†é™¢é”˜é“›ęœˆč¶Šé‰žä½å‰åƒžå±åœå§”åØå°‰ę…°ęšęø­ēˆ²ē‘‹ē·ÆčƒƒčŽč‘¦č”æčŸč”›č¤˜č¬‚é•éŸ‹é­ä¹³ä¾‘å„’å…Ŗļ§‡å”Æ喩å­ŗ宄幼幽åŗ¾ę‚ ęƒŸę„ˆę„‰ę„ę”ø꜉ļ§ˆęŸ”ęŸšļ§‰ę„”ę„¢ę²¹ę“§ļ§Šęøøļ§‹\"],[\"eba1\",\"ęæ”ēŒ¶ēŒ·ļ§Œē‘œē”±ļ§ē™’ļ§Žļ§ē¶­č‡¾čøč£•čŖ˜č«›č«­čø°č¹‚遊逾éŗ酉釉鍮ļ§ļ§‘å ‰ļ§’ęÆ“č‚‰č‚²ļ§“ļ§”允儫尹ļ§•ļ§–ę½¤ēŽ§čƒ¤č“‡ļ§—鈗閏ļ§˜ļ§™ļ§šļ§›čæꈎē€œēµØ融ļ§œåž ę©ę…‡ę®·čŖ¾éŠ€éš±ä¹™åŸę·«č”­é™°éŸ³é£®ę–ę³£é‚‘å‡ę‡‰č†ŗé·¹ä¾å€šå„€å®œę„ę‡æꓬ꤅ęƅē–‘ēŸ£ē¾©č‰¤č–čŸ»č”£čŖ¼\"],[\"eca1\",\"議醫äŗŒä»„伊ļ§ļ§žå¤·å§Øļ§Ÿå·²å¼›å½›ę€”ļ§ ļ§”ļ§¢ļ§£ēˆ¾ē„ļ§¤ē•°ē—ļ§„ē§»ļ§¦č€Œč€³č‚„č‹”荑ļ§§ļ§Øč²½č²³é‚‡ļ§©ļ§Ŗ飓餌ļ§«ļ§¬ē€·ē›ŠēæŠēæŒēæ¼č¬šäŗŗ仁刃印ļ§­å’½å› å§»åƅ引åæę¹®ļ§®ļ§ÆēµŖčŒµļ§°čš“čŖļ§±é­é·ļ§²ļ§³äø€ä½šä½¾å£¹ę—„ęŗ¢é€øéŽ°é¦¹ä»»å£¬å¦Šå§™ęļ§“ļ§µēؔļ§¶čč³ƒå…„卄\"],[\"eda1\",\"ļ§·ļ§øļ§¹ä»å‰©å­•čŠæ仔åˆŗå’Ø姉å§æå­å­—å­œę£ę…ˆę»‹ē‚™ē…®ēŽ†ē“·ē–µē£ē“«č€…č‡ŖčŒØč”—č—‰č«®č³‡é›Œä½œå‹ŗåš¼ę–«ę˜Øē¼ē‚øēˆµē¶½čŠé…Œé›€éµ²å­±ę£§ę®˜ę½ŗē›žå²‘ęš«ę½›ē®“ē°Ŗč ¶é›œäøˆä»—匠堓墻å£Æ儬將åø³åŗ„å¼µęŽŒęš²ę–ę؟ęŖ£ę¬Œę¼æē‰†ļ§ŗēē’‹ē« ē²§č…øč‡Ÿč‡§čŽŠč‘¬č”£č–”č—č£č““é†¬é•·\"],[\"eea1\",\"障再哉åœØå®°ę‰ęę ½ę¢“ęø½ę»“ē½ēø”č£č²”č¼‰é½‹é½Žēˆ­ē®č«éŒšä½‡ä½Žå„²å’€å§åŗ•ęŠµęµę„®ęØ—ę²®ęøšē‹™ēŒŖē–½ē®øē“µč‹§č¹č‘—č—·č©›č²Æčŗ‡é€™é‚ø雎齟勣吊嫔åÆ‚ę‘˜ę•µę»“ē‹„ļ§»ēš„ē©ē¬›ē±ēø¾ēæŸč»č¬«č³Ščµ¤č·”č¹ŸčæŖčæ¹é©é‘佃ä½ŗ傳å…Øå…ø前å‰Ŗå””å”¼å„ å°ˆå±•å»›ę‚›ęˆ°ę “ę®æę°ˆę¾±\"],[\"efa1\",\"ē…Žē ē”°ē”øē•‘ē™²ē­Œē®‹ē®­ēƆēŗč©®č¼¾č½‰éˆæ銓錢鐫電锚锫餞切ęˆŖęŠ˜ęµ™ē™¤ē«Šēƀēµ¶å å²¾åŗ—ę¼øē‚¹ē²˜éœ‘鮎點ꎄę‘ŗč¶äøäŗ•äŗ­åœåµå‘ˆå§ƒå®šå¹€åŗ­å»·å¾ęƒ…ęŒŗę”æę•“ę—Œę™¶ę™øęŸ¾ę„ØęŖ‰ę­£ę±€ę·€ę·ØęøŸę¹žē€žē‚”ēŽŽē½ē”ŗē›ē¢‡ē¦Žē؋ē©½ē²¾ē¶Žč‰‡č؂č«Ŗč²žé„­é…Šé‡˜é‰¦é‹ŒéŒ éœ†é–\"],[\"f0a1\",\"靜頂鼎制劑啼堤åøå¼Ÿę‚Œęę¢ÆęæŸē„­ē¬¬č‡č–ŗč£½č«øč¹„é†é™¤éš›éœ½é”Œé½ŠäæŽå…†å‡‹åŠ©å˜²å¼”彫ęŽŖę“ę—©ę™ę›ŗę›¹ęœę¢ę£—ę§½ę¼•ę½®ē…§ē‡„ēˆŖē’Ŗēœŗē„–ē„šē§ŸēØ ēŖ•ē²—ē³Ÿēµ„ē¹°č‚‡č—»čš¤č©”čŖæ趙čŗé€ é­é‡£é˜»é›•é³„ꗏē°‡č¶³éƒå­˜å°Šå’ę‹™ēŒå€§å®—å¾žę‚°ę…«ę£•ę·™ē®ēØ®ēµ‚ē¶œēø±č…«\"],[\"f1a1\",\"čøŖčøµé¾é˜ä½åå·¦åŗ§ęŒ«ē½Ŗäø»ä½ä¾åšå§čƒ„å‘Ŗå‘Øå—¾å„å®™å·žå»šę™ęœ±ęŸ±ę Ŗę³Øę“²ę¹Šę¾ē‚·ē ē–‡ē±Œē“‚ē“¬ē¶¢čˆŸč››čØ»čŖ…čµ°čŗŠč¼³é€±é…Žé…’鑄駐ē«¹ē²„äæŠå„å‡†åŸˆåÆÆå³»ę™™ęØ½ęµšęŗ–ęæ¬ē„Œē•Æē«£č ¢é€”遵雋é§æ茁äø­ä»²č”†é‡å½ę«›ę„«ę±č‘ŗå¢žę†Žę›¾ę‹Æēƒē”‘ē—‡ē¹’č’øč­‰č“ˆä¹‹åŖ\"],[\"f2a1\",\"咫地址åæ—ęŒęŒ‡ę‘Æę”Æę—Øę™ŗęžęž³ę­¢ę± ę²šę¼¬ēŸ„ē „ē„‰ē„—ē“™č‚¢č„‚č‡³čŠčŠ·čœ˜čŖŒļ§¼č“„č¶¾é²ē›“ēؙēØ·ē¹”č·å”‡å—”å”µęŒÆę¢ę™‰ę™‹ę”­ę¦›ę®„ę“„ęŗ±ēē‘Øē’”ē•›ē–¹ē›”ēœžēž‹ē§¦ēø‰ēøč‡»č”Æč¢—čØŗč³‘č»«č¾°é€²éŽ­é™£é™³éœ‡ä¾„å±å§Ŗ嫉åø™ę”Žē“†ē–¾ē§©ēŖ’č†£č›­č³Ŗč·Œčæ­ę–Ÿęœ•ļ§½åŸ·ę½—ē·č¼Æ\"],[\"f3a1\",\"é¶é›†å¾µę‡²ę¾„äø”侘借叉嗟åµÆå·®ę¬”ę­¤ē£‹ē®šļ§¾č¹‰č»Šé®ę‰ę¾ē€ēŖ„éŒÆé‘æé½Ŗ꒰ę¾Æē‡¦ē’Øē“šē«„ē°’ēŗ‚ē²²ēŗ˜č®šč“Šé‘½é¤é„Œåˆ¹åÆŸę“¦ęœ­ē“®åƒ­åƒå”¹ę…˜ę…™ę‡ŗę–¬ē«™č®’č®–å€‰å€”創唱åØ¼å» å½°ę„“ę•žę˜Œę˜¶ęš¢ę§ę»„ę¼²ēŒ–ē˜”ēŖ“č„¹č‰™č–č’¼å‚µåŸ°åƀåÆØå½©ęŽ”ē ¦ē¶µčœč””é‡‡é‡µå†ŠęŸµē­–\"],[\"f4a1\",\"č²¬å‡„å¦»ę‚½č™•å€œļ§æ剔å°ŗę…½ęˆšę‹“ę“²ę–„ę»Œē˜ č„Šč¹ é™Ÿéš»ä»Ÿåƒå–˜å¤©å·ę“…ę³‰ę·ŗēŽ”ē©æčˆ›č–¦č³¤čøé·é‡§é—”阔韆å‡øå“²å–†å¾¹ę’¤ę¾ˆē¶“č¼Ÿč½éµåƒ‰å°–ę²¾ę·»ē”›ēž»ē°½ē±¤č©¹č«‚堞妾åø–ę·ē‰’ē–Šē«č«œč²¼č¼’å»³ę™“ę·øč½čč«‹é‘éƖļ؀剃ę›æ궕ę»Æē· č«¦é€®éžé«”初å‰æå“Øę†”ęŠ„ę‹›ę¢¢\"],[\"f5a1\",\"ꤒꄚęصē‚’ē„¦ē”ē¤ē¤Žē§’ēØč‚–č‰øč‹•č‰č•‰č²‚č¶…é…¢é†‹é†®äæƒå›‘ē‡­ēŸ—čœ€č§øåÆøåæ–ę‘é‚Ø叢唚åÆµę‚¤ę†ę‘ ēø½č°č”„éŠƒę’®å‚¬å“”ęœ€å¢œęŠ½ęŽØꤎę„øęØžę¹«ēšŗē§‹čŠ»č©č«č¶Øčæ½é„’酋醜錐錘鎚雛éض鰍äø‘ē•œē„ē«ŗē­‘ēƉēø®č“„č¹™č¹“č»øé€ę˜„ę¤æē‘ƒå‡ŗęœ®é»œå……åæ ę²–čŸ²č”č”·ę‚“č†µčƒ\"],[\"f6a1\",\"č“…å–å¹å˜“åض就ē‚Šēæ čšč„†č‡­č¶£é†‰é©Ÿé·²å“ä»„åŽ ęƒ»ęø¬å±¤ä¾ˆå€¤å—¤å³™å¹Ÿę„ę¢”ę²»ę·„ē†¾ē—”ē—“ē™”ēؚē©‰ē·‡ē·»ē½®č‡“čš©č¼œé›‰é¦³é½’å‰‡å‹…é£­č¦ŖäøƒęŸ’ę¼†ä¾µåÆ¢ęž•ę²ˆęµøē›ē §é‡é¼čŸ„ē§¤ēرåæ«ä»–å’¤å”¾å¢®å¦„ęƒ°ę‰“ę‹–ęœ¶ę„•čˆµé™€é¦±é§å€¬å“å•„å¼ļØę‰˜ļØ‚ę“¢ę™«ęŸęæęæÆē¢ēøčؗ\"],[\"f7a1\",\"éøå‘‘å˜†å¦å½ˆę†šę­Žē˜ē‚­ē¶»čŖ•å„Ŗč„«ęŽ¢ēœˆč€½č²Ŗå””ę­ę¦»å®•åø‘ę¹ÆļØƒč•©å…Œå°å¤Ŗę€ ę…‹ę®†ę±°ę³°ē¬žčƒŽč‹”č·†é‚°é¢±ļØ„ę“‡ę¾¤ę’‘ę”„å…ŽååœŸčØŽę…Ÿę”¶ļ؅ē—›ē­’ēµ±é€šå †ę§Œč…æč¤Ŗ退頹åøå„—å¦¬ęŠ•é€é¬Ŗꅝē‰¹é—–å”å©†å·“ęŠŠę’­ę“ŗę·ę³¢ę“¾ēˆ¬ē¶ē “ē½·čŠ­č·›é —判坂ęæē‰ˆē“£č²©č¾¦éˆ‘\"],[\"f8a1\",\"é˜Ŗå…«å­ęŒä½©å”„ę‚–ę•—ę²›ęµæē‰Œē‹½ēØ—č¦‡č²å½­ę¾Žēƒ¹č†Øꄎä¾æåę‰ē‰‡ēƇē·Øēæ©ééž­éØ™č²¶åŖå¹³ęž°čč©•å å¬–å¹£å»¢å¼Šę–ƒč‚ŗč”½é–‰é™›ä½ˆåŒ…åŒåŒå’†å“ŗ圃åøƒę€–ęŠ›ęŠ±ę•ļØ†ę³”ęµ¦ē–±ē ²čƒžč„Æč‹žč‘”č’²č¢č¤’é€‹é‹Ŗé£½é®‘å¹…ęš“ę›ē€‘ēˆ†ļ؇äæµå‰½å½ŖꅓꝓęØ™ę¼‚ē“¢ē„Øč”Øč±¹é£‡é£„é©ƒ\"],[\"f9a1\",\"品ēØŸę„“č«·č±Šé¢Øé¦®å½¼ęŠ«ē–²ēš®č¢«éæ陂匹弼åæ…ę³ŒēŒē•¢ē–‹ē­†č‹¾é¦ä¹é€¼äø‹ä½•åŽ¦å¤å»ˆę˜°ę²³ē‘•č·č¦č³€ééœžé°•å£‘å­ø虐謔鶓åƒęØę‚ę—±ę±—ę¼¢ę¾£ē€šē½•ēæ°é–‘é–’é™éŸ“å‰²č½„å‡½å«å’ø啣喊ęŖ»ę¶µē·˜č‰¦éŠœé™·é¹¹åˆå“ˆē›’č›¤é–¤é—”é™œäŗ¢ä¼‰å§®å«¦å··ę’ęŠ—ę­ę”ę²†ęøÆē¼ø肛čˆŖ\"],[\"faa1\",\"ļ؈ļ؉項äŗ„å•å’³åž“å„šå­©å®³ę‡ˆę„·ęµ·ē€£čŸ¹č§£č©²č«§é‚‚駭éŖø劾ę ø倖å¹øęč‡č”Œäŗ«å‘åš®ē¦é„•éŸæé¤‰é„—é¦™å™“å¢Ÿč™›čØ±ę†²ę«¶ē»č»’ę­‡éšŖé©—å„•ēˆ€čµ«é©äæ”峓弦ę‡øę™›ę³«ē‚«ēŽ„ēŽ¹ē¾ēœ©ēēµƒēµ¢ēø£čˆ·č”’ļØŠč³¢é‰‰é”Æ孑ē©“č”€é å«Œäæ å”å¤¾å³½ęŒ¾ęµ¹ē‹¹č„…č„‡čŽ¢é‹é °äŗØ兄刑型\"],[\"fba1\",\"å½¢ę³‚ę»Žē€…ēē‚Æē†’ē©ē‘©čŠčž¢č””逈邢鎣é¦Øå…®å½—ęƒ ę…§ęš³č•™č¹Šé†Æ鞋乎äŗ’呼壕å£ŗå„½å²µå¼§ęˆ¶ę‰ˆę˜Šę™§ęÆ«ęµ©ę·ę¹–ę»øę¾”ęæ ęæ©ēē‹ē„ē‘šē“ ēš“ē„œē³Šēøžčƒ”芦葫č’æč™Žč™Ÿč“č­·č±ŖéŽ¬é €é”„ęƒ‘ęˆ–é…·å©šę˜ę··ęø¾ēæ魂åæ½ęƒšē¬å“„å¼˜ę±žę³“ę“Ŗēƒ˜ē“…č™¹č،铻化和嬅ęØŗē«ē•µ\"],[\"fca1\",\"ē¦ē¦¾čŠ±čÆ話譁č²Ø靓ļØ‹ę““ę”«ē¢ŗē¢»ē©«äøøå–šå„å®¦å¹»ę‚£ę›ę­”ę™„ę”“ęø™ē…„ē’°ē“ˆé‚„é©©é°„ꓻ껑ēŒ¾č±é—Šå‡°å¹Œå¾Øęęƒ¶ę„°ę…Œę™ƒę™„ę¦„ę³ę¹Ÿę»‰ę½¢ē…Œē’œēš‡ēƁē°§č’č—é‘éšé»ƒåŒÆå›žå»»å¾Šę¢ę‚”ę‡·ę™¦ęœƒęŖœę·®ę¾®ē°ēŖē¹Ŗč†¾čŒ“č›”čŖØč³„åŠƒē²å®–ę©«é„å“®åš†å­ę•ˆę–…ę›‰ę¢Ÿę¶ę·†\"],[\"fda1\",\"ēˆ»č‚“酵驍ä¾Æ候厚后吼喉嗅åøæå¾Œęœ½ē…¦ēé€…勛勳唤壎ē„„ē†ē‡»č–°čØ“ęšˆč–Øå–§ęš„ē…Šč±å‰å–™ęÆå½™å¾½ę®ęš‰ē…‡č«±č¼éŗ¾ä¼‘ęŗēƒ‹ē•¦č™§ę¤č­Žé·øå…‡å‡¶åŒˆę“¶čƒøé»‘ę˜•ę¬£ē‚˜ē—•åƒå±¹ē“‡čØ–ę¬ ę¬½ę­†åøę°ę“½ēæ•čˆˆåƒ–凞喜噫囍姬嬉åøŒę†™ę†˜ęˆ±ę™žę›¦ē†™ē†¹ē†ŗēŠ§ē¦§ē؀ē¾²č©°\"]]"); + +/***/ }), + +/***/ 7231: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"0\",\"\\u0000\",127],[\"a140\",\"怀ļ¼Œć€ć€‚ļ¼Žā€§ļ¼›ļ¼šļ¼Ÿļ¼ļø°ā€¦ā€„ļ¹ļ¹‘ļ¹’Ā·ļ¹”ļ¹•ļ¹–ļ¹—ļ½œā€“ļø±ā€”ļø³ā•“ļø“ļ¹ļ¼ˆļ¼‰ļøµļø¶ļ½›ļ½ļø·ļøø怔怕ļø¹ļøŗ怐怑ļø»ļø¼ć€Šć€‹ļø½ļø¾ć€ˆć€‰ļøæļ¹€ć€Œć€ļ¹ļ¹‚ć€Žć€ļ¹ƒļ¹„ļ¹™ļ¹š\"],[\"a1a1\",\"ļ¹›ļ¹œļ¹ļ¹žā€˜ā€™ā€œā€ć€ć€žā€µā€²ļ¼ƒļ¼†ļ¼Šā€»Ā§ć€ƒā—‹ā—ā–³ā–²ā—Žā˜†ā˜…ā—‡ā—†ā–”ā– ā–½ā–¼ćŠ£ā„…ĀÆļæ£ļ¼æĖļ¹‰ļ¹Šļ¹ļ¹Žļ¹‹ļ¹Œļ¹Ÿļ¹ ļ¹”ļ¼‹ļ¼Ć—Ć·Ā±āˆšļ¼œļ¼žļ¼ā‰¦ā‰§ā‰ āˆžā‰’ā‰”ļ¹¢\",4,\"ļ½žāˆ©āˆŖāŠ„āˆ āˆŸāŠæ插揑āˆ«āˆ®āˆµāˆ“ā™€ā™‚āŠ•āŠ™ā†‘ā†“ā†ā†’ā†–ā†—ā†™ā†˜āˆ„āˆ£ļ¼\"],[\"a240\",\"ļ¼¼āˆ•ļ¹Øļ¼„ļæ„怒ļæ ļæ”ļ¼…ļ¼ ā„ƒā„‰ļ¹©ļ¹Ŗļ¹«ć•ćŽœćŽćŽžćŽćŽ”掎掏揄Ā°å…™å…›å…žå…å…”兣嗧ē“©ē³Žā–\",7,\"ā–ā–Žā–ā–Œā–‹ā–Šā–‰ā”¼ā”“ā”¬ā”¤ā”œā–”ā”€ā”‚ā–•ā”Œā”ā””ā”˜ā•­\"],[\"a2a1\",\"ā•®ā•°ā•Æā•ā•žā•Ŗā•”ā—¢ā—£ā—„ā—¤ā•±ā•²ā•³ļ¼\",9,\"ā… \",9,\"怔\",8,\"十卄卅ļ¼”\",25,\"ļ½\",21],[\"a340\",\"ļ½—ļ½˜ļ½™ļ½šĪ‘\",16,\"Ī£\",6,\"Ī±\",16,\"Ļƒ\",6,\"愅\",10],[\"a3a1\",\"愐\",25,\"Ė™Ė‰ĖŠĖ‡Ė‹\"],[\"a3e1\",\"ā‚¬\"],[\"a440\",\"äø€ä¹™äøäøƒä¹ƒä¹äŗ†äŗŒäŗŗå„æ兄八几刀刁力匕十卜又äø‰äø‹äøˆäøŠäø«äøø凔久么也乞äŗŽäŗ”兀刃å‹ŗ千叉口土士夕大儳子孑孓åÆø小尢å°øå±±å·å·„å·±å·²å·³å·¾å¹²å»¾å¼‹å¼“ę‰\"],[\"a4a1\",\"äø‘äøäøäø­äø°äø¹ä¹‹å°¹äŗˆäŗ‘äŗ•äŗ’äŗ”äŗ¢ä»ä»€ä»ƒä»†ä»‡ä»ä»Šä»‹ä»„元允內六兮公冗凶分切刈勻勾å‹æ化匹午升卅卞厄友及反壬天夫å¤Ŗ夭孔少尤å°ŗå±Æå·“å¹»å»æ弔引åæƒęˆˆęˆ¶ę‰‹ę‰Žę”Æę–‡ę–—ę–¤ę–¹ę—„ę›°ęœˆęœØę¬ ę­¢ę­¹ęƋęƔęÆ›ę°ę°“ē«ēˆŖēˆ¶ēˆ»ē‰‡ē‰™ē‰›ēŠ¬ēŽ‹äø™\"],[\"a540\",\"äø–äø•äø”äø˜äø»ä¹ä¹ä¹Žä»„付仔仕他仗代令仙仞充兄冉冊冬凹å‡ŗå‡ø刊加功包匆北匝仟半卉協占åÆ卮去åÆ古右召叮叩åØ叼åø叵叫另åŖ史叱台叄叭叻四囚外\"],[\"a5a1\",\"央失儓儶孕它尼å·Ø巧左åø‚åøƒå¹³å¹¼å¼å¼˜å¼—åæ…ęˆŠę‰“ę‰”ę‰’ę‰‘ę–„ę—¦ęœ®ęœ¬ęœŖęœ«ęœ­ę­£ęÆę°‘ę°ę°øę±ę±€ę°¾ēŠÆēŽ„ēŽ‰ē“œē“¦ē”˜ē”Ÿē”Øē”©ē”°ē”±ē”²ē”³ē–‹ē™½ēš®ēšæē›®ēŸ›ēŸ¢ēŸ³ē¤ŗē¦¾ē©“ē«‹äøžäøŸä¹’乓乩äŗ™äŗ¤äŗ¦äŗ„ä»æ伉伙伊伕伍伐休伏仲件任仰仳份企伋光兇兆先å…Ø\"],[\"a640\",\"共再冰列刑划刎刖劣匈匔匠印危吉吏同吊吐吁吋各向名合吃后吆吒因回囝圳地åœØ圭圬åœÆ圩夙多夷å¤ø妄å„ø妃儽儹如妁字存宇守宅安åÆŗ尖屹州åø†å¹¶å¹“\"],[\"a6a1\",\"式弛åæ™åæ–ęˆŽęˆŒęˆęˆę‰£ę‰›ę‰˜ę”¶ę—©ę—Øę—¬ę—­ę›²ę›³ęœ‰ęœ½ęœ“ęœ±ęœµę¬”ę­¤ę­»ę°–ę±ę±—ę±™ę±Ÿę± ę±ę±•ę±”ę±›ę±ę±Žē°ē‰Ÿē‰ē™¾ē«¹ē±³ē³øē¼¶ē¾Šē¾½č€č€ƒč€Œč€’č€³čæč‚‰č‚‹č‚Œč‡£č‡Ŗč‡³č‡¼čˆŒčˆ›čˆŸč‰®č‰²č‰¾č™«č”€č”Œč”£č„æ阔äø²äŗØ位住佇佗佞伓佛何估佐佑伽ä¼ŗä¼ø佃佔似但佣\"],[\"a740\",\"作你ä¼Æ低伶余佝佈佚兌克免兵冶冷刄判利åˆŖåˆØ劫助åŠŖ劬匣即卵吝吭吞吾否呎吧呆呃吳呈呂君吩告吹吻åø吮吵吶吠吼呀吱含吟听å›Ŗ困囤囫坊坑址坍\"],[\"a7a1\",\"均坎圾坐坏圻å£Æ夾妝妒å¦Ø妞妣妙妖妍妤妓妊妄孝孜孚孛完宋宏尬局屁å°æ尾岐岑岔岌巫åøŒåŗåŗ‡åŗŠå»·å¼„弟彤形彷役åæ˜åæŒåæ—åæåæ±åæ«åæøåæŖęˆ’ęˆ‘ęŠ„ęŠ—ęŠ–ęŠ€ę‰¶ęŠ‰ę‰­ęŠŠę‰¼ę‰¾ę‰¹ę‰³ęŠ’ę‰ÆęŠ˜ę‰®ęŠ•ęŠ“ęŠ‘ęŠ†ę”¹ę”»ę”øę—±ę›“ęŸęŽęęę‘ęœę–ęžę‰ę†ę \"],[\"a840\",\"ę“ę—ę­„ęÆę±‚ę±žę²™ę²ę²ˆę²‰ę²…ę²›ę±Ŗę±ŗę²ę±°ę²Œę±Øę²–ę²’ę±½ę²ƒę±²ę±¾ę±“ę²†ę±¶ę²ę²”ę²˜ę²‚ē¶ē¼ē½ēøē‰¢ē‰”ē‰ ē‹„ē‹‚ēŽ–ē”¬ē”«ē”·ē”øēš‚ē›ÆēŸ£ē§ē§€ē¦æē©¶ē³»ē½•č‚–č‚“č‚č‚˜č‚›č‚šč‚²č‰Æ芒\"],[\"a8a1\",\"čŠ‹čŠč¦‹č§’čØ€č°·č±†č±•č²čµ¤čµ°č¶³čŗ«č»Šč¾›č¾°čæ‚čæ†čæ…čæ„å·”邑邢é‚Ŗ邦那酉釆里防阮阱é˜Ŗ阬äø¦ä¹–ä¹³äŗ‹äŗ›äŗžäŗ«äŗ¬ä½Æ依侍佳ä½æ佬供例來侃佰併侈佩佻侖佾侏侑ä½ŗ兔兒兕兩具其å…ø冽函刻åˆø刷åˆŗ到刮制剁劾劻卒協卓卑卦卷åø卹取叔受味呵\"],[\"a940\",\"咖å‘ø咕咀呻呷咄咒咆呼咐呱呶和咚呢å‘Ø咋命咎å›ŗ垃坷åŖ坩坔坦坤坼夜儉儇儈億儔妾妻委妹妮姑姆姐姍始姓姊å¦Æ妳姒姅孟孤季宗定官宜宙宛尚屈居\"],[\"a9a1\",\"屆岷岔å²ø岩岫岱岳åø˜åøšåø–åø•åø›åø‘å¹øåŗšåŗ—åŗœåŗ•åŗ–延弦弧弩往征å½æå½¼åæåæ åæ½åæµåææꀏꀔę€Æꀵꀖę€Ŗę€•ę€”ę€§ę€©ę€«ę€›ęˆ–ęˆ•ęˆæęˆ¾ę‰€ę‰æꋉꋌꋄęŠæę‹‚ęŠ¹ę‹’ę‹›ęŠ«ę‹“ę‹”ę‹‹ę‹ˆęŠØęŠ½ęŠ¼ę‹ę‹™ę‹‡ę‹ęŠµę‹šęŠ±ę‹˜ę‹–ę‹—ę‹†ęŠ¬ę‹Žę”¾ę–§ę–¼ę—ŗꘔꘓꘌꘆꘂ꘎ꘀ꘏ꘕꘊ\"],[\"aa40\",\"ę˜‡ęœęœ‹ę­ęž‹ęž•ę±ęžœę³ę·ęž‡ęžęž—ęÆꝰęæęž‰ę¾ęžęµęžšęž“ę¼ęŖę²ę¬£ę­¦ę­§ę­æę°“ę°›ę³£ę³Øę³³ę²±ę³Œę³„ę²³ę²½ę²¾ę²¼ę³¢ę²«ę³•ę³“ę²øę³„ę²¹ę³ę²®ę³—ę³…ę³±ę²æę²»ę³”ę³›ę³Šę²¬ę³Æę³œę³–ę³ \"],[\"aaa1\",\"ē‚•ē‚Žē‚’ē‚Šē‚™ēˆ¬ēˆ­ēˆøē‰ˆē‰§ē‰©ē‹€ē‹Žē‹™ē‹—ē‹ēŽ©ēŽØēŽŸēŽ«ēŽ„ē”½ē–ē–™ē–šēš„ē›‚ē›²ē›“ēŸ„ēŸ½ē¤¾ē„€ē„ē§‰ē§ˆē©ŗē©¹ē«ŗē³¾ē½”ē¾Œē¾‹č€…č‚ŗč‚„č‚¢č‚±č‚”č‚«č‚©č‚“č‚Ŗč‚Æč‡„č‡¾čˆčŠ³čŠčŠ™čŠ­čŠ½čŠŸčŠ¹čŠ±čŠ¬čŠ„čŠÆčŠøčŠ£čŠ°čŠ¾čŠ·č™Žč™±åˆč”Ø軋čæŽčæ”čæ‘邵é‚ø邱邶采金長門阜陀é˜æ阻附\"],[\"ab40\",\"陂隹é›Ø青非äŗŸäŗ­äŗ®äæ”ä¾µä¾Æä¾æäæ äæ‘äæäæäæƒä¾¶äæ˜äæŸäæŠäæ—ä¾®äæäæ„äæ‚äæšäæŽäæžä¾·å…—冒冑冠剎剃削前剌剋則勇勉勃勁匍南卻厚叛咬哀å’Ø哎哉å’ø咦咳哇哂咽å’Ŗ品\"],[\"aba1\",\"哄哈å’Æ咫咱咻咩咧å’æå›æ垂型垠垣垢城垮垓儕儑儏儎儐姜姘å§æ姣å§Øå؃姄å§Ŗ姚姦å؁姻孩宣宦室客宄封屎屏屍屋峙峒巷åøåø„åøŸå¹½åŗ åŗ¦å»ŗå¼ˆå¼­å½„å¾ˆå¾…å¾Šå¾‹å¾‡å¾Œå¾‰ę€’ę€ę€ ę€„ę€Žę€ØꁍꁰęØę¢ę†ęƒę¬ę«ęŖę¤ę‰ę‹œęŒ–ęŒ‰ę‹¼ę‹­ęŒę‹®ę‹½ęŒ‡ę‹±ę‹·\"],[\"ac40\",\"ę‹Æę‹¬ę‹¾ę‹“ęŒ‘ęŒ‚ę”æę•…ę–«ę–½ę—¢ę˜„ę˜­ę˜ ę˜§ę˜Æꘟę˜Øę˜±ę˜¤ę›·ęŸæęŸ“ęŸ±ęŸ”ęŸęŸ¬ęž¶ęžÆęŸµęŸ©ęŸÆęŸ„ęŸ‘ęž“ęŸšęŸ„ęžøęŸęŸžęŸ³ęž°ęŸ™ęŸ¢ęŸęŸ’ę­Ŗę®ƒę®†ę®µęƒęÆ—ę°Ÿę³‰ę“‹ę“²ę“Ŗęµę“„ę“Œę“±ę“žę“—\"],[\"aca1\",\"ę“»ę“½ę“¾ę“¶ę“›ę³µę“¹ę“§ę“øꓩꓮꓵ꓎ꓫē‚«ē‚ŗē‚³ē‚¬ē‚Æē‚­ē‚øē‚®ē‚¤ēˆ°ē‰²ē‰Æē‰“ē‹©ē‹ ē‹”ēŽ·ēŠēŽ»ēŽ²ēē€ēŽ³ē”šē”­ē•ē•Œē•Žē•‹ē–«ē–¤ē–„ē–¢ē–£ē™øēš†ēš‡ēšˆē›ˆē›†ē›ƒē›…ēœē›¹ē›øēœ‰ēœ‹ē›¾ē›¼ēœ‡ēŸœē ‚ē ”ē Œē ē„†ē„‰ē„ˆē„‡ē¦¹ē¦ŗē§‘ē§’ē§‹ē©æēŖē«æē«½ē±½ē“‚ē“…ē“€ē“‰ē“‡ē“„ē“†ē¼øē¾Žē¾æ耄\"],[\"ad40\",\"č€č€č€‘č€¶čƒ–čƒ„čƒščƒƒčƒ„čƒŒčƒ”čƒ›čƒŽčƒžčƒ¤čƒč‡“čˆ¢č‹§čŒƒčŒ…č‹£č‹›č‹¦čŒ„č‹„čŒ‚čŒ‰č‹’č‹—č‹±čŒč‹œč‹”č‹‘č‹žč‹“č‹Ÿč‹ÆčŒ†č™č™¹č™»č™ŗč”č”«č¦č§”č؈č؂čØƒč²žč² čµ“čµ³č¶“č»č»Œčæ°čæ¦čæ¢čæŖčæ„\"],[\"ada1\",\"čæ­čæ«čæ¤čæØ郊郎郁郃酋酊重閂限陋陌降面革韋韭音頁é¢Ø飛食首香乘äŗ³å€Œå€å€£äæÆ倦倄äæø倩倖倆值借倚倒們äæŗ倀倔å€Øäæ±å€”個候倘äæ³äæ®å€­å€Ŗäæ¾å€«å€‰å…¼å†¤å†„冢凍凌准凋剖剜剔剛剝åŒŖåæ原厝叟å“Ø唐唁唷哼哄哲唆å“ŗ唔哩哭哔唉哮å“Ŗ\"],[\"ae40\",\"哦唧唇哽唏圃圄埂埔埋埃堉夏儗儘儚åؑåؘå؜å؟å؛åؓ姬åØ åØ£åØ©åØ„å،å؉孫屘宰害家宓宮宵容å®ø射屑展屐峭峽峻å³Ŗå³Ø峰島品峓差åø­åø«åŗ«åŗ­åŗ§å¼±å¾’å¾‘å¾ę™\"],[\"aea1\",\"ę£ę„ęę•ę­ę©ęÆę‚„ę‚Ÿę‚šę‚ę‚”ę‚Œę‚…ę‚–ę‰‡ę‹³ęŒˆę‹æęŽęŒ¾ęŒÆꍕꍂꍆꍏꍉęŒŗęęŒ½ęŒŖęŒ«ęŒØꍍꍌꕈꕉꖙꗁꗅꙂꙉꙏꙃꙒꙌꙅꙁę›øęœ”ęœ•ęœ—ę ”ę øę”ˆę”†ę”“ę ¹ę”‚ę””ę ©ę¢³ę —ę”Œę”‘ę ½ęŸ“ę”ę”€ę ¼ę”ƒę Ŗę”…ę “ę ˜ę”ę®Šę®‰ę®·ę°£ę°§ę°Øę°¦ę°¤ę³°ęµŖę¶•ę¶ˆę¶‡ęµ¦ęµø굷굙궓\"],[\"af40\",\"ęµ¬ę¶‰ęµ®ęµšęµ“ęµ©ę¶Œę¶Šęµ¹ę¶…ęµ„ę¶”ēƒŠēƒ˜ēƒ¤ēƒ™ēƒˆēƒēˆ¹ē‰¹ē‹¼ē‹¹ē‹½ē‹øē‹·ēŽ†ē­ē‰ē®ē ēŖēžē•”ē•ē•œē•šē•™ē–¾ē—…ē—‡ē–²ē–³ē–½ē–¼ē–¹ē—‚ē–øēš‹ēš°ē›Šē›ē›Žēœ©ēœŸēœ ēœØēŸ©ē °ē §ē øē ē “ē ·\"],[\"afa1\",\"ē „ē ­ē  ē Ÿē ²ē„•ē„ē„ ē„Ÿē„–ē„žē„ē„—ē„šē§¤ē§£ē§§ē§Ÿē§¦ē§©ē§˜ēŖ„ēŖˆē«™ē¬†ē¬‘ē²‰ē“”ē“—ē“‹ē“Šē“ ē“¢ē“”ē“ē“•ē“šē“œē“ē“™ē“›ē¼ŗē½Ÿē¾”ēæ…ēæč€†č€˜č€•č€™č€—č€½č€æčƒ±č„‚čƒ°č„…čƒ­čƒ“č„†čƒøčƒ³č„ˆčƒ½č„Ščƒ¼čƒÆč‡­č‡¬čˆ€čˆčˆŖ舫čˆØčˆ¬čŠ»čŒ«č’č”čŠčŒøčč‰čŒµčŒ“ččŒ²čŒ¹čŒ¶čŒ—č€čŒ±čŒØ荃\"],[\"b040\",\"虔蚊čšŖčš“čš¤čš©čšŒčš£čšœč”°č”·č¢č¢‚č”½č”¹čؘčؐč؎č،čؕč؊čؗčؓčؖč؏čØ‘č±ˆč±ŗč±¹č²”č²¢čµ·čŗ¬č»’č»”č»č¾±é€é€†čæ·é€€čæŗčæ“逃čæ½é€…čæø邕郔郝郢酒配酌釘針釗釜釙閃院陣陔\"],[\"b0a1\",\"陛陝除陘陞隻飢馬éŖØ高鬄鬲鬼乾åŗ偽停假偃偌做偉偄偶偎偕偵偓偷偏倏åÆ偭兜冕凰å‰Ŗå‰Æ勒務勘動匐匏匙åŒæå€åŒ¾åƒę›¼å•†å•Ŗ啦啄啞啔啃啊唱啖問啕å”Æ啤å”ø售啜唬啣唳啁啗圈國圉域堅堊堆埠埤åŸŗ堂堵執培夠儢åض婁婉婦å©Ŗ婀\"],[\"b140\",\"åؼ婢婚婆婊孰åƇåƅåƄåƂå®æåƆ尉專將屠屜屝哇哆哎哛哖哢哑哩哔哙哤哧哗巢åøøåø¶åø³åø·åŗ·åŗøåŗ¶åŗµåŗ¾å¼µå¼·å½—彬彩彫得徙從徘徔徠徜ęæę‚£ę‚‰ę‚ ę‚Øęƒ‹ę‚“ęƒ¦ę‚½\"],[\"b1a1\",\"ęƒ…ę‚»ę‚µęƒœę‚¼ęƒ˜ęƒ•ęƒ†ęƒŸę‚øęƒšęƒ‡ęˆšęˆ›ę‰ˆęŽ ęŽ§ę²ęŽ–ęŽ¢ęŽ„ę·ę§ęŽ˜ęŽŖę±ęŽ©ęŽ‰ęŽƒęŽ›ę«ęŽØęŽ„ęŽˆęŽ™ęŽ”ęŽ¬ęŽ’ęŽęŽ€ę»ę©ęØęŗę•ę•–ę•‘ę•™ę•—å•Ÿę•ę•˜ę••ę•”ę–œę–›ę–¬ę—ę—‹ę—Œę—Žę™ę™šę™¤ę™Øę™¦ę™žę›¹å‹—ęœ›ę¢ę¢Æę¢¢ę¢“ę¢µę”æę”¶ę¢±ę¢§ę¢—ę¢°ę¢ƒę£„ę¢­ę¢†ę¢…ę¢”ę¢ę¢Øę¢Ÿę¢”ę¢‚ę¬²ę®ŗ\"],[\"b240\",\"ęÆ«ęÆ¬ę°«ę¶Žę¶¼ę·³ę·™ę¶²ę·”ę·Œę·¤ę·»ę·ŗęø…귇귋ę¶Æę·‘ę¶®ę·žę·¹ę¶ø귷귵귅귒ęøšę¶µę·šę·«ę·˜ę·Ŗ귱귮ę·Ø귆귄ę¶Ŗę·¬ę¶æę·¦ēƒ¹ē„‰ē„Šēƒ½ēƒÆēˆ½ē‰½ēŠēŒœēŒ›ēŒ–ēŒ“ēŒ™ēŽ‡ē…ēŠēƒē†ē¾ēē“ ē“¶\"],[\"b2a1\",\"ē“·ē”œē”¢ē•„ē•¦ē•¢ē•°ē–ē—”ē—•ē–µē—Šē—ēšŽē›”ē›’ē››ēœ·ēœ¾ēœ¼ēœ¶ēœøēœŗē”«ē”ƒē”Žē„„ē„Øē„­ē§»ēŖ’ēŖ•ē¬ ē¬Øē¬›ē¬¬ē¬¦ē¬™ē¬žē¬®ē²’ē²—ē²•ēµ†ēµƒēµ±ē“®ē“¹ē“¼ēµ€ē“°ē“³ēµ„ē“Æēµ‚ē“²ē“±ē¼½ē¾žē¾šēæŒēæŽēæ’č€œčŠč†č„Æč„–č„£č„«č„©č„°č„¤čˆ‚čˆµčˆ·čˆ¶čˆ¹čŽŽčŽžčŽ˜čøčŽ¢čŽ–čŽ½čŽ«čŽ’čŽŠčŽ“čŽ‰čŽ č·č»č¼\"],[\"b340\",\"莆莧處å½Ŗ蛇蛀蚶蛄蚵蛆蛋蚱čšÆč›‰č”“č¢žč¢ˆč¢«č¢’č¢–č¢č¢‹č¦“č¦čØŖč؝čØ£čØ„čرčØ­č؟č؛čØ¢č±‰č±šč²©č²¬č²«č²Øč²Ŗč²§čµ§čµ¦č¶¾č¶ŗč»›č»Ÿé€™é€é€šé€—é€£é€Ÿé€é€é€•é€žé€ é€é€¢é€–é€›é€”\"],[\"b3a1\",\"éƒØ郭都酗野釵釦釣釧釭釩閉é™Ŗ陵陳é™ø陰陓陶陷陬雀é›Ŗ雩ē« ē«Ÿé ‚頃魚鳄鹵é¹æéŗ„éŗ»å‚¢å‚å‚…å‚™å‚‘å‚€å‚–å‚˜å‚šęœ€å‡±å‰²å‰“創剩勞勝勛博厄啻喀喧啼喊喝喘喂喜å–Ŗ喔喇喋喃喳單喟唾喲喚喻喬喱啾喉喫喙圍å Æå Ŗ堓堤堰報堔堝堠壹å£ŗå„ \"],[\"b440\",\"å©·åŖšå©æåŖ’åŖ›åŖ§å­³å­±åƒåƌåƓåƐ尊尋就嵌嵐哓嵇巽幅åø½å¹€å¹ƒå¹¾å»Šå»å»‚廄弼彭復å¾Ŗå¾Øęƒ‘ęƒ”ę‚²ę‚¶ęƒ ę„œę„£ęƒŗę„•ęƒ°ęƒ»ęƒ“ę…Øęƒ±ę„Žęƒ¶ę„‰ę„€ę„’ęˆŸę‰‰ęŽ£ęŽŒęę€ę©ę‰ę†ę\"],[\"b4a1\",\"ę’ę£ęę”ę–ę­ę®ę¶ę“ęŖę›ę‘’ęšę¹ę•žę•¦ę•¢ę•£ę–‘ę–ę–Æꙮ꙰ꙓꙶę™Æꚑę™ŗę™¾ę™·ę›¾ę›æꜟꜝę£ŗę£•ę£ ę£˜ę£—ę¤…ę£Ÿę£µę£®ę£§ę£¹ę£’ę£²ę££ę£‹ę£ę¤ę¤’ę¤Žę£‰ę£šę„®ę£»ę¬¾ę¬ŗę¬½ę®˜ę®–ę®¼ęÆÆę°®ę°Æę°¬ęøÆęøøę¹”ęø”ęø²ę¹§ę¹Šęø ęø„ęø£ęø›ę¹›ę¹˜ęø¤ę¹–ę¹®ęø­ęø¦ę¹Æęø“ę¹ęøŗęø¬ę¹ƒęøęø¾ę»‹\"],[\"b540\",\"ęŗ‰ęø™ę¹Žę¹£ę¹„ę¹²ę¹©ę¹Ÿē„™ē„šē„¦ē„°ē„”ē„¶ē…®ē„œē‰ŒēŠ„ēŠ€ēŒ¶ēŒ„ēŒ“ēŒ©ēŗēŖē³ē¢ē„ēµē¶ē“ēÆē›ē¦ēØē”„ē”¦ē•«ē•Ŗē—¢ē—›ē—£ē—™ē—˜ē—žē— ē™»ē™¼ēš–ēš“ēš“ē›œēēŸ­ē”ē”¬ē”Æē؍ē؈ē؋ē؅ē؀ēŖ˜\"],[\"b5a1\",\"ēŖ—ēŖ–ē«„ē«£ē­‰ē­–ē­†ē­ē­’ē­”ē­ē­‹ē­ē­‘ē²Ÿē²„ēµžēµēµØēµ•ē“«ēµ®ēµ²ēµ”ēµ¦ēµ¢ēµ°ēµ³å–„ēæ”ēæ•č€‹č’č‚…č…•č…”č…‹č…‘č…Žč„¹č…†č„¾č…Œč…“č…“čˆ’čˆœč©čƒčø萍菠菅萋菁čÆč±č“č‘—čŠč°čŒčŒč½č²čŠčøčŽč„čœč‡č”čŸč™›č›Ÿč›™č›­č›”č››č›¤č›č›žč”—č£č£‚č¢±č¦ƒč¦–čØ»č© č©•č©žčØ¼č©\"],[\"b640\",\"詔詛詐詆čØ“čØŗčØ¶č©–č±”č²‚č²Æč²¼č²³č²½č³č²»č³€č²“č²·č²¶č²æč²øč¶Šč¶…č¶č·Žč·č·‹č·šč·‘č·Œč·›č·†č»»č»øč»¼č¾œé€®é€µé€±é€ø進逶鄂郵鄉郾酣酄量鈔鈕鈣鈉鈞鈍鈐鈇鈑閔閏開閑\"],[\"b6a1\",\"間閒閎隊階隋陽隅隆隍陲隄雁雅雄集雇é›Æ雲韌項順須飧é£Ŗé£Æ飩飲飭馮馭黃黍黑äŗ‚傭債傲傳僅傾催傷傻å‚Æ僇å‰æ剷剽募勦勤勢勣åŒÆ嗟å—Ø嗓嗦嗎嗜嗇嗑嗣嗤å—Æ嗚嗔嗅嗆嗄嗉園圓唞唑唘唗唚唔唫唌唭唊唢唒唋儧嫁嫉嫌åŖ¾åŖ½åŖ¼\"],[\"b740\",\"åŖ³å«‚åŖ²åµ©åµÆå¹Œå¹¹å»‰å»ˆå¼’å½™å¾¬å¾®ę„šę„ę…ˆę„Ÿęƒ³ę„›ęƒ¹ę„ę„ˆę…Žę…Œę…„ę…ę„¾ę„“ę„§ę„ę„†ę„·ęˆ”ęˆ¢ę“ę¾ęžęŖę­ę½ę¬ęęœę”ęę¶ę–ę—ę†ę•¬ę–Ÿę–°ęš—ęš‰ęš‡ęšˆęš–ęš„ęš˜ęšęœƒę¦”ę„­\"],[\"b7a1\",\"ꄚꄷꄠꄔꄵꤰꦂꄊę„Øę„«ę„žę„“ę„¹ę¦†ę„ę„£ę„›ę­‡ę­²ęƀę®æęƓęƽęŗ¢ęŗÆ껓ęŗ¶ę»‚ęŗęŗę»‡ę»…ęŗ„ęŗ˜ęŗ¼ęŗŗęŗ«ę»‘ęŗ–ęŗœę»„ę»”ęŗŖęŗ§ęŗ“ē…Žē…™ē…©ē…¤ē…‰ē…§ē…œē…¬ē…¦ē…Œē…„ē…žē…†ē…Øē…–ēˆŗē‰’ēŒ·ē…ēŒæēŒ¾ē‘Æē‘šē‘•ē‘Ÿē‘žē‘ēæē‘™ē‘›ē‘œē•¶ē•øē˜€ē—°ē˜ē—²ē—±ē—ŗē—æē—“ē—³ē›žē›Ÿē›ē«ē¦ēžē£\"],[\"b840\",\"ē¹ēŖē¬ēœē„ēØē¢ēŸ®ē¢Žē¢°ē¢—ē¢˜ē¢Œē¢‰ē”¼ē¢‘ē¢“ē”æē„ŗē„æē¦č¬ē¦½ē؜ēؚēØ ēؔē؟ē؞ēŖŸēŖ ē­·ēƀē­ ē­®ē­§ē²±ē²³ē²µē¶“ēµ¹ē¶‘ē¶ē¶ēµ›ē½®ē½©ē½Ŗē½²ē¾©ē¾Øē¾¤č–č˜č‚†č‚„č…±č…°č…øč…„č…®č…³č…«\"],[\"b8a1\",\"č…¹č…ŗč…¦čˆ…č‰‡č’‚č‘·č½č±č‘µč‘¦č‘«č‘‰č‘¬č‘›č¼čµč‘”č‘£č‘©č‘­č‘†č™žč™œč™Ÿč›¹čœ“čœˆčœ‡čœ€č›¾č›»čœ‚čœƒčœ†čœŠč”™č£Ÿč£”č£™č£œč£˜č£č£”č£Šč£•č£’č¦œč§£č©«č©²č©³č©¦č©©č©°čŖ‡č©¼č©£čŖ č©±čŖ…č©­č©¢č©®č©¬č©¹č©»čؾč©Øč±¢č²Šč²‰č³Šč³‡č³ˆč³„č²²č³ƒč³‚č³…č·”č·Ÿč·Øč·Æč·³č·ŗč·Ŗ跤跦čŗ²č¼ƒč¼‰č»¾č¼Š\"],[\"b940\",\"č¾Ÿč¾²é‹éŠé“é‚é”é€¼é•éé‡ééŽéé‘é€¾éé„’é„—é…¬é…Ŗ酩釉鈷鉗éˆø鈽鉀鈾鉛鉋鉤鉑鈓鉉鉍鉅鈹éˆæ鉚閘隘隔隕雍雋雉雊雷電雹零靖靓靶預頑頓頊頒頌飼飓\"],[\"b9a1\",\"飽飾馳馱馓體鳩éŗ‚鼎鼓鼠僧僮僄僖僭僚僕像僑僱僎僩兢凳劃劂匱厭嗾嘀嘛嘗嗽嘔嘆嘉嘍嘎嗷嘖嘟嘈嘐嗶團圖唵唾境墓墊唹墅唽壽处夢夤å„Ŗ儩嫔嫦嫩嫗嫖嫘嫣孵åƞåƧåÆ”åÆ„åƦåÆØåÆ¢åƤåÆŸå°å±¢å¶„å¶‡å¹›å¹£å¹•å¹—å¹”å»“å»–å¼Šå½†å½°å¾¹ę…‡\"],[\"ba40\",\"ę„æę…‹ę…·ę…¢ę…£ę…Ÿę…šę…˜ę…µęˆŖꒇꑘꑔ꒤ę‘øꑟę‘ŗę‘‘ę‘§ę“ę‘­ę‘»ę•²ę–”ę——ę—–ęš¢ęšØęšę¦œę¦Øę¦•ę§ę¦®ę§“ę§‹ę¦›ę¦·ę¦»ę¦«ę¦“ę§ę§ę¦­ę§Œę¦¦ę§ƒę¦£ę­‰ę­Œę°³ę¼³ę¼”ę»¾ę¼“ę»“ę¼©ę¼¾ę¼ ę¼¬ę¼ę¼‚ę¼¢\"],[\"baa1\",\"ę»æę»Æę¼†ę¼±ę¼øę¼²ę¼£ę¼•ę¼«ę¼Æę¾ˆę¼Ŗę»¬ę¼ę»²ę»Œę»·ē†”ē†™ē…½ē†Šē†„ē†’ēˆ¾ēŠ’ēŠ–ē„ēē‘¤ē‘£ē‘Ŗē‘°ē‘­ē”„ē–‘ē˜§ē˜ē˜‹ē˜‰ē˜“ē›”ē›£ēž„ē½ēæē”ē£ē¢Ÿē¢§ē¢³ē¢©ē¢£ē¦Žē¦ē¦ēØ®ēرēŖŖēŖ©ē«­ē«Æē®”ē®•ē®‹ē­µē®—ē®ē®”ē®ē®øē®‡ē®„ē²¹ē²½ē²¾ē¶»ē¶°ē¶œē¶½ē¶¾ē¶ ē·Šē¶“ē¶²ē¶±ē¶ŗē¶¢ē¶æē¶µē¶øē¶­ē·’ē·‡ē¶¬\"],[\"bb40\",\"ē½°ēæ ēæ”ēæŸčžčšč‚‡č…č†€č†č†ˆč†Šč…æ膂臧č‡ŗ與舔舞艋蓉č’æč“†č“„č’™č’žč’²č’œč“‹č’øč“€č““č’č’¼č“‘č“Ščœæčœœčœ»čœ¢čœ„čœ“čœ˜č•čœ·čœ©č£³č¤‚č£“č£¹č£øč£½č£Ø褚č£ÆčŖ¦čŖŒčŖžčŖ£čŖčŖ”čŖ“čŖ¤\"],[\"bba1\",\"čŖŖčŖ„čŖØčŖ˜čŖ‘čŖščŖ§č±Ŗč²č²Œč³“č³‘č³’čµ«č¶™č¶•č·¼č¼”č¼’č¼•č¼“č¾£é é˜éœé£é™éžé¢éé›é„™é„˜é„žé…µé…øé…·é…“é‰ø銀銅銘銖鉻銓銜éŠØ鉼銑閔é–Ø閩閣閄閤隙障際雌雒需靼鞅韶頗領é¢Æ颱餃餅餌餉駁éŖÆéŖ°é«¦é­é­‚鳓鳶鳳éŗ¼é¼»é½Šå„„儀僻僵價儂儈儉儅凜\"],[\"bc40\",\"劇劈劉劍劊勰厲嘮嘻嘹嘲å˜æ嘓嘩噓噎噗噓嘶å˜Æ嘰墀墟增墳墜墮墩墦儭嬉嫻嬋嫵嬌嬈åÆ®åƬåÆ©åÆ«å±¤å±„å¶å¶”å¹¢å¹Ÿå¹”å»¢å»šå»Ÿå»å»£å» å½ˆå½±å¾·å¾µę…¶ę…§ę…®ę…ę…•ę†‚\"],[\"bca1\",\"ę…¼ę…°ę…«ę…¾ę†§ę†ę†«ę†Žę†¬ę†šę†¤ę†”ę†®ęˆ®ę‘©ę‘Æę‘¹ę’žę’²ę’ˆę’ę’°ę’„ę’“ę’•ę’©ę’’ę’®ę’­ę’«ę’šę’¬ę’™ę’¢ę’³ę•µę•·ę•øꚮꚫꚓꚱęØ£ę؟ę§Øę؁ę؞ęØ™ę§½ęØ”ęؓęØŠę§³ę؂ęØ…ę§­ęØ‘ę­ę­Žę®¤ęƅęƆę¼æę½¼ę¾„ę½‘ę½¦ę½”ę¾†ę½­ę½›ę½øę½®ę¾Žę½ŗę½°ę½¤ę¾—ę½˜ę»•ę½Æę½ ę½Ÿē†Ÿē†¬ē†±ē†Øē‰–ēŠ›ēŽē—ē‘©ē’‹ē’ƒ\"],[\"bd40\",\"ē‘¾ē’€ē•æē˜ ē˜©ē˜Ÿē˜¤ē˜¦ē˜”ē˜¢ēššēšŗē›¤ēžŽēž‡ēžŒēž‘ēž‹ē£‹ē£…ē¢ŗē£Šē¢¾ē£•ē¢¼ē£ēØæēؼē©€ēؽēØ·ēØ»ēŖÆēŖ®ē®­ē®±ēƄē®“ēƆēƇēƁē® ēƌē³Šē· ē·“ē·Æē·»ē·˜ē·¬ē·ē·Øē·£ē·šē·žē·©ē¶žē·™ē·²ē·¹ē½µē½·ē¾Æ\"],[\"bda1\",\"ēæ©č€¦č†›č†œč†č† č†šč†˜č”—č”½č”šč“®č”¬č”­č”“č”‘č”£č””蔔蓬蔄č“æč”†čž‚č“č¶č č¦čøčØč™č—čŒč“č”›č”č¤č¤‡č¤’č¤“č¤•č¤ŠčŖ¼č«’談諄čŖ•č«‹č«øčŖ²č«‰č«‚čŖæčŖ°č«–č«čŖ¶čŖ¹č«›č±Œč±Žč±¬č³ č³žč³¦č³¤č³¬č³­č³¢č³£č³œč³Ŗč³”čµ­č¶Ÿč¶£čø«čøčøčø¢čøčø©čøŸčø”čøžčŗŗč¼č¼›č¼Ÿč¼©č¼¦č¼Ŗč¼œč¼ž\"],[\"be40\",\"č¼„é©é®éØ遭遷鄰鄭鄧鄱醇醉醋醃鋅銻銷é‹Ŗ銬鋤鋁銳銼鋒鋇鋰銲閭閱霄霆震霉靠鞍鞋鞏頔頫頜颳養餓餒餘駝駐駟駛駑駕駒駙éŖ·é«®é«Æ鬧魅魄魷é­Æ铆铉\"],[\"bea1\",\"铃éŗ©éŗ¾é»Žå¢Ø齒儒儘儔儐儕冀å†Ŗ凝劑劓勳噙噫噹噩噤å™øå™Ŗå™Ø噄噱å™Æ噬噢噶壁墾壇壅儮嬝嬓å­øåÆ°å°Žå½Šę†²ę†‘ę†©ę†Šę‡ę†¶ę†¾ę‡Šę‡ˆęˆ°ę“…ę“ę“‹ę’»ę’¼ę“šę“„ę“‡ę“‚ę“ę’æę“’ę“”ę’¾ę•“ę›†ę›‰ęš¹ę›„ę›‡ęšøęؽęØøęØŗę©™ę©«ę©˜ęØ¹ę©„ę©¢ę©”ę©‹ę©‡ęØµę©Ÿę©ˆę­™ę­·ę°…ęæ‚ę¾±ę¾”\"],[\"bf40\",\"ęæƒę¾¤ęæę¾§ę¾³ęæ€ę¾¹ę¾¶ę¾¦ę¾ ę¾“ē†¾ē‡‰ē‡ē‡’ē‡ˆē‡•ē†¹ē‡Žē‡™ē‡œē‡ƒē‡„ēØē’œē’£ē’˜ē’Ÿē’žē“¢ē”Œē”ē˜“ē˜øē˜ŗē›§ē›„ēž ēžžēžŸēž„ē£Øē£šē£¬ē£§ē¦¦ē©ē©Žē©†ē©Œē©‹ēŖŗēƙē°‘ēƉēƤēƛēÆ”ēÆ©ēƦē³•ē³–ēøŠ\"],[\"bfa1\",\"ēø‘ēøˆēø›ēø£ēøžēøēø‰ēøē½¹ē¾²ēæ°ēæ±ēæ®č€Øč†³č†©č†Øč‡»čˆˆč‰˜č‰™č•Šč•™č•ˆč•Øč•©č•ƒč•‰č•­č•Ŗč•žčžƒčžŸčžžčž¢čžč””č¤Ŗč¤²č¤„č¤«č¤”č¦Ŗ覦諦č«ŗč««č«±č¬€č«œč«§č«®č«¾č¬č¬‚č«·č«­č«³č«¶č«¼č±«č±­č²“č³“č¹„čø±čø“č¹‚čø¹čøµč¼»č¼Æč¼øč¼³č¾Øč¾¦éµé“éø遲遼éŗ鄓醒錠錶é‹ø錳éŒÆ錢鋼錫錄錚\"],[\"c040\",\"錐錦錔錕錮錙閻隧éšØéšŖ雕霎霑霖霍霓霏靛靜靦鞘頰é ø頻頷頭頹頤餐é¤Ø餞餛餔餚駭駢駱éŖøéŖ¼é«»é«­é¬Ø鮑铕铣铦é“Ø铒铛默黔龍龜å„Ŗ償儔儲勵嚎嚀嚐嚅嚇\"],[\"c0a1\",\"嚏壕壓壑壎嬰å¬Ŗ嬤å­ŗå°·å±Ø嶼å¶ŗ嶽å¶øå¹«å½Œå¾½ę‡‰ę‡‚ę‡‡ę‡¦ę‡‹ęˆ²ęˆ“ę“Žę“Šę“˜ę“ ę“°ę“¦ę“¬ę“±ę“¢ę“­ę–‚ę–ƒę›™ę›–ęŖ€ęŖ”ęŖ„ęŖ¢ęŖœę«›ęŖ£ę©¾ęŖ—ęŖęŖ ę­œę®®ęÆšę°ˆęæ˜ęæ±ęæŸęæ ęæ›ęæ¤ęæ«ęæÆę¾€ęæ¬ęæ”ęæ©ęæ•ęæ®ęæ°ē‡§ē‡Ÿē‡®ē‡¦ē‡„ē‡­ē‡¬ē‡“ē‡ ēˆµē‰†ē°ē²ē’©ē’°ē’¦ē’Øē™†ē™‚ē™Œē›Ŗēž³ēžŖēž°ēž¬\"],[\"c140\",\"ēž§ēž­ēŸÆē£·ē£ŗē£“ē£Æē¤ē¦§ē¦Ŗē©—ēŖæē°‡ē°ēƾēÆ·ē°ŒēÆ ē³ ē³œē³žē³¢ē³Ÿē³™ē³ēø®ēø¾ē¹†ēø·ēø²ē¹ƒēø«ēø½ēø±ē¹…ē¹ēø“ēø¹ē¹ˆēøµēøæēøÆē½„ēæ³ēæ¼č±č²č°čÆč³č‡†č‡ƒč†ŗ臂臀č†æč†½č‡‰č†¾č‡Øčˆ‰č‰±č–Ŗ\"],[\"c1a1\",\"č–„č•¾č–œč–‘č–”č–Æ薛薇č–Øč–Šč™§čŸ€čŸ‘čž³čŸ’čŸ†čž«čž»čžŗčŸˆčŸ‹č¤»č¤¶č„„č¤øč¤½č¦¬č¬Žč¬—č¬™č¬›č¬Šč¬ č¬č¬„č¬č±č°æč±³č³ŗč³½č³¼č³øč³»č¶Øč¹‰č¹‹č¹ˆč¹Šč½„č¼¾č½‚č½…č¼æéæ遽還邁邂邀鄹醣醞醜鍍鎂éŒØ鍵鍊鍄鍋錘鍾鍬鍛鍰鍚鍔闊闋闌闈闆隱éšø雖霜霞鞠韓锆颶餵é؁\"],[\"c240\",\"é§æ鮮鮫é®Ŗé®­é“»é“æéŗ‹é»é»žé»œé»é»›é¼¾é½‹å¢åš•åš®å£™å£˜å¬øå½ę‡£ęˆ³ę““ę“²ę“¾ę”†ę“ŗę“»ę“·ę–·ę›œęœ¦ęŖ³ęŖ¬ę«ƒęŖ»ęŖøę«‚ęŖ®ęŖÆꭟę­øę®Æē€‰ē€‹ęæ¾ē€†ęæŗē€‘ē€ē‡»ē‡¼ē‡¾ē‡øē·ēµē’§ē’æē”•ē™–ē™˜\"],[\"c2a1\",\"ē™’ēž½ēžæēž»ēž¼ē¤Žē¦®ē©”ē©¢ē© ē«„ē«…ē°«ē°§ē°Ŗē°žē°£ē°”ē³§ē¹”ē¹•ē¹žē¹šē¹”ē¹’ē¹™ē½ˆēæ¹ēæ»č·č¶č‡č‡čˆŠč—č–©č—č—č—‰č–°č–ŗč–¹č–¦čŸÆčŸ¬čŸ²čŸ č¦†č¦²č§“č¬Øč¬¹č¬¬č¬«č±č“…č¹™č¹£č¹¦č¹¤č¹Ÿč¹•č»€č½‰č½é‚‡é‚ƒé‚ˆé†«é†¬é‡éŽ”éŽŠéŽ–éŽ¢éŽ³éŽ®éŽ¬éŽ°éŽ˜éŽšéŽ—é—”é—–é—é—•é›¢é›œé›™é››é›žéœ¤éž£éž¦\"],[\"c340\",\"鞭韹锍锏锌锎锓é¢ŗ餾é¤æ餽餮馄é؎髁鬃鬆魏魎魍éƊéƉéƽéƈéƀ鵑鵝鵠黠鼕鼬儳嚄壞壟壢åÆµé¾å»¬ę‡²ę‡·ę‡¶ę‡µę”€ę”ę› ę›ę«„ę«ę«šę«“ē€›ē€Ÿē€Øē€šē€ē€•ē€˜ēˆ†ēˆē‰˜ēŠ¢ēø\"],[\"c3a1\",\"ēŗē’½ē“Šē“£ē–‡ē–†ē™Ÿē™”ēŸ‡ē¤™ē¦±ē©«ē©©ē°¾ē°æē°øē°½ē°·ē±€ē¹«ē¹­ē¹¹ē¹©ē¹Ŗē¾…ē¹³ē¾¶ē¾¹ē¾øč‡˜č—©č—č—Ŗč—•č—¤č—„č—·čŸ»č …č čŸ¹čŸ¾č„ č„Ÿč„–č„žč­č­œč­˜č­‰č­šč­Žč­č­†č­™č“ˆč“Šč¹¼č¹²čŗ‡č¹¶č¹¬č¹ŗč¹“č½”č½Žč¾­é‚Šé‚‹é†±é†®é”é‘éŸéƒéˆéœéé–é¢éé˜é¤é—éØ關隓難éœŖ霧靔韜韻锞\"],[\"c440\",\"锘锛颼鄅鄉éؖéؙ鬍éÆØéƧéƖéƛ鶉鵔鵲éµŖ鵬éŗ’éŗ—éŗ“éŗ“å‹øåšØ嚷嚶嚓嚼壤孀孃孽åƶ巉ę‡øę‡ŗę”˜ę””ę”™ę›¦ęœ§ę«¬ē€¾ē€°ē€²ēˆē»ē“ē™¢ē™„ē¤¦ē¤Ŗē¤¬ē¤«ē«‡ē«¶ē±Œē±ƒē±ē³Æē³°č¾®ē¹½ē¹¼\"],[\"c4a1\",\"ēŗ‚ē½Œč€€č‡šč‰¦č—»č—¹č˜‘č—ŗč˜†č˜‹č˜‡č˜Šč ”č •č„¤č¦ŗč§ø議譬警č­Æč­Ÿč­«č“č“čŗ‰čŗčŗ…čŗ‚醓釋鐘鐃鏽闔霰飄鄒鄑é¦ØéØ«éØ°éØ·éص鰓鰍鹹éŗµé»Øé¼Æ齟齣齔儷å„øå›å›€å›‚å¤”å±¬å·ę‡¼ę‡¾ę”ę”œę–•ę›©ę«»ę¬„ę«ŗę®²ēŒēˆ›ēŠ§ē“–ē“”ē™©ēŸ“ē±ēŗēŗŒē¾¼č˜—č˜­č˜šč £č ¢č ”蠟č„Ŗč„¬č¦½č­“\"],[\"c540\",\"č­·č­½č““čŗŠčŗčŗ‹č½Ÿč¾Æé†ŗ鐮鐳鐵éŗéø鐲鐫闢éœø霹露éŸæ锧锄鄗驅驃驀éؾ髏魔魑鰭鰄é¶Æ鶓鷂é¶øéŗé»Æ鼙齜齦齧儼儻囈囊囉å­æ巔巒彎ę‡æꔤꬊꭔē‘ē˜ēŽ€ē“¤ē–Šē™®ē™¬\"],[\"c5a1\",\"ē¦³ē± ē±Ÿč¾č½č‡Ÿč„²č„Æč§¼č®€č“–č“—čŗ‘čŗ“č½”酈鑄鑑鑒霽霾韃韁锫鄕驕驍髒鬚鱉鰱鰾鰻鷓鷗鼓齬é½Ŗé¾”å›Œå·–ęˆ€ę”£ę”«ę”Ŗꛬ꬐ē“šē«Šē±¤ē±£ē±„ēŗ“ēŗ–ēŗ”č‡¢č˜øč˜æč ±č®Šé‚é‚é‘£é‘ é‘¤éØé”Æ鄜驚驛驗髓體髑鱔鱗鱖鷄éŗŸé»“å›‘å£©ę”¬ēžē™±ē™²ēŸ—ē½ē¾ˆč ¶č ¹č”¢č®“č®’\"],[\"c640\",\"讖艷蓛釀é‘Ŗ靂靈靄韆锰驟鬢魘鱟鷹é·ŗé¹¼é¹½é¼‡é½·é½²å»³ę¬–ē£ē±¬ē±®č »č§€čŗ”釁鑲鑰锱鄞髖鬣黌ē¤ēŸšč®šé‘·éŸ‰é©¢é©„ēŗœč®œčŗŖ釅鑽鑾鑼鱷é±øé»·č±”é‘æéøšēˆØé©Ŗ鬱éø›éøžē±²\"],[\"c940\",\"乂乜凵匚厂äø‡äøŒä¹‡äŗå›—ļ،屮彳äøå†‡äøŽäø®äŗ“仂仉仈冘勼卬厹圠夃夬尐å·æę—”ę®³ęÆŒę°”ēˆæäø±äø¼ä»Ø仜仩仔仝仚刌匜卌圢圣夗å¤Æ宁宄尒尻屓屳åø„åŗ€åŗ‚åæ‰ęˆ‰ę‰ę°•\"],[\"c9a1\",\"갶걃ę°æę°»ēŠ®ēŠ°ēŽŠē¦øč‚Šé˜žä¼Žä¼˜ä¼¬ä»µä¼”ä»±ä¼€ä»·ä¼ˆä¼ä¼‚ä¼…ä¼¢ä¼“ä¼„ä»“ä¼’å†±åˆ“åˆ‰åˆåŠ¦åŒ¢åŒŸååŽŠå‡å›”å›Ÿåœ®åœŖ圓夼妀儼妅儻儾儷å„æå­–å°•å°„å±¼å±ŗ屻屾巟幵åŗ„异弚当åæ•åæ”åæę‰œę‰žę‰¤ę‰”ę‰¦ę‰¢ę‰™ę‰ ę‰šę‰„ę—Æę—®ęœ¾ęœ¹ęœøęœ»ęœŗęœæęœ¼ęœ³ę°˜ę±†ę±’ę±œę±ę±Šę±”ę±‹\"],[\"ca40\",\"ę±Œē±ē‰žēŠ“ēŠµēŽŽē”Ŗē™æē©µē½‘č‰øč‰¼čŠ€č‰½č‰æč™č„¾é‚™é‚—é‚˜é‚›é‚”é˜¢é˜¤é˜ é˜£ä½–ä¼»ä½¢ä½‰ä½“ä½¤ä¼¾ä½§ä½’ä½Ÿä½ä½˜ä¼­ä¼³ä¼æ佔冏冹刜刞刔劭劮匉卣卲厎厏吰吷åŖ呔呅吙吜各吘\"],[\"caa1\",\"吽呏呁åØ吤呇囮囧囄坁坅坌坉坋坒夆儀妦妘妠妗妎妢妐妏妧妔宎宒å°Øå°Ŗ岍岏岈岋岉岒岊岆岓岕巠åøŠåøŽåŗ‹åŗ‰åŗŒåŗˆåŗå¼…弝å½ø彶åæ’åæ‘åæåæ­åæØåæ®åæ³åæ”åæ¤åæ£åæŗåæÆåæ·åæ»ę€€åæ“ęˆŗęŠƒęŠŒęŠŽęŠęŠ”ęŠ‡ę‰±ę‰»ę‰ŗę‰°ęŠęŠˆę‰·ę‰½ę‰²ę‰“ę”·ę—°ę—“ę—³ę—²ę—µę…ę‡\"],[\"cb40\",\"ꝙꝕꝌꝈꝝꝍꝚꝋęÆę°™ę°šę±øę±§ę±«ę²„ę²‹ę²ę±±ę±Æę±©ę²šę±­ę²‡ę²•ę²œę±¦ę±³ę±„ę±»ę²Žē“ēŗē‰£ēŠæēŠ½ē‹ƒē‹†ē‹ēŠŗē‹…ēŽ•ēŽ—ēŽ“ēŽ”ēŽ’ē”ŗē”¹ē–”ē–•ēšē¤½č€“肕肙肐肒肜芐芏芅芎芑芓\"],[\"cba1\",\"芊芃芄č±øčæ‰č¾æ邟邔還邞邧邠阰é˜Øé˜Æ阭äø³ä¾˜ä½¼ä¾…佽侀侇佶体侉侄佷佌侗ä½Ŗ侚佹侁ä½ø侐侜侔侞侒侂侕佫佮冞冼冾刵刲刳剆刱劼匊匋匼厒厔咇å‘æ咁咑咂咈呫å‘ŗ呾呄呬呓呦咍å‘Æ呔呠咘呣呧呤囷囹åÆ坲坭坫坱坰坶垀坵坻坳坓坢\"],[\"cc40\",\"åØ坽夌儅妵å¦ŗ姏姎妲姌姁妶妼姃姖妱妽姀姈妓姇孢孄宓宕屄屇岮岤岠岵å²Æå²Ø岬岟岣岭岢å²Ŗ岧岝岄岶岰岦åø—åø”åø™å¼Ø弢弣弤彔徂彾彽åæžåæ„ę€­ę€¦ę€™ę€²ę€‹\"],[\"cca1\",\"ę€“ę€Šę€—ę€³ę€šę€žę€¬ę€¢ę€ę€ę€®ę€“ę€‘ę€Œę€‰ę€œęˆ”ęˆ½ęŠ­ęŠ“ę‹‘ęŠ¾ęŠŖęŠ¶ę‹ŠęŠ®ęŠ³ęŠÆꊻꊩꊰęŠøę”½ę–Øę–»ę˜‰ę—¼ę˜„ę˜’ę˜ˆę—»ę˜ƒę˜‹ę˜ę˜…ę—½ę˜‘ę˜ę›¶ęœŠęž…ę¬ęžŽęž’ę¶ę»ęž˜ęž†ęž„ę“ęžęžŒęŗęžŸęž‘ęž™ęžƒę½ęžęøę¹ęž”ę¬„ę®€ę­¾ęÆžę°ę²“ę³¬ę³«ę³®ę³™ę²¶ę³”ę²­ę³§ę²·ę³ę³‚ę²ŗę³ƒę³†ę³­ę³²\"],[\"cd40\",\"ę³’ę³ę²“ę²Šę²ę²€ę³žę³€ę“°ę³ę³‡ę²°ę³¹ę³ę³©ę³‘ē‚”ē‚˜ē‚…ē‚“ē‚†ē‚„ē‚‘ē‚–ē‚‚ē‚šē‚ƒē‰Ŗē‹–ē‹‹ē‹˜ē‹‰ē‹œē‹’ē‹”ē‹šē‹Œē‹‘ēŽ¤ēŽ”ēŽ­ēŽ¦ēŽ¢ēŽ ēŽ¬ēŽē“ē“Øē”æē•€ē”¾ē–Œē–˜ēšÆē›³ē›±ē›°ē›µēŸøēŸ¼ēŸ¹ēŸ»ēŸŗ\"],[\"cda1\",\"ēŸ·ē„‚ē¤æē§…ē©øē©»ē«»ē±µē³½č€µč‚č‚®č‚£č‚øč‚µč‚­čˆ čŠ č‹€čŠ«čŠščŠ˜čŠ›čŠµčŠ§čŠ®čŠ¼čŠžčŠŗ芓čŠØčŠ”čŠ©č‹‚čŠ¤č‹ƒčŠ¶čŠ¢č™°č™Æ虭虮豖čæ’čæ‹čæ“čæčæ–čæ•čæ—邲邓é‚Æ邳邰阹阽阼é˜ŗ陃äæäæ…äæ“ä¾²äæ‰äæ‹äæäæ”äæœäæ™ä¾»ä¾³äæ›äæ‡äæ–ä¾ŗäæ€ä¾¹äæ¬å‰„剉勀勂匽卼厗厖厙厘å’ŗ咔咭咄哏\"],[\"ce40\",\"å“ƒčŒå’·å’®å“–å’¶å“…å“†å’ å‘°å’¼å’¢å’¾å‘²å“žå’°åžµåžžåžŸåž¤åžŒåž—åžåž›åž”åž˜åžåž™åž„åžšåž•å£“å¤å„“å§”å§žå§®å؀姱姝å§ŗ姽姼姶姤姲姷姛姩姳姵姠姾姓姭å®Ø屌峐峘峌峗峋峛\"],[\"cea1\",\"峞峚峉峇峊峖峓峔峏峈峆峎峟å³øå·¹åø”åø¢åø£åø åø¤åŗ°åŗ¤åŗ¢åŗ›åŗ£åŗ„å¼‡å¼®å½–å¾†ę€·ę€¹ę”ę²ęžę…ę“ę‡ę‰ę›ęŒę€ę‚ęŸę€¤ę„ę˜ę¦ę®ę‰‚ę‰ƒę‹ęŒęŒ‹ę‹µęŒŽęŒƒę‹«ę‹¹ęŒęŒŒę‹øę‹¶ęŒ€ęŒ“ęŒ”ę‹ŗęŒ•ę‹»ę‹°ę•ę•ƒę–Ŗę–æę˜¶ę˜”ę˜²ę˜µę˜œę˜¦ę˜¢ę˜³ę˜«ę˜ŗę˜ę˜“ę˜¹ę˜®ęœęœęŸęŸ²ęŸˆęžŗ\"],[\"cf40\",\"ęŸœęž»ęŸøęŸ˜ęŸ€ęž·ęŸ…ęŸ«ęŸ¤ęŸŸęžµęŸęž³ęŸ·ęŸ¶ęŸ®ęŸ£ęŸ‚ęž¹ęŸŽęŸ§ęŸ°ęž²ęŸ¼ęŸ†ęŸ­ęŸŒęž®ęŸ¦ęŸ›ęŸŗꟉꟊꟃęŸŖꟋę¬ØꮂꮄꮶęƖęƘęÆ ę° ę°”ę“Øę““ę“­ę“Ÿę“¼ę“æę“’ę“Šę³šę“³ę“„ę“™ę“ŗę“šę“‘ę“€ę“ęµ‚\"],[\"cfa1\",\"ę“ę“˜ę“·ę“ƒę“ęµ€ę“‡ę“ ę“¬ę“ˆę“¢ę“‰ę“ē‚·ē‚Ÿē‚¾ē‚±ē‚°ē‚”ē‚“ē‚µē‚©ē‰ē‰‰ē‰Šē‰¬ē‰°ē‰³ē‰®ē‹Šē‹¤ē‹Øē‹«ē‹Ÿē‹Ŗē‹¦ē‹£ēŽ…ēŒē‚ēˆē…ēŽ¹ēŽ¶ēŽµēŽ“ē«ēŽæē‡ēŽ¾ēƒē†ēŽøē‹ē“¬ē“®ē”®ē•‡ē•ˆē–§ē–Ŗē™¹ē›„ēœˆēœƒēœ„ēœ…ēœŠē›·ē›»ē›ŗēŸ§ēŸØē †ē ‘ē ’ē …ē ē ē Žē ‰ē ƒē “ē„Šē„Œē„‹ē„…ē„„ē§•ē§ē§ē§–ē§ŽēŖ€\"],[\"d040\",\"ē©¾ē«‘ē¬€ē¬ē±ŗē±øē±¹ē±æē²€ē²ē“ƒē“ˆē“ē½˜ē¾‘ē¾ē¾¾č€‡č€Žč€č€”č€·čƒ˜čƒ‡čƒ čƒ‘čƒˆčƒ‚čƒčƒ…čƒ£čƒ™čƒœčƒŠčƒ•čƒ‰čƒčƒ—čƒ¦čƒč‡æčˆ”čŠ”č‹™č‹¾č‹¹čŒ‡č‹Ø茀苕čŒŗč‹«č‹–č‹“č‹¬č‹”č‹²č‹µčŒŒč‹»č‹¶č‹°č‹Ŗ\"],[\"d0a1\",\"苤苠č‹ŗč‹³č‹­č™·č™“č™¼č™³č”č”Žč”§č”Ŗ蔩觓č؄čØ‡čµ²čæ£čæ”čæ®čæ éƒ±é‚½é‚æ郕郅邾郇郋郈釔釓陔陏陑陓陊陎倞倅倇倓倢倰倛äæµäæ“倳倷倬äæ¶äæ·å€—倜倠倧倵å€Æ倱倎党冔冓凊凄凅凈凎剔剚剒剞剟剕剢勍匎厞唦哢唗唒哧哳哤唚å“æ唄唈哫唑唅哱\"],[\"d140\",\"唊哻哷å“ø哠唎唃唋圁圂埌堲埕埒åžŗ埆垽垼åžø垶åžæ埇埐垹埁夎儊åؙåؖåØ­åØ®åؕå؏åؗå؊å؞åس孬宧宭宬尃屖屔峬å³æ峮峱峷哀峹åø©åøØåŗØåŗ®åŗŖåŗ¬å¼³å¼°å½§ęęšę§\"],[\"d1a1\",\"ęę‚¢ę‚ˆę‚€ę‚’ę‚ę‚ę‚ƒę‚•ę‚›ę‚—ę‚‡ę‚œę‚Žęˆ™ę‰†ę‹²ęŒę–ęŒ¬ę„ę…ęŒ¶ęƒę¤ęŒ¹ę‹ęŠęŒ¼ęŒ©ęęŒ“ę˜ę”ę™ęŒ­ę‡ęŒ³ęšę‘ęŒøę—ę€ęˆę•Šę•†ę—†ę—ƒę—„ę—‚ę™Šę™Ÿę™‡ę™‘ęœ’ęœ“ę Ÿę šę”‰ę ²ę ³ę »ę”‹ę”ę –ę ±ę œę µę «ę ­ę Æę”Žę”„ę “ę ę ’ę ”ę ¦ę Øę ®ę”ę ŗꠄꠠꬬę¬Æę¬­ę¬±ę¬“ę­­č‚‚ę®ˆęƦęƤ\"],[\"d240\",\"ęÆØęÆ£ęÆ¢ęÆ§ę°„ęµŗęµ£ęµ¤ęµ¶ę“ęµ”ę¶’ęµ˜ęµ¢ęµ­ęµÆę¶‘ę¶ę·Æęµæę¶†ęµžęµ§ęµ ę¶—ęµ°ęµ¼ęµŸę¶‚ę¶˜ę“ÆęµØę¶‹ęµ¾ę¶€ę¶„ę“–ę¶ƒęµ»ęµ½ęµµę¶ēƒœēƒ“ēƒ‘ēƒēƒ‹ē¼¹ēƒ¢ēƒ—ēƒ’ēƒžēƒ ēƒ”ēƒēƒ…ēƒ†ēƒ‡ēƒšēƒŽēƒ”ē‰‚ē‰ø\"],[\"d2a1\",\"ē‰·ē‰¶ēŒ€ē‹ŗē‹“ē‹¾ē‹¶ē‹³ē‹»ēŒē“ē™ē„ē–ēŽ¼ē§ē£ē©ēœē’ē›ē”ēēšē—ē˜ēØē“žē“Ÿē““ē“µē””ē•›ē•Ÿē–°ē—ē–»ē—„ē—€ē–æē–¶ē–ŗēšŠē›‰ēœēœ›ēœēœ“ēœ’ēœ£ēœ‘ēœ•ēœ™ēœšēœ¢ēœ§ē £ē ¬ē ¢ē µē Æē Øē ®ē «ē ”ē ©ē ³ē Ŗē ±ē„”ē„›ē„ē„œē„“ē„’ē„‘ē§«ē§¬ē§ ē§®ē§­ē§Ŗē§œē§žē§ēŖ†ēŖ‰ēŖ…ēŖ‹ēŖŒēŖŠēŖ‡ē«˜ē¬\"],[\"d340\",\"ē¬„ē¬“ē¬…ē¬ē¬ˆē¬Šē¬Žē¬‰ē¬’ē²„ē²‘ē²Šē²Œē²ˆē²ē²…ē“žē“ē“‘ē“Žē“˜ē“–ē““ē“Ÿē“’ē“ē“Œē½œē½”ē½žē½ ē½ē½›ē¾–ē¾’ēæƒēæ‚ēæ€č€–č€¾č€¹čƒŗčƒ²čƒ¹čƒµč„čƒ»č„€čˆčˆÆčˆ„čŒ³čŒ­č„čŒ™č‘čŒ„č–čŒæččŒ¦čŒœčŒ¢\"],[\"d3a1\",\"荂荎茛čŒŖčŒˆčŒ¼ččŒ–čŒ¤čŒ čŒ·čŒÆčŒ©č‡č…čŒč“čŒžčŒ¬č‹čŒ§čˆč™“č™’čš¢čšØčš–čščš‘čšžčš‡čš—čš†čš‹čšščš…čš„čš™čš”čš§čš•čš˜čšŽčščščš”č”ƒč”„č”­č”µč”¶č”²č¢€č”±č”æč”Æč¢ƒč”¾č”“č”¼čØ’č±‡č±—č±»č²¤č²£čµ¶čµø趵趷趶軑軓čæ¾čæµé€‚čææčæ»é€„čæ¼čæ¶éƒ–郠郙郚郣郟郄郘郛郗郜郤酐\"],[\"d440\",\"酎酏釕釢釚陜陟隼飣髟é¬Æä¹æ偰åŖ偔偞偠偓偋偝偲偈偍偁偛偊偢倕偅偟偩偫偣偤偆偀偮偳偗偑凐剫剭剬剮勖勓匭厜啵啶唼啍啐唓å”Ŗ啑啢唶唵唰啒啅\"],[\"d4a1\",\"唌唲啄啎唹啈唭唻啀啋圊圇埻堔埢埶埜埓堀埭埽堈åŸø堋埳埏堇埮埣埲埄埬埔堎埼堐埧堁堌埱埩埰堍堄儜婠婘婕婧婞åØøåص婭婐婟婄婬婓婤婗婃婝婒婄婛婈åŖŽåؾ婍åع婌婰婩婇婑婖婂婜孲孮åƁåƀ屙哞哋哝哚哠哌å“Ø响哦哄哏\"],[\"d540\",\"哰哒哣哟哮åø¾åø“åŗ±åŗ“åŗ¹åŗ²åŗ³å¼¶å¼øå¾›å¾–å¾Ÿę‚Šę‚ę‚†ę‚¾ę‚°ę‚ŗęƒ“ęƒ”ęƒęƒ¤ęƒ™ęƒęƒˆę‚±ęƒ›ę‚·ęƒŠę‚æęƒƒęƒęƒ€ęŒ²ę„ęŽŠęŽ‚ę½ęŽ½ęŽžęŽ­ęŽęŽ—ęŽ«ęŽŽęÆęŽ‡ęŽę®ęŽÆęµęŽœę­ęŽ®ę¼ęŽ¤ęŒ»ęŽŸ\"],[\"d5a1\",\"ęøęŽ…ęŽęŽ‘ęŽę°ę•“ę—ę™„ę™”ę™›ę™™ę™œę™¢ęœ˜ę”¹ę¢‡ę¢ę¢œę”­ę”®ę¢®ę¢«ę„–ę”Æę¢£ę¢¬ę¢©ę”µę”“ę¢²ę¢ę”·ę¢’ę”¼ę”«ę”²ę¢Ŗę¢€ę”±ę”¾ę¢›ę¢–ę¢‹ę¢ ę¢‰ę¢¤ę”øę”»ę¢‘ę¢Œę¢Šę”½ę¬¶ę¬³ę¬·ę¬øę®‘ę®ę®ę®Žę®Œę°Ŗę·€ę¶«ę¶“ę¶³ę¹“ę¶¬ę·©ę·¢ę¶·ę·¶ę·”ęø€ę·ˆę· ę·Ÿę·–ę¶¾ę·„ę·œę·ę·›ę·“ę·Šę¶½ę·­ę·°ę¶ŗę·•ę·‚ę·ę·‰\"],[\"d640\",\"ę·ę·²ę·“ę·½ę·—ę·ę·£ę¶»ēƒŗē„ēƒ·ē„—ēƒ“ē„Œēƒ°ē„„ēƒ³ē„ēƒ¼ēƒæē„†ē„“ē„€ēƒøēƒ¶ē„‹ē„‚ē„Žē‰¾ē‰»ē‰¼ē‰æēŒēŒ—ēŒ‡ēŒ‘ēŒ˜ēŒŠēŒˆē‹æēŒēŒžēŽˆē¶ēøēµē„ēē½ē‡ē€ēŗē¼ēæēŒē‹ē“ēˆē•¤ē•£ē—Žē—’ē—\"],[\"d6a1\",\"ē—‹ē—Œē—‘ē—ēšēš‰ē›“ēœ¹ēœÆēœ­ēœ±ēœ²ēœ“ēœ³ēœ½ēœ„ēœ»ēœµē”ˆē”’ē”‰ē”ē”Šē”Œē ¦ē”…ē”ē„¤ē„§ē„©ē„Ŗē„£ē„«ē„”ē¦»ē§ŗē§øē§¶ē§·ēŖēŖ”ēŖē¬µē­‡ē¬“ē¬„ē¬°ē¬¢ē¬¤ē¬³ē¬˜ē¬Ŗē¬ē¬±ē¬«ē¬­ē¬Æē¬²ē¬øē¬šē¬£ē²”ē²˜ē²–ē²£ē“µē“½ē“øē“¶ē“ŗēµ…ē“¬ē“©ēµēµ‡ē“¾ē“æēµŠē“»ē“Øē½£ē¾•ē¾œē¾ē¾›ēæŠēæ‹ēæēæēæ‘ēæ‡ēæēæ‰č€Ÿ\"],[\"d740\",\"č€žč€›č‡čƒčˆč„˜č„„č„™č„›č„­č„Ÿč„¬č„žč„”č„•č„§č„č„¢čˆ‘čˆøčˆ³čˆŗčˆ“čˆ²č‰“čŽčŽ£čŽØ莍čŗč³čŽ¤č“čŽčŽčŽ•čŽ™čµčŽ”čŽ©č½čŽƒčŽŒčŽčŽ›čŽŖčŽ‹č¾čŽ„čŽÆ莈莗莰čæčŽ¦čŽ‡čŽ®č¶čŽšč™™č™–čšæčš·\"],[\"d7a1\",\"蛂蛁蛅čšŗčš°č›ˆčš¹čš³čšøč›Œčš“čš»čš¼č›ƒčš½čš¾č”’č¢‰č¢•č¢Øč¢¢č¢Ŗč¢šč¢‘č¢”č¢Ÿč¢˜č¢§č¢™č¢›č¢—č¢¤č¢¬č¢Œč¢“č¢Žč¦‚č§–č§™č§•čØ°čاčجčØžč°¹č°»č±œč±č±½č²„čµ½čµ»čµ¹č¶¼č·‚č¶¹č¶æč·č»˜č»žč»č»œč»—č» č»”é€¤é€‹é€‘é€œé€Œé€”éƒÆéƒŖ郰郓郲郳郔郫郬郩酖酘酚酓酕釬釓釱釳é‡ø釤釹é‡Ŗ\"],[\"d840\",\"釫釷é‡Ø釮é•ŗ閆閈陼陭陫陱é™ÆéšæéŖ頄飄馗傛傕傔傞傋傣傃傌傎傝åØ傜傒傂傇兟凔匒匑厤厧喑å–Ø善喭啷噅喢喓喈喏喵喁喣喒喤啽喌喦å•æ喕喔喎圌堩堷\"],[\"d8a1\",\"堙堞堧堣å Ø埵唈堄堜堛堳å æ堶堮堹å ø堭堬堻儔åŖÆåŖ”åŖŸå©ŗåŖ¢åŖžå©øåŖ¦å©¼åŖ„åŖ¬åŖ•åŖ®åØ·åŖ„åŖŠåŖ—åŖƒåŖ‹åŖ©å©»å©½åŖŒåŖœåŖåŖ“åŖåÆŖåƍåƋåƔåƑåƊåƎ尌尰哷嵃嵫嵁嵋å“æ哵嵑嵎嵕哳å“ŗ嵒哽哱嵙嵂哹嵉å“øå“¼å“²å“¶åµ€åµ…å¹„å¹å½˜å¾¦å¾„å¾«ęƒ‰ę‚¹ęƒŒęƒ¢ęƒŽęƒ„ę„”\"],[\"d940\",\"ęƒ²ę„Šę„–ę„…ęƒµę„“ęƒøęƒ¼ęƒ¾ęƒę„ƒę„˜ę„ę„ęƒæę„„ę„‹ę‰ŠęŽ”ęŽ±ęŽ°ęŽę„ęØęÆęƒę’ę³ęŠę ę¶ę•ę²ęµę‘”ęŸęŽ¾ęęœę„ę˜ę“ę‚ę‡ęŒę‹ęˆę°ę—ę™ę”²ę•§ę•Ŗꕤꕜę•Øę•„ę–Œę–ę–žę–®ę—ę—’\"],[\"d9a1\",\"ę™¼ę™¬ę™»ęš€ę™±ę™¹ę™Ŗę™²ęœę¤Œę£“ę¤„ę£œę¤Ŗę£¬ę£Ŗę£±ę¤ę£–ę£·ę£«ę£¤ę£¶ę¤“ę¤ę£³ę£”ę¤‡ę£Œę¤ˆę„°ę¢“ę¤‘ę£Æę£†ę¤”ę£øę£ę£½ę£¼ę£Øę¤‹ę¤Šę¤—ę£Žę£ˆę£ę£žę£¦ę£“ę£‘ę¤†ę£”ę£©ę¤•ę¤„ę£‡ę¬¹ę¬»ę¬æę¬¼ę®”ę®—ę®™ę®•ę®½ęÆ°ęƲęÆ³ę°°ę·¼ę¹†ę¹‡ęøŸę¹‰ęŗˆęø¼ęø½ę¹…ę¹¢ęø«ęøæę¹ę¹ę¹³ęøœęø³ę¹‹ę¹€ę¹‘ęø»ęøƒęø®ę¹ž\"],[\"da40\",\"ę¹Øę¹œę¹”ęø±ęøØę¹ ę¹±ę¹«ęø¹ęø¢ęø°ę¹“ę¹„ęø§ę¹øę¹¤ę¹·ę¹•ę¹¹ę¹’ę¹¦ęøµęø¶ę¹šē„ ē„žē„Æēƒ»ē„®ē„±ē„£ē„„ē„¢ē„²ē„Ÿē„Øē„ŗē„›ē‰‹ē‰šēŠˆēŠ‰ēŠ†ēŠ…ēŠ‹ēŒ’ēŒ‹ēŒ°ēŒ¢ēŒ±ēŒ³ēŒ§ēŒ²ēŒ­ēŒ¦ēŒ£ēŒµēŒŒē®ē¬ē°ē«ē–\"],[\"daa1\",\"ēšē”ē­ē±ē¤ē£ēē©ē ē²ē“»ē”Æē•Æē•¬ē—§ē—šē—”ē—¦ē—ē—Ÿē—¤ē——ēš•ēš’ē›šē†ē‡ē„ēē…ēŠēŽē‹ēŒēŸžēŸ¬ē” ē”¤ē”„ē”œē”­ē”±ē”Ŗē”®ē”°ē”©ē”Øē”žē”¢ē„“ē„³ē„²ē„°ē؂ē؊ē؃ē،ē؄ēŖ™ē«¦ē«¤ē­Šē¬»ē­„ē­ˆē­Œē­Žē­€ē­˜ē­…ē²¢ē²žē²Øē²”ēµ˜ēµÆēµ£ēµ“ēµ–ēµ§ēµŖēµēµ­ēµœēµ«ēµ’ēµ”ēµ©ēµ‘ēµŸēµŽē¼¾ē¼æē½„\"],[\"db40\",\"ē½¦ē¾¢ē¾ ē¾”ēæ—č‘čččƒ¾čƒ”č…ƒč…Šč…’č…č…‡č„½č…č„ŗ臦臮臷č‡øč‡¹čˆ„čˆ¼čˆ½čˆæč‰µčŒ»čč¹č£č€čØč’č§č¤č¼č¶čč†čˆč«č£čŽæččč„č˜čæč”č‹čŽč–čµč‰č‰ččžč‘č†č‚č³\"],[\"dba1\",\"菕čŗ菇菑čŖč“čƒč¬č®č„č»č—č¢č›č›č¾č›˜č›¢č›¦č›“č›£č›šč›Ŗč›č›«č›œč›¬č›©č›—č›Øč›‘č”ˆč”–č”•č¢ŗč£—č¢¹č¢øč£€č¢¾č¢¶č¢¼č¢·č¢½č¢²č¤č£‰č¦•č¦˜č¦—č§č§šč§›č©Žč©čØ¹č©™č©€č©—č©˜č©„č©…č©’č©ˆč©‘č©Šč©Œč©č±Ÿč²č²€č²ŗč²¾č²°č²¹č²µč¶„č¶€č¶‰č·˜č·“č·č·‡č·–č·œč·č·•č·™č·ˆč·—č·…č»Æč»·č»ŗ\"],[\"dc40\",\"č»¹č»¦č»®č»„č»µč»§č»Ø軶軫軱軬軓軩逭逓é€Æ鄆鄬鄄éƒæ郼鄈郹郻鄁鄀鄇鄅鄃酔酤酟酢酠鈁鈊鈄鈃鈚鈦鈏鈌鈀鈒é‡æ釽鈆鈄鈧鈂鈜鈤鈙鈗鈅鈖镻閍閌閐隇陾隈\"],[\"dca1\",\"隉隃隀雂雈雃雱雰靬靰靮頇颩飫鳦黹äŗƒäŗ„äŗ¶å‚½å‚æ僆傮僄僊傓僈僂傰僁å‚ŗ傱僋僉傶å‚ø凗å‰ŗå‰ø剻剼嗃嗛嗌嗐嗋嗊嗝嗀嗔嗄嗩å–æ嗒喍嗏嗕嗢嗖嗈嗲嗍嗙嗂圔唓å”Ø唤唏唍唉å”Æ唕唎唝唙唄唛堽唣唱壼嫇嫄嫋åŖŗåŖøåŖ±åŖµåŖ°åŖæ嫈åŖ»å«†\"],[\"dd40\",\"åŖ·å«€å«ŠåŖ“åŖ¶å«åŖ¹åŖåƖåƘåƙ尟尳嵱嵣嵊嵄嵲嵬嵞åµØ嵧嵢巰幏幎幊幍幋廅廌廆廋廇彀å¾Æå¾­ęƒ·ę…‰ę…Šę„«ę……ę„¶ę„²ę„®ę…†ę„Æę…ę„©ę…€ęˆ é…Øęˆ£ęˆ„ęˆ¤ę…ę±ę«ęę’ę‰ę ę¤\"],[\"dda1\",\"ę³ę‘ƒęŸę•ę˜ę¹ę·ę¢ę£ęŒę¦ę°ęØꑁꐵęÆęŠęšę‘€ę„ę§ę‹ę§ę›ę®ę”ęŽę•ÆꖒꗓꚆꚌꚕꚐꚋꚊꚙꚔę™øęœ ę„¦ę„Ÿę¤øę„Žę„¢ę„±ę¤æę„…ę„Ŗę¤¹ę„‚ę„—ę„™ę„ŗę„ˆę„‰ę¤µę„¬ę¤³ę¤½ę„„ę£°ę„øꤓꄩꄀę„Æę„„ę„¶ę„˜ę„ę„“ę„Œę¤»ę„‹ę¤·ę„œę„ę„‘ę¤²ę„’ę¤Æę„»ę¤¼ę­†ę­…ę­ƒę­‚ę­ˆę­ę®›ļ؍ęÆ»ęƼ\"],[\"de40\",\"ęƹęÆ·ęÆøęŗ›ę»–ę»ˆęŗę»€ęŗŸęŗ“ęŗ”ęŗ ęŗ±ęŗ¹ę»†ę»’ęŗ½ę»ęŗžę»‰ęŗ·ęŗ°ę»ęŗ¦ę»ęŗ²ęŗ¾ę»ƒę»œę»˜ęŗ™ęŗ’ęŗŽęŗęŗ¤ęŗ”ęŗæęŗ³ę»ę»Šęŗ—ęŗ®ęŗ£ē…‡ē…”ē…’ē…£ē… ē…ē…ē…¢ē…²ē…øē…Ŗē…”ē…‚ē…˜ē…ƒē…‹ē…°ē…Ÿē…ē…“\"],[\"dea1\",\"ē…„ē…ē…šē‰ēŠēŠŒēŠ‘ēŠēŠŽēŒ¼ē‚ēŒ»ēŒŗē€ēŠē‰ē‘„ē‘Šē‘‹ē‘’ē‘‘ē‘—ē‘€ē‘ē‘ē‘Žē‘‚ē‘†ē‘ē‘”ē“”ē“æē“¾ē“½ē”ē•¹ē•·ę¦ƒē—Æē˜ē˜ƒē—·ē—¾ē—¼ē—¹ē—øē˜ē—»ē—¶ē—­ē—µē—½ēš™ēšµē›ē•ēŸē ē’ē–ēšē©ē§ē”ē™ē­ēŸ ē¢‡ē¢šē¢”ē¢ē¢„ē¢•ē¢…ē¢†ē¢”ē¢ƒē”¹ē¢™ē¢€ē¢–ē”»ē„¼ē¦‚ē„½ē„¹ēؑēؘēؙēؒēؗēؕēØ¢ēؓ\"],[\"df40\",\"ē؛ēؐēŖ£ēŖ¢ēŖžē««ē­¦ē­¤ē­­ē­“ē­©ē­²ē­„ē­³ē­±ē­°ē­”ē­øē­¶ē­£ē²²ē²“ē²Æē¶ˆē¶†ē¶€ē¶ēµæē¶…ēµŗē¶Žēµ»ē¶ƒēµ¼ē¶Œē¶”ē¶„ēµ½ē¶’ē½­ē½«ē½§ē½Øē½¬ē¾¦ē¾„ē¾§ēæ›ēæœč€”č…¤č… č…·č…œč…©č…›č…¢č…²ęœ”č…žč…¶č…§č…Æ\"],[\"dfa1\",\"č…„č…”čˆč‰‰č‰„č‰€č‰‚č‰…č“±čæč‘–č‘¶č‘¹č’č’č‘„č‘‘č‘€č’†č‘§č°č‘č‘½č‘šč‘™č‘“č‘³č‘č”‡č‘žč·čŗ萓č‘ŗ葃č‘øč²č‘…č©č™č‘‹čÆč‘‚č­č‘Ÿč‘°č¹č‘Žč‘Œč‘’č‘Æč“…č’Žč»č‘‡č¶č³č‘Øč‘¾č‘„č«č‘ č‘”č‘®č‘čœ‹čœ„č›·čœŒč›ŗč›–č›µčč›øčœŽčœ‰čœč›¶čœčœ…č£–č£‹č£č£Žč£žč£›č£šč£Œč£č¦…č¦›č§Ÿč§„č§¤\"],[\"e040\",\"č§”č§ č§¢č§œč§¦č©¶čŖ†č©æč©”čØæč©·čŖ‚čŖ„詵čŖƒčŖč©“č©ŗč°¼č±‹č±Šč±„č±¤č±¦č²†č²„č²…č³ŒčµØčµ©č¶‘č¶Œč¶Žč¶č¶č¶“č¶”č¶č¶’č·°č· č·¬č·±č·®č·č·©č·£č·¢č·§č·²č·«č·“č¼†č»æč¼č¼€č¼…č¼‡č¼ˆč¼‚č¼‹é’é€æ\"],[\"e0a1\",\"遄遉逽鄐鄍鄏鄑鄖鄔鄋鄎酮é…Æ鉈鉒鈰éˆŗ鉦鈳鉄鉞銃鈮鉊鉆鉭鉬鉏鉠鉧é‰Æ鈶鉔鉰鈱鉔鉣鉐鉲鉎鉓鉌鉖鈲閟閜閞閛隒隓隑隗雎é›ŗ雽é›ø雵靳靷éø靲頏頍頎颬飶飹é¦Æ馲馰馵éŖ­éŖ«é­›é³Ŗ鳭鳧éŗ€é»½åƒ¦åƒ”僗åƒØ僳僛åƒŖ僝僤僓僬僰åƒÆ僣僠\"],[\"e140\",\"凘劀劁勩勫匰厬嘧嘕嘌嘒嗼嘏嘜嘁嘓嘂å—ŗ嘝嘄å—æ嗹墉唼墐墘墆墁å”æ唓墋å”ŗ墇墑墎唶墂墈唻墔墏壾儫嫜嫮嫄嫕å«Ŗ嫚嫭嫫嫳嫢嫠嫛嫬嫞嫝嫙å«Ø嫟孷åÆ \"],[\"e1a1\",\"åƣ屣嶂嶀嵽嶆åµŗ嶁嵷嶊嶉嶈嵾嵼嶍嵹åµæ幘幙幓廘廑廗廎廜廕廙廒廔彄彃å½Æå¾¶ę„¬ę„Øę…ę…žę…±ę…³ę…’ę…“ę…²ę…¬ę†€ę…“ę…”ę…ŗꅛꅄꄻę…Ŗę…”ę…–ęˆ©ęˆ§ęˆ«ę«ę‘ę‘›ę‘ę‘“ę‘¶ę‘²ę‘³ę‘½ę‘µę‘¦ę’¦ę‘Žę’‚ę‘žę‘œę‘‹ę‘“ę‘ ę‘ę‘æęæę‘¬ę‘«ę‘™ę‘„ę‘·ę•³ę– ęš”ęš ęšŸęœ…ęœ„ęœ¢ę¦±ę¦¶ę§‰\"],[\"e240\",\"ę¦ ę§Žę¦–ę¦°ę¦¬ę¦¼ę¦‘ę¦™ę¦Žę¦§ę¦ę¦©ę¦¾ę¦Æę¦æę§„ę¦½ę¦¤ę§”ę¦¹ę§Šę¦šę§ę¦³ę¦“ę¦Ŗę¦”ę¦žę§™ę¦—ę¦ę§‚ę¦µę¦„ę§†ę­Šę­ę­‹ę®žę®Ÿę® ęƃęƄęÆ¾ę»Žę»µę»±ę¼ƒę¼„ę»øę¼·ę»»ę¼®ę¼‰ę½Žę¼™ę¼šę¼§ę¼˜ę¼»ę¼’ę»­ę¼Š\"],[\"e2a1\",\"ę¼¶ę½³ę»¹ę»®ę¼­ę½€ę¼°ę¼¼ę¼µę»«ę¼‡ę¼Žę½ƒę¼…ę»½ę»¶ę¼¹ę¼œę»¼ę¼ŗę¼Ÿę¼ę¼žę¼ˆę¼”ē†‡ē†ē†‰ē†€ē†…ē†‚ē†ē…»ē††ē†ē†—ē‰„ē‰“ēŠ—ēŠ•ēŠ“ēƒēē‘ēŒē‘¢ē‘³ē‘±ē‘µē‘²ē‘§ē‘®ē”€ē”‚ē”ƒē•½ē–ē˜–ē˜ˆē˜Œē˜•ē˜‘ē˜Šē˜”ēšøēžē¼ēž…ēž‚ē®ēž€ēÆē¾ēžƒē¢²ē¢Ŗē¢“ē¢­ē¢Øē”¾ē¢«ē¢žē¢„ē¢ ē¢¬ē¢¢ē¢¤ē¦˜ē¦Šē¦‹ē¦–ē¦•ē¦”ē¦“\"],[\"e340\",\"ē¦—ē¦ˆē¦’ē¦ēØ«ē©ŠēØ°ēØÆēØØēئēŖØēŖ«ēŖ¬ē«®ē®ˆē®œē®Šē®‘ē®ē®–ē®ē®Œē®›ē®Žē®…ē®˜åŠ„ē®™ē®¤ē®‚ē²»ē²æē²¼ē²ŗē¶§ē¶·ē·‚ē¶£ē¶Ŗē·ē·€ē·…ē¶ē·Žē·„ē·†ē·‹ē·Œē¶Æē¶¹ē¶–ē¶¼ē¶Ÿē¶¦ē¶®ē¶©ē¶”ē·‰ē½³ēæ¢ēæ£ēæ„ēæž\"],[\"e3a1\",\"č€¤ččœč†‰č††č†ƒč†‡č†č†Œč†‹čˆ•č’—č’¤č’”č’Ÿč’ŗč“Žč“‚č’¬č’®č’«č’¹č’“č“č“č’Ŗč’šč’±č“č’č’§č’»č’¢č’”č“‡č“Œč’›č’©č’Æč’Øč“–č’˜č’¶č“č’ č“—č“”č“’č“›č’°č’‘č™”čœ³čœ£čœØč«č€čœ®čœžčœ”čœ™čœ›čƒčœ¬ččœ¾č†čœ čœ²čœŖčœ­čœ¼čœ’čœŗčœ±čœµč‚čœ¦čœ§čœøčœ¤čœščœ°čœ‘č£·č£§č£±č£²č£ŗč£¾č£®č£¼č£¶č£»\"],[\"e440\",\"č£°č£¬č£«č¦č¦”č¦Ÿč¦žč§©č§«č§ØčŖ«čŖ™čŖ‹čŖ’čŖčŖ–č°½č±Øč±©č³•č³č³—č¶–čø‰čø‚č·æčøč·½čøŠčøƒčø‡čø†čø…č·¾čø€čø„č¼č¼‘č¼Žč¼é„£é„œé„ é„¢é„Ÿé„é„šé„¤é„”鄛é…ŗ酲酹酳銄銤鉶銛é‰ŗ銠銔éŠŖ銍\"],[\"e4a1\",\"銦銚銫鉹銗é‰æ銣鋮銎銂銕銢鉽銈銔銊銆銌銙銧鉾銇銩銝銋鈭隞隔é›æ靘靽éŗ靾鞃鞀鞂靻鞄鞁éæ韎韍頖颭颮餂餀餇馝馜駃馹馻é¦ŗ駂馽駇éŖ±é«£é«§é¬¾é¬æ魠魔魟鳱鳲鳵éŗ§åƒæ儃儰åƒø儆儇僶僾儋儌僽儊劋劌勱å‹Æ噈噂噌嘵噁噊噉噆噘\"],[\"e540\",\"噚噀嘳嘽嘬嘾å˜øå˜Ŗå˜ŗ圚墫墝墱墠墣å¢Æ墬墄墔å£æå«æ嫓嫽嫷嫶嬃å«ø嬂嫹嬁嬇嬅嬏屧嶙嶗嶟嶒嶢嶓嶕嶠嶜嶔嶚嶞幩幝幠幜ē·³å»›å»žå»”å½‰å¾²ę†‹ę†ƒę…¹ę†±ę†°ę†¢ę†‰\"],[\"e5a1\",\"ꆛꆓę†Æꆭꆟꆒę†Ŗę†”ę†ę…¦ę†³ęˆ­ę‘®ę‘°ę’–ę’ ę’…ę’—ę’œę’ę’‹ę’Šę’Œę’£ę’Ÿę‘Øę’±ę’˜ę•¶ę•ŗę•¹ę•»ę–²ę–³ęšµęš°ęš©ęš²ęš·ęšŖęšÆę؀ę؆ęØ—ę§„ę§øęØ•ę§±ę§¤ęØ ę§æę§¬ę§¢ę؛ęØę§¾ęØ§ę§²ę§®ęØ”ę§·ę§§ę©€ęØˆę§¦ę§»ęØę§¼ę§«ę؉ę؄ęؘęØ„ęØę§¶ęئęØ‡ę§“ęØ–ę­‘ę®„ę®£ę®¢ę®¦ę°ę°€ęÆæę°‚ę½ę¼¦ę½¾ę¾‡ęæ†ę¾’\"],[\"e640\",\"ę¾ę¾‰ę¾Œę½¢ę½ę¾…ę½šę¾–ę½¶ę½¬ę¾‚ę½•ę½²ę½’ę½ę½—ę¾”ę¾“ę½ę¼€ę½”ę½«ę½½ę½§ę¾ę½“ę¾‹ę½©ę½æę¾•ę½£ę½·ę½Ŗę½»ē†²ē†Æē†›ē†°ē† ē†šē†©ē†µē†ē†„ē†žē†¤ē†”ē†Ŗē†œē†§ē†³ēŠ˜ēŠšē˜ē’ēžēŸē ēē›ē”ēšē™\"],[\"e6a1\",\"ē¢ē’‡ē’‰ē’Šē’†ē’ē‘½ē’…ē’ˆē‘¼ē‘¹ē”ˆē”‡ē•¾ē˜„ē˜žē˜™ē˜ē˜œē˜£ē˜šē˜Øē˜›ēšœēšēšžēš›ēžēžēž‰ēžˆē£ē¢»ē£ē£Œē£‘ē£Žē£”ē£ˆē£ƒē£„ē£‰ē¦šē¦”ē¦ ē¦œē¦¢ē¦›ę­¶ēعēŖ²ēŖ“ēŖ³ē®·ēƋē®¾ē®¬ēƎē®Æē®¹ēƊē®µē³…ē³ˆē³Œē³‹ē··ē·›ē·Ŗē·§ē·—ē·”ēøƒē·ŗē·¦ē·¶ē·±ē·°ē·®ē·Ÿē½¶ē¾¬ē¾°ē¾­ēæ­ēæ«ēæŖēæ¬ēæ¦ēæØč¤č§č†£č†Ÿ\"],[\"e740\",\"č†žč†•č†¢č†™č†—čˆ–č‰č‰“č‰’č‰č‰Žč‰‘č”¤č”»č”č”€č”©č”Žč”‰č”č”Ÿč”Šč”§č”œč“»č”«č“ŗč”ˆč”Œč““č”Ŗč“²č”•č“·č“«č“³č“¼č”’č“Ŗč“©č”–č“¾č”Øč”č”®č”‚č“½č”žč“¶č”±č”¦č“§č“Ø蓰č“Æč“¹č”˜č” č”°č”‹č”™č”Æč™¢\"],[\"e7a1\",\"č–č£č¤č·čŸ”č³č˜č”č›č’č”čšč‘čžč­čŖ蝐蝎蝟蝝čÆč¬čŗč®čœč„čč»čµč¢č§č©č”šč¤…č¤Œč¤”č¤‹č¤—č¤˜č¤™č¤†č¤–č¤‘č¤Žč¤‰č¦¢č¦¤č¦£č§­č§°č§¬č«č«†čŖø諓諑諔諕čŖ»č«—čŖ¾č«€č«…č«˜č«ƒčŖŗčŖ½č«™č°¾č±č²č³„č³Ÿč³™č³Øč³šč³č³§č¶ č¶œč¶”č¶›čø čø£čø„čø¤čø®čø•čø›čø–čø‘čø™čø¦čø§\"],[\"e840\",\"čø”čø’čø˜čø“čøœčø—čøšč¼¬č¼¤č¼˜č¼šč¼ č¼£č¼–č¼—é³é°éÆ遧遫é„Æ鄫鄩é„Ŗ鄲鄦鄮醅醆醊醁醂醄醀鋐鋃鋄鋀鋙銶鋏鋱鋟鋘鋩鋗鋝鋌é‹Æ鋂é‹Ø鋊鋈鋎鋦鋍鋕鋉鋠鋞鋧鋑鋓\"],[\"e8a1\",\"銵鋔鋆銓镼閬閫閮閰隤隢雓霅霈霂靚鞊鞎鞈韐韏頞頝頦頩é Ø頠頛頧颲餈é£ŗ餑餔餖餗餕駜駍駏駓駔駎駉駖駘駋駗駌éŖ³é«¬é««é«³é«²é«±é­†é­ƒé­§é­“魱魦魶魵魰é­Ø魤魬鳼é³ŗé³½é³æ鳷铇铀鳹鳻铈铅铄éŗƒé»“鼏鼐儜儓儗儚儑凞匓叔噰噠噮\"],[\"e940\",\"噳噦噣噭噲噞噷圜圛壈墽壉å¢æå¢ŗ壂墼壆嬗嬙嬛嬔嬔嬓嬐嬖å¬Ø嬚嬠嬞åÆÆ嶬嶱嶩嶧嶵嶰嶮å¶Ŗå¶Ø嶲嶭å¶Æ嶓幧å¹Ø幦å¹Æ廩廧廦å»Øå»„å½‹å¾¼ę†ę†Øę†–ę‡…ę†“ę‡†ę‡ę‡Œę†ŗ\"],[\"e9a1\",\"ę†æę†øę†Œę“—ę“–ę“ę“ę“‰ę’½ę’‰ę“ƒę“›ę“³ę“™ę”³ę•æę•¼ę–¢ę›ˆęš¾ę›€ę›Šę›‹ę›ęš½ęš»ęšŗę›Œęœ£ęØ“ę©¦ę©‰ę©§ęزę©ØęØ¾ę©ę©­ę©¶ę©›ę©‘ęØØę©šęØ»ęØæꩁę©Ŗę©¤ę©ę©ę©”ę©Æę©©ę© ęØ¼ę©žę©–ę©•ę©ę©Žę©†ę­•ę­”ę­–ę®§ę®ŖꮫęƈęÆ‡ę°„ę°ƒę°†ę¾­ęæ‹ę¾£ęæ‡ę¾¼ęæŽęæˆę½žęæ„ę¾½ę¾žęæŠę¾Øē€„ę¾„ę¾®ę¾ŗę¾¬ę¾Ŗęæę¾æę¾ø\"],[\"ea40\",\"ę¾¢ęæ‰ę¾«ęæę¾Æę¾²ę¾°ē‡…ē‡‚ē†æē†øē‡–ē‡€ē‡ē‡‹ē‡”ē‡Šē‡‡ē‡ē†½ē‡˜ē†¼ē‡†ē‡šē‡›ēŠēŠžē©ē¦ē§ē¬ē„ē«ēŖē‘æē’šē’ ē’”ē’’ē’•ē’”ē”‹ē–€ē˜Æē˜­ē˜±ē˜½ē˜³ē˜¼ē˜µē˜²ē˜°ēš»ē›¦ēžšēžēž”ēžœēž›ēž¢ēž£ēž•ēž™\"],[\"eaa1\",\"ēž—ē£ē£©ē£„ē£Ŗē£žē££ē£›ē£”ē£¢ē£­ē£Ÿē£ ē¦¤ē©„ē©ˆē©‡ēŖ¶ēŖøēŖµēŖ±ēŖ·ēƞēÆ£ēƧēƝēƕēÆ„ēƚēÆØēƹēƔēÆŖēÆ¢ēƜēÆ«ēƘēƟē³’ē³”ē³—ē³ē³‘ēø’ēø”ēø—ēøŒēøŸēø ēø“ēøŽēøœēø•ēøšēø¢ēø‹ēøēø–ēøēø”ēø„ēø¤ē½ƒē½»ē½¼ē½ŗē¾±ēæÆč€Ŗč€©č¬č†±č†¦č†®č†¹č†µč†«č†°č†¬č†“č†²č†·č†§č‡²č‰•č‰–č‰—č•–č•…č•«č•č•“č•”č•˜\"],[\"eb40\",\"č•€č•†č•¤č•č•¢č•„č•‘č•‡č•£č”¾č•›č•±č•Žč•®č•µč••č•§č• č–Œč•¦č•č•”č•„č•¬č™£č™„č™¤čž›čžčž—čž“čž’čžˆčžčž–čž˜č¹čž‡čž£čž…čžčž‘čžčž„čž”čžœčžščž‰č¤žč¤¦č¤°č¤­č¤®č¤§č¤±č¤¢č¤©č¤£č¤Æč¤¬č¤Ÿč§±č« \"],[\"eba1\",\"č«¢č«²č«“č«µč«č¬”č«¤č«Ÿč«°č«ˆč«žč«”č«Øč«æč«Æč«»č²‘č²’č²č³µč³®č³±č³°č³³čµ¬čµ®č¶„č¶§čø³čø¾čøøč¹€č¹…čø¶čø¼čø½č¹čø°čøæčŗ½č¼¶č¼®č¼µč¼²č¼¹č¼·č¼“遶遹遻邆éƒŗ鄳鄵鄶醓醐醑醍醏錧錞錈錟錆錏éŗéŒø錼錛錣錒錁鍆錭錎錍鋋錝é‹ŗ錄錓鋹鋷錓錂錤é‹æ錩錹錵éŒŖ錔錌\"],[\"ec40\",\"錋鋾錉錀鋻錖閼闍閾閹é–ŗ閶é–æ閵閽隩雔霋霒霐鞙鞗鞔韰éŸøé µé Æ頲餤餟餧餩馞駮駬駄駤駰駣é§Ŗ駩駧éŖ¹éŖæéŖ“éŖ»é«¶é«ŗ髹髷鬳鮀鮅鮇魼魾魻鮂鮓鮒鮐é­ŗ鮕\"],[\"eca1\",\"魽鮈铄铗铠铞铔铩铝铘铢铐铙铟éŗˆéŗ†éŗ‡éŗ®éŗ­é»•é»–é»ŗ鼒鼽儦億儢儤儠儩勓嚓嚌嚍嚆嚄嚃噾嚂å™æ嚁壖壔壏壒嬭嬄嬲嬣嬬嬧嬦å¬Æ嬮孻åƱåƲ嶷幬å¹Ŗå¾¾å¾»ę‡ƒę†µę†¼ę‡§ę‡ ę‡„ę‡¤ę‡Øꇞę“Æę“©ę“£ę“«ę“¤ę“ØꖁꖀꖶꗚꛒęŖęŖ–ęŖęŖ„ęŖ‰ęŖŸęŖ›ęŖ”ęŖžęŖ‡ęŖ“ęŖŽ\"],[\"ed40\",\"ęŖ•ęŖƒęŖØęŖ¤ęŖ‘ę©æęŖ¦ęŖšęŖ…ęŖŒęŖ’꭛ꮭ갉ęæŒę¾©ęæ“ęæ”ęæ£ęæœęæ­ęæ§ęæ¦ęæžęæ²ęæęæ¢ęæØē‡”ē‡±ē‡Øē‡²ē‡¤ē‡°ē‡¢ē³ē®ēÆē’—ē’²ē’«ē’ē’Ŗē’­ē’±ē’„ē’Æē”ē”‘ē”’ē”ē–„ē™ƒē™ˆē™‰ē™‡ēš¤ē›©ēžµēž«ēž²ēž·ēž¶\"],[\"eda1\",\"ēž“ēž±ēžØēŸ°ē£³ē£½ē¤‚ē£»ē£¼ē£²ē¤…ē£¹ē£¾ē¤„ē¦«ē¦Øē©œē©›ē©–ē©˜ē©”ē©šēŖ¾ē«€ē«ē°…ē°ēƲē°€ēÆæēÆ»ē°ŽēÆ“ē°‹ēƳē°‚ē°‰ē°ƒē°ēÆøēƽē°†ēÆ°ēƱē°ē°Šē³Øēø­ēø¼ē¹‚ēø³é”ˆēøøēøŖē¹‰ē¹€ē¹‡ēø©ē¹Œēø°ēø»ēø¶ē¹„ēøŗē½…ē½æē½¾ē½½ēæ“ēæ²č€¬č†»č‡„č‡Œč‡Šč‡…č‡‡č†¼č‡©č‰›č‰šč‰œč–ƒč–€č–č–§č–•č– č–‹č–£č•»č–¤č–šč–ž\"],[\"ee40\",\"č•·č•¼č–‰č–”č•ŗč•øč•—č–Žč––č–†č–č–™č–č–č–¢č–‚č–ˆč–…č•¹č•¶č–˜č–č–Ÿč™Øčž¾čžŖčž­čŸ…čž°čž¬čž¹čžµčž¼čž®čŸ‰čŸƒčŸ‚čŸŒčž·čžÆčŸ„čŸŠčž“čž¶čžæčžøčž½čŸžčž²č¤µč¤³č¤¼č¤¾č„č„’č¤·č„‚č¦­č¦Æč¦®č§²č§³č¬ž\"],[\"eea1\",\"č¬˜č¬–č¬‘č¬…č¬‹č¬¢č¬č¬’č¬•č¬‡č¬č¬ˆč¬†č¬œč¬“č¬šč±č±°č±²č±±č±Æč²•č²”č³¹čµÆč¹Žč¹č¹“č¹č¹Œč¹‡č½ƒč½€é‚…é¾é„ø醚醢醛醙醟醔醝醠鎔鎃éŽÆ鍤鍖鍇鍼鍘鍜鍶鍉鍐鍑鍠鍭鎏鍌éŖ鍹鍗鍕鍒鍏鍱鍷鍻鍔鍞鍣鍧鎀鍎鍙闇闀闉闃闅閷隮隰隬霠霟霘霝霙鞚鞔鞜\"],[\"ef40\",\"鞞鞝韕韔韱锁锄锊锉锅锃餄餫餬é¤Ŗ餳餲é¤Æ餭餱餰馘馣馔é؂é§ŗ駓駷駹é§ø駶駻駽駾駼é؃éŖ¾é«¾é«½é¬é«¼é­ˆé®šé®Ø鮞鮛鮦鮔鮄鮤鮆鮢鮠é®Æ铳鵁鵧银铮é“Æ铱é“øé“°\"],[\"efa1\",\"鵅鵂鵃链铷鵀铽ēæµé“­éŗŠéŗ‰éŗéŗ°é»ˆé»šé»»é»æ鼤鼣鼢齔龠儱儭儮嚘嚜嚗嚚嚝嚙儰嬼屩å±Ŗå·€å¹­å¹®ę‡˜ę‡Ÿę‡­ę‡®ę‡±ę‡Ŗꇰꇫꇖꇩę“æę”„ę“½ę“øę”ę”ƒę“¼ę–”ę—›ę›šę››ę›˜ę«…ęŖ¹ęŖ½ę«”꫆ęŖŗęŖ¶ęŖ·ę«‡ęŖ“ęŖ­ę­žęÆ‰ę°‹ē€‡ē€Œē€ē€ē€…ē€”ē€Žęææē€€ęæ»ē€¦ęæ¼ęæ·ē€Šēˆē‡æē‡¹ēˆƒē‡½ē¶\"],[\"f040\",\"ē’øē“€ē’µē“ē’¾ē’¶ē’»ē“‚ē””ē”“ē™œē™¤ē™™ē™ē™“ē™—ē™šēš¦ēš½ē›¬ēŸ‚ēžŗē£æē¤Œē¤“ē¤”ē¤‰ē¤ē¤’ē¤‘ē¦­ē¦¬ē©Ÿē°œē°©ē°™ē° ē°Ÿē°­ē°ē°¦ē°Øē°¢ē°„ē°°ē¹œē¹ē¹–ē¹£ē¹˜ē¹¢ē¹Ÿē¹‘ē¹ ē¹—ē¹“ē¾µē¾³ēæ·ēæø聵臑臒\"],[\"f0a1\",\"č‡č‰Ÿč‰žč–“č—†č—€č—ƒč—‚č–³č–µč–½č—‡č—„č–æč—‹č—Žč—ˆč—…č–±č–¶č—’č˜¤č–øč–·č–¾č™©čŸ§čŸ¦čŸ¢čŸ›čŸ«čŸŖčŸ„čŸŸčŸ³čŸ¤čŸ”čŸœčŸ“čŸ­čŸ˜čŸ£čž¤čŸ—čŸ™č čŸ“čŸØčŸč„“č„‹č„č„Œč„†č„č„‘č„‰č¬Ŗč¬§č¬£č¬³č¬°č¬µč­‡č¬Æč¬¼č¬¾č¬±č¬„č¬·č¬¦č¬¶č¬®č¬¤č¬»č¬½č¬ŗč±‚č±µč²™č²˜č²—č³¾č“„č“‚č“€č¹œč¹¢č¹ č¹—č¹–č¹žč¹„č¹§\"],[\"f140\",\"č¹›č¹šč¹”č¹č¹©č¹”č½†č½‡č½ˆč½‹é„Øé„ŗ鄻鄾é†Ø醄醧é†Æé†Ŗ鎵鎌鎒鎷鎛鎝鎉鎧鎎éŽŖ鎞鎦鎕鎈鎙鎟鎍鎱鎑鎲鎤éŽØ鎓鎣鎄闒闓闑隳雗雚巂雟雘雝霣霢霄鞬鞮éžØ鞫鞤éžŖ\"],[\"f1a1\",\"鞢鞄韗韙韖韘éŸŗ锐锑锒é¢ø鄁餼é¤ŗé؏é؋é؉é؍é؄éؑé؊é؅é؇é؆髀髜鬈鬄鬅鬩鬵魊魌魋éƇéƆéƃé®æéƁ鮵é®øéƓ鮶éƄ鮹鮽鵜鵓鵏鵊鵛鵋鵙鵖鵌鵗鵒鵔鵟鵘鵚éŗŽéŗŒé»Ÿé¼é¼€é¼–鼄鼫é¼Ŗ鼩é¼Ø齌齕儓儵劖勷厓嚫嚭嚦嚧åšŖ嚬壚壝壛夒嬽嬾å¬æ巃幰\"],[\"f240\",\"å¾æę‡»ę”‡ę”ę”ę”‰ę”Œę”Žę–„ę—žę—ę›žę«§ę« ę«Œę«‘ę«™ę«‹ę«Ÿę«œę«ę««ę«ę«ę«žę­ ę®°ę°Œē€™ē€§ē€ ē€–ē€«ē€”ē€¢ē€£ē€©ē€—ē€¤ē€œē€ŖēˆŒēˆŠēˆ‡ēˆ‚ēˆ…ēŠ„ēŠ¦ēŠ¤ēŠ£ēŠ”ē“‹ē“…ē’·ē“ƒē”–ē™ ēŸ‰ēŸŠēŸ„ēŸ±ē¤ē¤›\"],[\"f2a1\",\"ē¤”ē¤œē¤—ē¤žē¦°ē©§ē©Øē°³ē°¼ē°¹ē°¬ē°»ē³¬ē³Ŗē¹¶ē¹µē¹øē¹°ē¹·ē¹Æē¹ŗē¹²ē¹“ē¹Øē½‹ē½Šē¾ƒē¾†ē¾·ēæ½ēæ¾čøč‡—č‡•č‰¤č‰”č‰£č—«č—±č—­č—™č—”č—Øč—šč——č—¬č—²č—øč—˜č—Ÿč—£č—œč—‘č—°č—¦č—Æč—žč—¢č €čŸŗč ƒčŸ¶čŸ·č ‰č Œč ‹č †čŸ¼č ˆčŸæč Šč ‚č„¢č„šč„›č„—č„”č„œč„˜č„č„™č¦ˆč¦·č¦¶č§¶č­č­ˆč­Šč­€č­“č­–č­”č­‹č­•\"],[\"f340\",\"č­‘č­‚č­’č­—č±ƒč±·č±¶č²šč“†č“‡č“‰č¶¬č¶Ŗč¶­č¶«č¹­č¹øč¹³č¹Ŗč¹Æč¹»č»‚č½’č½‘č½č½č½“č¾“é…€é„æ醰醭鏞鏇鏏鏂鏚鏐鏹鏬鏌鏙鎩鏦鏊鏔鏮鏣鏕鏄鏎鏀鏒鏧镽闚闛雔霩霫霬éœØ霦\"],[\"f3a1\",\"鞳鞷鞶韝韞韟锜错锝锗é¢æ颽颻颾鄈鄇鄃馦馧éؚéؕéØ„é؝éؤé؛éØ¢éØ éاéØ£é؞é؜éؔ髂鬋鬊鬎鬌鬷éÆŖéÆ«éÆ éƞéƤéƦéÆ¢éÆ°éƔéƗéƬéƜéƙéÆ„éƕéÆ”éƚ鵷鶁鶊鶄鶈鵱鶀éµø鶆鶋鶌鵽鵫鵓鵵鵰鵩鶅鵳鵻鶂éµÆéµ¹éµæ鶇éµØéŗ”éŗ‘黀黼鼭齀齁齍齖齗齘匷嚲\"],[\"f440\",\"嚵嚳壣孅巆巇廮å»Æåæ€åæę‡¹ę”—ę”–ę”•ę”“ę—Ÿę›Øę›£ę›¤ę«³ę«°ę«Ŗę«Øę«¹ę«±ę«®ę«Æē€¼ē€µē€Æē€·ē€“ē€±ē‚ē€øē€æē€ŗē€¹ē€ē€»ē€³ēēˆ“ēˆ”ēŠØē½ē¼ē’ŗēš«ēšŖēš¾ē›­ēŸŒēŸŽēŸēŸēŸ²ē¤„ē¤£ē¤§ē¤Øē¤¤ē¤©\"],[\"f4a1\",\"ē¦²ē©®ē©¬ē©­ē«·ē±‰ē±ˆē±Šē±‡ē±…ē³®ē¹»ē¹¾ēŗēŗ€ē¾ŗēææč¹č‡›č‡™čˆ‹č‰Øč‰©č˜¢č—æč˜č—¾č˜›č˜€č—¶č˜„č˜‰č˜…č˜Œč—½č ™č č ‘č —č “č –č„£č„¦č¦¹č§·č­ č­Ŗ譝č­Øč­£č­„č­§č­­č¶®čŗ†čŗˆčŗ„č½™č½–č½—č½•č½˜č½šé‚é…ƒé…é†·é†µé†²é†³é‹é“é»é éé”é¾é•ééØ鐙鐍鏵鐀鏷鐇鐎鐖鐒éŗ鐉éø鐊éæ\"],[\"f540\",\"鏼鐌鏶鐑鐆闞闠闟霮éœÆ鞹鞻韽韾锠锢锣锟飁飂鄐鄎鄙鄌鄋鄓éزéØ“éرéجéØŖéضéØ©éØ®éØøéح髇髊髆鬐鬒鬑鰋鰈éƷ鰅鰒éÆø鱀鰇鰎鰆鰗鰔鰉鶟鶙鶤鶝鶒鶘鶐鶛\"],[\"f5a1\",\"鶠鶔鶜é¶Ŗ鶗鶔鶚鶢é¶Ø鶞鶣é¶æ鶩鶖鶦鶧éŗ™éŗ›éŗšé»„黤黧黦鼰鼮齛齠齞齝齙龑å„ŗå„¹åŠ˜åŠ—å›ƒåš½åš¾å­ˆå­‡å·‹å·å»±ę‡½ę”›ę¬‚ę«¼ę¬ƒę«ø꬀ēƒē„ēŠēˆē‰ē…ē†ēˆēˆšēˆ™ē¾ē”—ē™ŖēŸē¤­ē¤±ē¤Æē±”ē±“ē³²ēŗŠēŗ‡ēŗˆēŗ‹ēŗ†ēŗē½ē¾»č€°č‡č˜˜č˜Ŗč˜¦č˜Ÿč˜£č˜œč˜™č˜§č˜®č˜”č˜ č˜©č˜žč˜„\"],[\"f640\",\"č ©č č ›č  č ¤č œč «č”Šč„­č„©č„®č„«č§ŗč­¹č­ø譅č­ŗ譻蓐蓔č¶ÆčŗŽčŗŒč½žč½›č½é…†é…„酅醹éæ鐻鐶鐩鐽鐼鐰鐹éŖ鐷鐬鑀鐱闄闤闣霵éœŗéžæ韔锤飉飆飀鄘鄖éعéؽ驆驄驂驁éØŗ\"],[\"f6a1\",\"éØæ髍鬕鬗鬘鬖é¬ŗ魒鰫鰝鰜鰬鰣é°Ø鰩鰤鰔鶷鶶鶼鷁鷇鷊鷏鶾鷅鷃鶻鶵鷎鶹é¶ŗ鶬鷈鶱鶭鷌鶳鷍鶲é¹ŗéŗœé»«é»®é»­é¼›é¼˜é¼šé¼±é½Žé½„齤龒äŗ¹å›†å›…å›‹å„±å­‹å­Œå·•å·‘å»²ę””ę” ę”¦ę”¢ę¬‹ę¬ˆę¬‰ę°ē•ē–ē—ē’ēˆžēˆŸēŠ©ēæē“˜ē“•ē“™ē“—ē™­ēš­ē¤µē¦“ē©°ē©±ē±—ē±œē±™ē±›ē±š\"],[\"f740\",\"ē³“ē³±ēŗ‘ē½ē¾‡č‡žč‰«č˜“č˜µč˜³č˜¬č˜²č˜¶č ¬č Øč ¦č Ŗ蠄脱č¦æč¦¾č§»č­¾č®„č®‚č®†č®…č­æč“•čŗ•čŗ”čŗščŗ’čŗčŗ–čŗ—č½ č½¢é…‡é‘Œé‘é‘Šé‘‹é‘é‘‡é‘…é‘ˆé‘‰é‘†éœæ韣é”Ŗ锩飋鄔鄛驎驓驔驌驏驈驊\"],[\"f7a1\",\"驉驒驐髐鬙鬫鬻魖魕鱆鱈é°æ鱄鰹鰳鱁鰼鰷鰓鰲鰽鰶鷛鷒鷞鷚鷋鷐鷜鷑鷟鷩鷙鷘鷖鷵鷕鷝éŗ¶é»°é¼µé¼³é¼²é½‚齫龕龢儽劙å£Ø壧儲孍巘č Æå½ęˆęˆƒęˆ„ę”©ę”„ę––ę›«ę¬‘ę¬’ę¬ęƊē›ēšēˆ¢ēŽ‚ēŽēŽƒē™°ēŸ”ē±§ē±¦ēŗ•č‰¬č˜ŗč™€č˜¹č˜¼č˜±č˜»č˜¾č °č ²č ®č ³č„¶č„“č„³č§¾\"],[\"f840\",\"č®Œč®Žč®‹č®ˆč±…č“™čŗ˜č½¤č½£é†¼é‘¢é‘•é‘é‘—鑞韄韅頀驖驙鬞鬟鬠鱒鱘鱐鱊鱍鱋鱕鱙鱌鱎鷻鷷é·Æ鷣鷫é·ø鷤鷶鷔鷮鷦鷲鷰鷢鷬鷓鷳é·Ø鷭黂黐黲黳鼆鼜é¼ø鼷鼶齃齏\"],[\"f8a1\",\"齱齰齮é½Æå›“å›å­Žå±­ę”­ę›­ę›®ę¬“ēŸē”ēē ēˆ£ē“›ē“„ēŸ•ē¤øē¦·ē¦¶ē±Ŗēŗ—ē¾‰č‰­č™ƒč ø蠷蠵蔋讔讕čŗžčŗŸčŗ čŗé†¾é†½é‡‚é‘«é‘Ø鑩雄靆靃靇韇韄驞髕魙鱣鱧鱦鱢鱞鱠éø‚é·¾éø‡éøƒéø†éø…éø€éøéø‰é·æé·½éø„éŗ é¼žé½†é½“é½µé½¶å›”ę”®ę–øę¬˜ę¬™ę¬—ę¬šē¢ēˆ¦ēŠŖēŸ˜ēŸ™ē¤¹ē±©ē±«ē³¶ēŗš\"],[\"f940\",\"ēŗ˜ēŗ›ēŗ™č‡ č‡”č™†č™‡č™ˆč„¹č„ŗč„¼č„»č§æč®˜č®™čŗ„čŗ¤čŗ£é‘®é‘­é‘Æ鑱鑳靉锲鄟é±Ø鱮鱭éø‹éøéøéøéø’éø‘éŗ”黵鼉齇é½øé½»é½ŗ齹圞ē¦ē±Æč ¼č¶²čŗ¦é‡ƒé‘“é‘ø鑶鑵驠鱓鱳鱱鱵éø”éø“黶鼊\"],[\"f9a1\",\"龤ēØē„ē³·č™Ŗč ¾č ½č æč®žč²œčŗ©č»‰é‹é”³é”“飌鄔馫驤驦驧鬤éø•éø—é½ˆęˆ‡ę¬žēˆ§č™ŒčŗØ钂钀钁驩é©Ø鬮éø™ēˆ©č™‹č®Ÿé’ƒé±¹éŗ·ē™µé©«é±ŗéøē©ēŖéŗ¤é½¾é½‰é¾˜ē¢éŠ¹č£å¢»ę’ē²§å«ŗā•”ā•¦ā•—ā• ā•¬ā•£ā•šā•©ā•ā•’ā•¤ā••ā•žā•Ŗā•”ā•˜ā•§ā•›ā•“ā•„ā•–ā•Ÿā•«ā•¢ā•™ā•Øā•œā•‘ā•ā•­ā•®ā•°ā•Æā–“\"]]"); + +/***/ }), + +/***/ 4957: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"0\",\"\\u0000\",127],[\"8ea1\",\"ļ½”\",62],[\"a1a1\",\"怀态怂ļ¼Œļ¼Žćƒ»ļ¼šļ¼›ļ¼Ÿļ¼ć‚›ć‚œĀ“ļ½€ĀØļ¼¾ļæ£ļ¼æćƒ½ćƒ¾ć‚ć‚žć€ƒä»ć€…ć€†ć€‡ćƒ¼ā€•ā€ļ¼ļ¼¼ļ½žāˆ„ļ½œā€¦ā€„ā€˜ā€™ā€œā€ļ¼ˆļ¼‰ć€”怕ļ¼»ļ¼½ļ½›ļ½ć€ˆ\",9,\"ļ¼‹ļ¼Ā±Ć—Ć·ļ¼ā‰ ļ¼œļ¼žā‰¦ā‰§āˆžāˆ“ā™‚ā™€Ā°ā€²ā€³ā„ƒļæ„ļ¼„ļæ ļæ”ļ¼…ļ¼ƒļ¼†ļ¼Šļ¼ Ā§ā˜†ā˜…ā—‹ā—ā—Žā—‡\"],[\"a2a1\",\"ā—†ā–”ā– ā–³ā–²ā–½ā–¼ā€»ć€’ā†’ā†ā†‘ā†“怓\"],[\"a2ba\",\"āˆˆāˆ‹āŠ†āŠ‡āŠ‚āŠƒāˆŖāˆ©\"],[\"a2ca\",\"āˆ§āˆØļæ¢ā‡’ā‡”āˆ€āˆƒ\"],[\"a2dc\",\"āˆ āŠ„āŒ’āˆ‚āˆ‡ā‰”ā‰’ā‰Ŗā‰«āˆšāˆ½āˆāˆµāˆ«āˆ¬\"],[\"a2f2\",\"ā„«ā€°ā™Æā™­ā™Ŗā€ ā€”Ā¶\"],[\"a2fe\",\"ā—Æ\"],[\"a3b0\",\"ļ¼\",9],[\"a3c1\",\"ļ¼”\",25],[\"a3e1\",\"ļ½\",25],[\"a4a1\",\"恁\",82],[\"a5a1\",\"ć‚”\",85],[\"a6a1\",\"Ī‘\",16,\"Ī£\",6],[\"a6c1\",\"Ī±\",16,\"Ļƒ\",6],[\"a7a1\",\"Š\",5,\"ŠŠ–\",25],[\"a7d1\",\"Š°\",5,\"ёŠ¶\",25],[\"a8a1\",\"ā”€ā”‚ā”Œā”ā”˜ā””ā”œā”¬ā”¤ā”“ā”¼ā”ā”ƒā”ā”“ā”›ā”—ā”£ā”³ā”«ā”»ā•‹ā” ā”Æā”Øā”·ā”æā”ā”°ā”„ā”øā•‚\"],[\"ada1\",\"ā‘ \",19,\"ā… \",9],[\"adc0\",\"ć‰ćŒ”ćŒ¢ććŒ˜ćŒ§ćŒƒćŒ¶ć‘ć—ćŒćŒ¦ćŒ£ćŒ«ćŠćŒ»ćŽœćŽćŽžćŽŽćŽć„ćŽ”\"],[\"addf\",\"ć»ć€ć€Ÿā„–揍ā„”护\",4,\"ćˆ±ćˆ²ćˆ¹ć¾ć½ć¼ā‰’ā‰”āˆ«āˆ®āˆ‘āˆšāŠ„āˆ āˆŸāŠæāˆµāˆ©āˆŖ\"],[\"b0a1\",\"äŗœå”–å؃é˜æå“€ę„›ęŒØå§¶é€¢č‘µčŒœē©ę‚Ŗę”ęø„ꗭ葦芦éÆµę¢“åœ§ę–”ę‰±å®›å§č™»é£“ēµ¢ē¶¾é®Žęˆ–ē²Ÿč¢·å®‰åŗµęŒ‰ęš—ę”ˆé—‡éžęä»„伊位依偉囲夷委åØå°‰ęƒŸę„ę…°ę˜“ę¤…ē‚ŗē•ē•°ē§»ē¶­ē·ÆčƒƒčŽč”£č¬‚é•éŗ医äŗ•äŗ„åŸŸč‚²éƒē£Æäø€å£±ęŗ¢é€øēزčŒØ芋é°Æå…å°å’½å“”å› å§»å¼•é£²ę·«čƒ¤č”­\"],[\"b1a1\",\"院陰隠韻吋右宇ēƒē¾½čæ‚é›ØåÆ鵜ēŖŗäø‘ē¢“č‡¼ęø¦å˜˜å”„ę¬č”šé°»å§„åŽ©ęµ¦ē“œé–å™‚äŗ‘é‹é›²čé¤Œå”å–¶å¬°å½±ę˜ ę›³ę „ę°øę³³ę“©ē‘›ē›ˆē©Žé “č‹±č”›č© é‹­ę¶²ē–«ē›Šé§…ę‚¦č¬č¶Šé–²ę¦ŽåŽ­å††åœ’å °å„„å®“延ę€ØęŽ©ę“ę²æę¼”ē‚Žē„”ē…™ē‡•ēŒæēøč‰¶č‹‘č–—é é‰›é“›å”©ę–¼ę±šē”„凹央億往åæœ\"],[\"b2a1\",\"ęŠ¼ę—ŗęØŖ꬧ꮓēŽ‹ēæč„–é“¬é“Žé»„å²”ę²–č»å„„å±‹ę†¶č‡†ę”¶ē‰”乙äæŗåøꁩęø©ē©éŸ³äø‹åŒ–仮何伽侔佳加åÆ嘉夏嫁家åÆ”ē§‘ęš‡ęžœęž¶ę­Œę²³ē«ē‚ē¦ē¦¾ēؼē®‡čŠ±č‹›čŒ„č·čÆč“č¦čŖ²å˜©č²Øčæ¦éŽéœžčšŠäæ„å³Øꈑē‰™ē”»č‡„čŠ½č›¾č³€é›…é¤“é§•ä»‹ä¼šč§£å›žå”Šå£Šå»»åæ«ę€Ŗę‚”ę¢ę‡ęˆ’ę‹ę”¹\"],[\"b3a1\",\"é­ę™¦ę¢°ęµ·ē°ē•Œēš†ēµµčŠ„čŸ¹é–‹éšŽč²å‡±åŠ¾å¤–å’³å®³å“–ę…Øꦂę¶Æē¢č“‹č”—č©²éŽ§éŖø구é¦Øč›™åž£ęŸæč›ŽéˆŽåŠƒåš‡å„å»“ę‹”ę’¹ę ¼ę øę®»ē²ē¢ŗē©«č¦šč§’čµ«č¼ƒéƒ­é–£éš”é©å­¦å²³ę„½é”é”ŽęŽ›ē¬ ęØ«ę©æę¢¶é°ę½Ÿå‰²å–ę°ę‹¬ę“»ęø‡ę»‘č‘›č¤č½„äø”é°¹å¶ę¤›ęØŗ鞄ę Ŗ兜ē«ƒč’²é‡œéŽŒå™›é“Øę ¢čŒ…č±\"],[\"b4a1\",\"ē²„åˆˆč‹…ē“¦ä¹¾ä¾ƒå† åƒ刊勘勧巻喚å Ŗ姦完官åÆ›å¹²å¹¹ę‚£ę„Ÿę…£ę†¾ę›ę•¢ęŸ‘ę”“ę£ŗę¬¾ę­“ę±—ę¼¢ę¾—ę½…ē’°ē”˜ē›£ēœ‹ē«æē®”ē°”ē·©ē¼¶ēæ°č‚č‰¦čŽžč¦³č«Œč²«é‚„鑑間閑関附韓é¤Ø舘äøø含å²ø巌ēŽ©ē™Œēœ¼å²©ēæ«č“‹é›é ‘锔锘企伎危喜å™ØåŸŗ儇嬉åƄ岐åøŒå¹¾åæŒę®ęœŗę——ę—¢ęœŸę£‹ę£„\"],[\"b5a1\",\"ę©Ÿåø°ęÆ…ę°—ę±½ē•æē„ˆå­£ē؀ē“€å¾½č¦čØ˜č²“čµ·č»Œč¼é£¢é؎鬼äŗ€å½å„€å¦“宜ęˆÆꊀꓬę¬ŗēŠ ē–‘ē„‡ē¾©čŸ»čŖ¼č­°ęŽ¬čŠéž å‰åƒå–«ę””ę©˜č©°ē §ęµé»å“å®¢č„šč™é€†äø˜ä¹…仇休及åøå®®å¼“ę€„ę•‘ęœ½ę±‚ę±²ę³£ēøēƒē©¶ēŖ®ē¬ˆē“šē³¾ēµ¦ę—§ē‰›åŽ»å±…å·Øꋒꋠꌙęø č™ščØ±č·é‹øę¼ē¦¦é­šäŗØäŗ«äŗ¬\"],[\"b6a1\",\"供侠僑兇ē«¶å…±å‡¶å”匔åæ叫喬境峔強彊ę€Æęę­ęŒŸę•™ę©‹ę³ē‹‚ē‹­ēŸÆčƒøč„…čˆˆč•Žéƒ·é”éŸæé„—é©šä»°å‡å°­ęšę„­å±€ę›²ę„µēŽ‰ę”ē²åƒ…å‹¤å‡å·¾éŒ¦ę–¤ę¬£ę¬½ē“ē¦ē¦½ē­‹ē·ŠčŠ¹čŒč”æč„Ÿč¬¹čæ‘金吟銀九倶叄åŒŗē‹—ēŽ–ēŸ©č‹¦čŗÆé§†é§ˆé§’å…·ę„šč™žå–°ē©ŗ偶åƓ遇隅äø²ę«›é‡§å±‘屈\"],[\"b7a1\",\"ꎘēŖŸę²“é“č½”ēŖŖē†Šéšˆē²‚ę —ē¹°ę”‘é¬å‹²å›č–«čؓē¾¤č»éƒ”å¦č¢ˆē„äæ‚傾刑兄啓圭ēŖåž‹å„‘å½¢å¾„ęµę…¶ę…§ę†©ęŽ²ęŗꕬę™Æꔂęø“ē•¦ēؽē³»ēµŒē¶™ē¹‹ē½«čŒŽčŠč›čØˆč©£č­¦č»½é šé¶čŠøčæŽéÆØåŠ‡ęˆŸę’ƒęæ€éš™ę”å‚‘ꬠę±ŗę½”ē©“ēµč”€čØ£ęœˆä»¶å€¹å€¦å„å…¼åˆø剣喧圏堅嫌å»ŗę†²ę‡øę‹³ę²\"],[\"b8a1\",\"ꤜęØ©ē‰½ēŠ¬ēŒ®ē ”ē”Æēµ¹ēœŒč‚©č¦‹č¬™č³¢č»’遣鍵é™ŗ锕éؓé¹ø元原厳幻弦ęø›ęŗēŽ„ē¾ēµƒčˆ·č؀č«ŗ限乎個古呼å›ŗ姑孤己åŗ«å¼§ęˆøꕅęžÆę¹–ē‹ē³Šč¢“č‚”čƒ”č°č™ŽčŖ‡č·Ø鈷雇锧鼓äŗ”äŗ’伍午呉吾åØÆå¾Œå¾”ę‚Ÿę¢§ęŖŽē‘šē¢čŖžčŖ¤č­·é†ä¹žéƉäŗ¤ä½¼ä¾Æ候倖光公功効勾厚口向\"],[\"b9a1\",\"后喉坑垢儽孔孝宏巄巧巷å¹øåŗƒåŗšåŗ·å¼˜ę’ę…ŒęŠ—ę‹˜ęŽ§ę”»ę˜‚ę™ƒę›“ę­ę ”ę¢—ę§‹ę±Ÿę“Ŗ굩ęøÆęŗē”²ēš‡ē”¬ēØæē³ ē“…ē“˜ēµžē¶±č€•č€ƒč‚Æč‚±č…”č†čˆŖč’č”Œč””č¬›č²¢č³¼éƒŠé…µé‰±ē æé‹¼é–¤é™é …é¦™é«˜é“»å‰›åŠ«å·åˆå£•ę‹·ęæ č±Ŗč½Ÿéŗ¹å…‹åˆ»å‘Šå›½ē©€é…·éµ é»’ē„ę¼‰č…°ē”‘åæ½ęƒšéŖØē‹›č¾¼\"],[\"baa1\",\"ę­¤é ƒä»Šå›°å¤å¢¾å©šęØę‡‡ę˜ę˜†ę ¹ę¢±ę··ē—•ē“ŗ艮魂äŗ›ä½å‰å”†åµÆå·¦å·®ęŸ»ę²™ē‘³ē ‚č©éŽ–č£Ÿååŗ§ęŒ«å‚µå‚¬å†ęœ€å“‰å”žå¦»å®°å½©ę‰ęŽ”ę ½ę­³ęøˆē½é‡‡ēŠ€ē •ē ¦ē„­ę–Žē“°čœč£č¼‰éš›å‰¤åœØꝐē½Ŗč²”å†“å‚é˜Ŗå ŗę¦Šč‚“å’²å“ŽåŸ¼ē¢•é·ŗä½œå‰Šå’‹ę¾ę˜Øęœ”ęŸµēŖ„ē­–ē“¢éŒÆę”œé®­ē¬¹åŒ™å†Šåˆ·\"],[\"bba1\",\"åÆŸę‹¶ę’®ę“¦ęœ­ę®ŗ薩雑ēšéÆ–ęŒéŒ†é®«ēšæꙒäø‰å‚˜å‚å±±ęƒØę’’ę•£ę”Ÿē‡¦ēŠē”£ē®—ēŗ‚čš•č®ƒč³›é…ø餐ꖬꚫꮋ仕仔ä¼ŗä½æåˆŗåø史嗣四士始姉å§æ子屍åø‚åø«åæ—ę€ęŒ‡ę”Æ孜ę–Æę–½ę—Øęžę­¢ę­»ę°ē…ē„‰ē§ē³øē“™ē“«č‚¢č„‚č‡³č¦–č©žč©©č©¦čŖŒč«®č³‡č³œé›Œé£¼ę­Æäŗ‹ä¼¼ä¾å…å­—åÆŗꅈꌁꙂ\"],[\"bca1\",\"ę¬”ę»‹ę²»ēˆ¾ē’½ē—”ē£ē¤ŗč€Œč€³č‡Ŗč’”č¾žę±é¹æå¼č­˜é“«ē«ŗč»ø宍雫äøƒå±åŸ·å¤±å«‰å®¤ę‚‰ę¹æę¼†ē–¾č³Ŗå®Ÿč”€ēÆ å²ęŸ“čŠå±”č•ŠēøžčˆŽå†™å°„ęØčµ¦ę–œē…®ē¤¾ē“—č€…č¬č»Šé®č›‡é‚Ŗ借å‹ŗå°ŗꝓē¼ēˆµé…Œé‡ˆéŒ«č‹„åÆ‚å¼±ęƒ¹äø»å–å®ˆę‰‹ęœ±ę®Šē‹©ē ēØ®č…«č¶£é…’é¦–å„’å—å‘ŖåÆæꎈęعē¶¬éœ€å›šåŽå‘Ø\"],[\"bda1\",\"宗就州äæ®ę„ę‹¾ę“²ē§€ē§‹ēµ‚ē¹ēæ’č‡­čˆŸč’č”†č„²č®č¹“č¼Æé€±é…‹é…¬é›†é†œä»€ä½å……åå¾“ęˆŽęŸ”ę±ęø‹ē£ēø¦é‡éŠƒå”夙å®æę·‘ē„ēø®ē²›å”¾ē†Ÿå‡ŗ蔓čæ°äæŠå³»ę˜„ēž¬ē«£čˆœé§æ准å¾Ŗę—¬ę„Æę®‰ę·³ęŗ–ę½¤ē›¾ē“”å·”éµé†‡é †å‡¦åˆę‰€ęš‘ę›™ęøšåŗ¶ē·’ē½²ę›øč–Æč—·č«ø助叙儳åŗå¾ę•é‹¤é™¤å‚·å„Ÿ\"],[\"bea1\",\"勝匠升召å“Ø商唱嘗å„Ø妾åؼ宵将小少尚åŗ„åŗŠå» å½°ę‰æęŠ„ę‹›ęŽŒę·ę˜‡ę˜Œę˜­ę™¶ę¾ę¢¢ę؟ęØµę²¼ę¶ˆęø‰ę¹˜ē„¼ē„¦ē…§ē—‡ēœē”ē¤ē„„ē§°ē« ē¬‘ē²§ē“¹č‚–č–č’‹č•‰č”č£³č؟čØ¼č©”č©³č±”č³žé†¤é‰¦é¾é˜éšœéž˜äøŠäøˆäøžä¹—冗剰城堓壌嬢åøøęƒ…ę“¾ę”ę–ęµ„ēŠ¶ē•³ē©£č’øč­²é†ø錠嘱埓飾\"],[\"bfa1\",\"ę‹­ę¤ę®–ē‡­ē¹”č·č‰²č§¦é£Ÿč•č¾±å°»ä¼øäæ”侵唇åØ åƝåÆ©åæƒę…ŽęŒÆę–°ę™‹ę£®ę¦›ęµøę·±ē”³ē–¹ēœŸē„žē§¦ē“³č‡£čŠÆč–Ŗč¦ŖčØŗčŗ«č¾›é€²é‡éœ‡äŗŗ仁刃唵壬尋ē”šå°½č…Žč؊čæ…陣靭ē¬„č«é ˆé…¢å›³åŽØ逗吹垂åø„ęŽØę°“ē‚Šē”ē²‹ēæ č”°é‚酔錐錘随ē‘žé«„å“‡åµ©ę•°ęž¢č¶Øé››ę®ę‰ę¤™č…é —é›€č£¾\"],[\"c0a1\",\"ę¾„ę‘ŗåÆøäø–ē€¬ē•ę˜Æå‡„åˆ¶å‹¢å§“å¾ę€§ęˆę”æę•“ę˜Ÿę™“ę£²ę –ę­£ęø…ē‰²ē”Ÿē››ē²¾č–å£°č£½č„æčŖ čŖ“č«‹é€é†’é’é™ę–‰ēØŽč„†éš»åø­ęƒœęˆšę–„ꘔꞐēŸ³ē©ē±ēø¾č„Šč²¬čµ¤č·”č¹Ÿē¢©åˆ‡ę‹™ęŽ„ꑂꊘčØ­ēŖƒēƀčŖ¬é›Ŗēµ¶čˆŒč‰ä»™å…ˆåƒå å®£å°‚å°–å·ęˆ¦ę‰‡ę’°ę “ę “ę³‰ęµ…ę“—ęŸ“ę½œē…Žē…½ę—‹ē©æē®­ē·š\"],[\"c1a1\",\"ē¹Šē¾Øč…ŗčˆ›čˆ¹č–¦č©®č³Žč·µéø遷銭銑閃鮮前善ę¼øē„¶å…Øē¦…ē¹•č†³ē³Žå™Œå”‘å²ØęŽŖę›¾ę›½ę„šē‹™ē–ē–Žē¤Žē„–ē§Ÿē²—ē“ ēµ„č˜‡čؓ阻達鼠僧創双叢倉å–Ŗ壮儏ēˆ½å®‹å±¤åŒęƒ£ęƒ³ęœęŽƒęŒæęŽ»ę“ę—©ę›¹å·£ę§ę§½ę¼•ē‡„äŗ‰ē—©ē›øēŖ“ē³Ÿē·ē¶œč”č‰č˜č‘¬č’¼č—»č£…čµ°é€é­éŽ—éœœéØ’åƒå¢—ę†Ž\"],[\"c2a1\",\"č‡“č”µč“ˆé€ äæƒå“則即ęÆꍉꝟęø¬č¶³é€Ÿäæ—å±žč³Šę—ē¶šå’č¢–å…¶ęƒå­˜å­«å°Šęę‘éœä»–å¤šå¤Ŗę±°č©‘å”¾å •å¦„ęƒ°ę‰“ęŸčˆµę„•é™€é§„éØØ体堆åÆ¾č€å²±åøÆå¾…ę€ ę…‹ęˆ“ę›æę³°ę»žčƒŽč…æč‹”č¢‹č²ø退逮隊黛éƛ代台大ē¬¬é†é”Œé·¹ę»ē€§å“å•„å®…ę‰˜ęŠžę‹“ę²¢ęæÆē¢čؗéøęæč«¾čŒø凧č›øåŖ\"],[\"c3a1\",\"å©ä½†é”č¾°å„Ŗč„±å·½ē«Ŗč¾æę£šč°·ē‹ø鱈ęؽčŖ°äø¹å˜å˜†å¦ę‹…ęŽ¢ę—¦ę­Žę·”ę¹›ē‚­ēŸ­ē«Æē®Ŗē¶»č€½čƒ†č›‹čŖ•é›å›£å£‡å¼¾ę–­ęš–ęŖ€ę®µē”·č«‡å€¤ēŸ„åœ°å¼›ę„ę™ŗę± ē—“ēؚē½®č‡“čœ˜é…é¦³ēƉē•œē«¹ē­‘蓄逐ē§©ēŖ’čŒ¶å«”ē€äø­ä»²å®™åæ ęŠ½ę˜¼ęŸ±ę³Ø虫蔷čػ酎鋳駐ęؗē€¦ēŒŖ苧著č²Æäøå…†å‡‹å–‹åƵ\"],[\"c4a1\",\"åø–åø³åŗå¼”å¼µå½«å¾“ę‡²ęŒ‘ęš¢ęœę½®ē‰’ē”ŗēœŗč“č„¹č…øč¶čŖæč«œč¶…č·³éŠšé•·é ‚é³„å‹…ę—ē›“ęœ•ę²ˆēč³ƒéŽ®é™³ę“„å¢œę¤Žę§Œčæ½éŽšē—›é€šå”šę ‚ęŽ“ę§»ä½ƒę¼¬ęŸ˜č¾»č”¦ē¶“鍔ę¤æę½°åŖ壷嬬ē“¬ēˆŖ吊釣鶓äŗ­ä½Žåœåµå‰ƒč²žå‘ˆå ¤å®šåøåŗ•åŗ­å»·å¼Ÿę‚ŒęŠµęŒŗꏐę¢Æę±€ē¢‡ē¦Žē؋ē· č‰‡čØ‚č«¦č¹„é€“\"],[\"c5a1\",\"é‚øé„­é‡˜é¼Žę³„ę‘˜ę“¢ę•µę»“ēš„ē¬›é©é‘ęŗŗå“²å¾¹ę’¤č½čæ­é‰„å…ø唫天展åŗ—ę·»ēŗē”œč²¼č»¢é”›ē‚¹ä¼ę®æę¾±ē”°é›»å…Žåå µå”—å¦¬å± å¾’ę–—ęœęø”ē™»čŸč³­é€”都鍍ē „ē ŗåŠŖåŗ¦åœŸå„“ę€’å€’å…šå†¬å‡åˆ€å”å””å”˜å„—å®•å³¶å¶‹ę‚¼ęŠ•ę­ę±ę”ƒę¢¼ę£Ÿē›—ę·˜ę¹Æ궛ēÆē‡ˆå½“ē—˜ē„·ē­‰ē­”ē­’ē³–ēµ±åˆ°\"],[\"c6a1\",\"č‘£č•©č—¤čØŽč¬„č±†čøé€ƒé€é™é™¶é ­éØ°é—˜åƒå‹•åŒå ‚å°Žę†§ę’žę“žēž³ē«„čƒ“č„é“éŠ…å³ é“‡åŒæå¾—å¾³ę¶œē‰¹ē£ē¦æēƤęƒē‹¬čŖ­ę ƒę©”å‡øēŖę¤“å±Šé³¶č‹«åƅ酉ē€žå™øå±Æęƒ‡ę•¦ę²Œč±šéé “å‘‘ę›‡éˆå„ˆé‚£å†…ä¹å‡Ŗ薙謎ē˜ęŗé‹ę„¢é¦“ēø„ē•·å—ę„ č»Ÿé›£ę±äŗŒå°¼å¼čæ©åŒ‚č³‘č‚‰č™¹å»æę—„ä¹³å…„\"],[\"c7a1\",\"如å°æ韮任妊åæčŖęæ”ē¦°ē„¢åÆ§č‘±ēŒ«ē†±å¹“åæµę»ę’šē‡ƒē²˜ä¹ƒå»¼ä¹‹åŸœåš¢ę‚©ęæƒē“čƒ½č„³č†æč¾²č¦—čš¤å·“ęŠŠę’­č¦‡ę·ę³¢ę“¾ē¶ē “婆ē½µčŠ­é¦¬äæ³å»ƒę‹ęŽ’ę•—ęÆē›ƒē‰ŒčƒŒč‚ŗč¼©é…å€åŸ¹åŖ’ę¢…ę„³ē…¤ē‹½č²·å£²č³ é™Ŗ這čæē§¤ēŸ§č©ä¼Æå‰„åšę‹ęŸę³Šē™½ē®”ē²•čˆ¶č–„čæ«ę›ę¼ ēˆ†ēø›čŽ«é§éŗ¦\"],[\"c8a1\",\"函ē®±ē”²ē®ø肇ē­ˆę«Øå¹”č‚Œē•‘ē• å…«é‰¢ęŗŒē™ŗ醗é«Ŗ伐ē½°ęŠœē­é–„鳩å™ŗå”™č›¤éš¼ä¼“åˆ¤åŠåå›åø†ę¬ę–‘ęæę°¾ę±Žē‰ˆēŠÆē­ē•”ē¹čˆ¬č—©č²©ēƄ釆ē…©é ’é£ÆęŒ½ę™©ē•Ŗē›¤ē£č•ƒč›®åŒŖ卑否妃åŗ‡å½¼ę‚²ę‰‰ę‰¹ęŠ«ę–ęÆ”ę³Œē–²ēš®ē¢‘ē§˜ē·‹ē½·č‚„č¢«čŖ¹č²»éæ非飛ę؋ē°øå‚™å°¾å¾®ęž‡ęƘēµēœ‰ē¾Ž\"],[\"c9a1\",\"é¼»ęŸŠēؗ匹ē–‹é«­å½¦č†č±č‚˜å¼¼åæ…ē•¢ē­†é€¼ę”§å§«åŖ›ē“ē™¾č¬¬äæµå½ŖęØ™ę°·ę¼‚ē“¢ē„Øč”Øč©•č±¹å»Ÿęē—…ē§’č‹—éŒØé‹²č’œč›­é°­å“å½¬ę–Œęµœē€•č²§č³“é »ę•ē“¶äøä»˜åŸ å¤«å©¦åƌå†Øåøƒåŗœę€–ꉶꕷꖧꙮ굮ēˆ¶ē¬¦č…č†ščŠ™č­œč² č³¦čµ“é˜œé™„ä¾®ę’«ę­¦čˆžč‘”č•ŖéƒØå°ę„“é¢Øč‘ŗč•—ä¼å‰Æå¾©å¹…ęœ\"],[\"caa1\",\"ē¦č…¹č¤‡č¦†ę·µå¼—ꉕę²ø仏ē‰©é®’åˆ†å»å™“å¢³ę†¤ę‰®ē„šå„®ē²‰ē³žē“›é›°ę–‡čžäø™ä½µå…µå”€å¹£å¹³å¼ŠęŸ„äø¦č”½é–‰é™›ē±³é åƒ»å£ē™–ē¢§åˆ„ēž„蔑ē®†åå¤‰ē‰‡ēƇē·Øč¾ŗčæ”遍ä¾æ勉åة弁鞭äæčˆ—é‹Ŗåœƒę•ę­©ē”«č£œč¼”ē©‚å‹Ÿå¢“ę…•ęˆŠęš®ęƍē°æč©å€£äæø包呆報儉宝峰å³Æå“©åŗ–ęŠ±ę§ę”¾ę–¹ęœ‹\"],[\"cba1\",\"ę³•ę³”ēƒ¹ē ²ēø«čƒžčŠ³čŒč“¬čœ‚褒čØŖč±Šé‚¦é‹’é£½é³³éµ¬ä¹äŗ”傍剖坊å¦Øåø½åæ˜åæ™ęˆæęš“ęœ›ęŸę£’å†’ē“”č‚Ŗč†Øč¬€č²Œč²æ鉾防吠頬北僕卜å¢Øę’²ęœ“ē‰§ē¦ē©†é‡¦å‹ƒę²”ę®†å €å¹Œå„”ęœ¬ēæ»å‡”ē›†ę‘©ē£Ø魔éŗ»åŸ‹å¦¹ę˜§ęžšęÆŽå“©ę§™å¹•č†œęž•é®ŖęŸ¾é±’ę”äŗ¦äæ£åˆęŠ¹ęœ«ę²«čæ„ä¾­ē¹­éŗæäø‡ę…¢ęŗ€\"],[\"cca1\",\"ę¼«č”“å‘³ęœŖ魅巳ē®•å²¬åÆ†čœœę¹Šč“‘ēØ”č„ˆå¦™ē²ę°‘ēœ å‹™å¤¢ē„”ē‰ŸēŸ›éœ§éµ”ꤋå©æåØ˜å†„åå‘½ę˜Žē›Ÿčæ·éŠ˜é³“å§Ŗē‰ę»…å…ę£‰ē¶æē·¬é¢éŗŗę‘øęØ”čŒ‚å¦„å­ŸęƛēŒ›ē›²ē¶²č€—č’™å„²ęœØ黙ē›®ę¢å‹æé¤…å°¤ęˆ»ē±¾č²°å•ę‚¶ē“‹é–€åŒä¹Ÿå†¶å¤œēˆŗč€¶é‡Žå¼„ēŸ¢åŽ„å½¹ē“„č–¬čسčŗé–ęŸ³č–®é‘“ę„‰ę„ˆę²¹ē™’\"],[\"cda1\",\"č«­č¼øå”Æ佑å„Ŗå‹‡å‹å®„å¹½ę‚ ę†‚ę–ęœ‰ęŸšę¹§ę¶ŒēŒ¶ēŒ·ē”±ē„č£•čŖ˜éŠé‚‘éƒµé›„čžå¤•äŗˆä½™äøŽčŖ‰č¼æ預傭幼妖容åŗøꏚęŗę“ę›œę„Šę§˜ę“‹ęŗ¶ē†”ē”ØēŖÆē¾Šč€€č‘‰č“‰č¦č¬”čøŠé„é™½é¤Šę…¾ęŠ‘ę¬²ę²ƒęµ“ēæŒēæ¼ę·€ē¾…čžŗč£øę„čŽ±é ¼é›·ę“›ēµ”č½é…Ŗä¹±åµåµę¬„ęæ«č—č˜­č¦§åˆ©åå±„Ꝏę¢Øē†ē’ƒ\"],[\"cea1\",\"ē—¢č£č£”里離é™ø律ēŽ‡ē«‹č‘ŽęŽ ē•„åŠ‰ęµęŗœē‰ē•™ē”«ē²’隆ē«œé¾ä¾¶ę…®ę—…č™œäŗ†äŗ®åƒšäø”凌åÆ®ę–™ę¢ę¶¼ēŒŸē™‚ēž­ē؜ē³§č‰Æč«’é¼é‡é™µé ˜åŠ›ē·‘å€«åŽ˜ęž—ę·‹ē‡ē³č‡Øč¼Ŗ隣鱗éŗŸē‘ å”ę¶™ē“Æ锞令伶例冷励å¶ŗꀜēŽ²ē¤¼č‹“鈓隷零霊éŗ—é½¢ęš¦ę­“列劣ēƒˆč£‚å»‰ę‹ę†ę¼£ē…‰ē°¾ē·“čÆ\"],[\"cfa1\",\"č“®é€£éŒ¬å‘‚é­Æę«“ē‚‰č³‚č·Æéœ²åŠ“å©å»Šå¼„ęœ—ę„¼ę¦”ęµŖę¼ē‰¢ē‹¼ēÆ­č€č¾č‹éƒŽå…­éŗ“ē¦„č‚‹éŒ²č«–å€­å’Œč©±ę­Ŗč³„č„‡ęƒ‘ęž é·²äŗ™äŗ˜é°č©«č—č•Øę¤€ę¹¾ē¢—č…•\"],[\"d0a1\",\"弌äøäø•äøŖäø±äø¶äø¼äøæ乂乖乘äŗ‚äŗ…豫äŗŠčˆ’弍äŗŽäŗžäŗŸäŗ äŗ¢äŗ°äŗ³äŗ¶ä»Žä»ä»„仆仂仗仞仭仟价伉佚估佛佝佗佇佶侈侏侘佻佩佰侑ä½Æ來侖儘äæ”äæŸäæŽäæ˜äæ›äæ‘äæšäæäæ¤äæ„倚å€Ø倔å€Ŗ倄倅伜äæ¶å€”倩倬äæ¾äæÆå€‘å€†åƒå‡ęœƒå•ååˆåšå–å¬åø傀傚傅傓傲\"],[\"d1a1\",\"僉僊傳僂僖僞僄僭僣僮價僵儉儁儂儖儕儔儚儔å„ŗ儷儼儻å„æ兀兒兌兔兢ē«ø兩å…Ŗ兮冀冂囘册冉冏冑冓冕冖冤冦冢冩å†Ŗå†«å†³å†±å†²å†°å†µå†½å‡…å‡‰å‡›å‡ č™•å‡©å‡­å‡°å‡µå‡¾åˆ„åˆ‹åˆ”åˆŽåˆ§åˆŖ刮刳刹剏剄剋剌剞剔å‰Ŗ剓剩剳å‰æ剽劍劔劒剱劈劑č¾Ø\"],[\"d2a1\",\"č¾§åŠ¬åŠ­åŠ¼åŠµå‹å‹å‹—å‹žå‹£å‹¦é£­å‹ å‹³å‹µå‹ø勹匆匈ē”ø匍匐匏匕匚匣åŒÆ匱匳åŒø區卆卅äø—卉卍凖卞卩卮夘卻卷厂厖厠厦厄厮厰厶參ē°’é›™åŸę›¼ē‡®å®åØ叭åŗ吁吽呀听吭吼吮吶吩吝呎咏呵咎呟呱呷呰咒呻咀呶咄咐咆哇咢å’ø咄咬哄哈å’Ø\"],[\"d3a1\",\"咫哂咤咾咼哘哄哦唏唔哽哮哭å“ŗ哢唹啀啣啌售啜啅啖啗å”ø唳啝喙喀å’Æ喊喟啻啾喘喞單啼喃喩喇å–Ø嗚嗅嗟嗄嗜嗤嗔嘔嗷嘖嗾嗽嘛嗹噎噐ē‡Ÿå˜“嘶嘲å˜ø噫噤å˜Æ噬å™Ŗ嚆嚀嚊嚠嚔嚏嚄嚮嚶嚓囂嚼囁囃囀囈囎囑囓囗囮囹圀å›æ圄圉\"],[\"d4a1\",\"圈國圍圓團圖嗇圜圦圷åœø坎圻址坏坩埀垈坔åæ垉垓垠垳垤åžŖ垰埃埆埔埒埓堊埖埣堋堙堝唲堔唢唋唰ęƀ唒堽唹墅墹墟墫å¢ŗ壞墻å¢ø墮壅壓壑壗壙壘壄壜壤壟å£Æå£ŗå£¹å£»å£¼å£½å¤‚å¤Šå¤å¤›ę¢¦å¤„å¤¬å¤­å¤²å¤ø夾ē«’儕儐儎儚儘儢儠儧儬儩\"],[\"d5a1\",\"å„ø妁妝佞侫妣妲姆å§Ø姜妍姙姚åØ„å؟åؑå؜å؉åؚ婀婬婉åصåض婢å©ŖåŖšåŖ¼åŖ¾å«‹å«‚åŖ½å«£å«—嫦嫩嫖å«ŗ嫻嬌嬋嬖嬲嫐å¬Ŗ嬶嬾孃孅孀孑孕孚孛孄孩孰孳孵å­øꖈå­ŗ宀它宦å®øåƃåƇåƉåƔåƐåƤåƦåÆ¢åƞåÆ„åÆ«åÆ°åƶåƳ尅將專對尓尠尢å°Øå°ø尹屁屆屎屓\"],[\"d6a1\",\"屐屏孱屬屮乢屶屹岌岑岔妛岫岻岶岼岷峅岾峇峙峩峽å³ŗ峭嶌å³Ŗ哋哕哗嵜哟哛哑哔哢哚哙哘嵌嵒嵎嵋嵬嵳嵶嶇嶄嶂嶢嶝嶬嶮嶽嶐嶷嶼巉巍巓巒巖巛巫已巵åø‹åøšåø™åø‘åø›åø¶åø·å¹„幃幀幎幗幔幟幢幤幇幵并å¹ŗéŗ¼å¹æåŗ å»å»‚廈廐廏\"],[\"d7a1\",\"廖廣廝廚廛廢廔å»Ø廩廬廱廳廰廓å»ø廾弃弉彝彜弋弑弖弩弭å¼ø彁彈彌彎å¼Æ彑彖彗彙彔彭彳彷徃徂å½æ徊很徑徇從徙徘徠å¾Øå¾­å¾¼åæ–åæ»åæ¤åæøåæ±åæę‚³åææę€”ę ę€™ę€ę€©ę€Žę€±ę€›ę€•ę€«ę€¦ę€ę€ŗꁚꁁęŖę·ęŸęŠę†ęę£ęƒę¤ę‚ę¬ę«ę™ę‚ę‚ęƒ§ę‚ƒę‚š\"],[\"d8a1\",\"ę‚„ę‚›ę‚–ę‚—ę‚’ę‚§ę‚‹ęƒ”ę‚øęƒ ęƒ“ę‚“åæ°ę‚½ęƒ†ę‚µęƒ˜ę…ę„•ę„†ęƒ¶ęƒ·ę„€ęƒ“ęƒŗę„ƒę„”ęƒ»ęƒ±ę„ę„Žę…‡ę„¾ę„Øꄧꅊę„æę„¼ę„¬ę„“ę„½ę…‚ę…„ę…³ę…·ę…˜ę…™ę…šę…«ę…“ę…Æę…„ę…±ę…Ÿę…ę…“ę…µę†™ę†–ę†‡ę†¬ę†”ę†šę†Šę†‘ę†«ę†®ę‡Œę‡Šę‡‰ę‡·ę‡ˆę‡ƒę‡†ę†ŗꇋē½¹ę‡ę‡¦ę‡£ę‡¶ę‡ŗꇓę‡æę‡½ę‡¼ę‡¾ęˆ€ęˆˆęˆ‰ęˆęˆŒęˆ”ęˆ›\"],[\"d9a1\",\"ęˆžęˆ”ęˆŖęˆ®ęˆ°ęˆ²ęˆ³ę‰ę‰Žę‰žę‰£ę‰›ę‰ ę‰Øę‰¼ęŠ‚ęŠ‰ę‰¾ęŠ’ęŠ“ęŠ–ę‹”ęŠƒęŠ”ę‹—ę‹‘ęŠ»ę‹ę‹æę‹†ę“”ę‹ˆę‹œę‹Œę‹Šę‹‚ę‹‡ęŠ›ę‹‰ęŒŒę‹®ę‹±ęŒ§ęŒ‚ęŒˆę‹Æę‹µęęŒ¾ęęœęęŽ–ęŽŽęŽ€ęŽ«ę¶ęŽ£ęŽęŽ‰ęŽŸęŽµę«ę©ęŽ¾ę©ę€ę†ę£ę‰ę’ę¶ę„ę–ę“ę†ę“ę¦ę¶ę”ę—ęØꐏꑧę‘Æꑶꑎę”Ŗę’•ę’“ę’„ę’©ę’ˆę’¼\"],[\"daa1\",\"ę“šę“’ę“…ę“‡ę’»ę“˜ę“‚ę“±ę“§čˆ‰ę“ ę“”ęŠ¬ę“£ę“Æę”¬ę“¶ę““ę“²ę“ŗę”€ę“½ę”˜ę”œę”…ę”¤ę”£ę”«ę”“ę”µę”·ę”¶ę”øē•‹ę•ˆę•–ę••ę•ę•˜ę•žę•ę•²ę•øę–‚ę–ƒč®Šę–›ę–Ÿę–«ę–·ę—ƒę—†ę—ę—„ę—Œę—’ę—›ę—™ę— ę—”ę—±ę²ę˜Šę˜ƒę—»ę³ę˜µę˜¶ę˜“ę˜œę™ę™„ę™‰ę™ę™žę™ę™¤ę™§ę™Øę™Ÿę™¢ę™°ęšƒęšˆęšŽęš‰ęš„ęš˜ęšę›ęš¹ę›‰ęš¾ęš¼\"],[\"dba1\",\"ꛄęšøꛖꛚꛠę˜æę›¦ę›©ę›°ę›µę›·ęœęœ–ęœžęœ¦ęœ§éœøęœ®ęœæęœ¶ęęœøęœ·ę†ęžę ę™ę£ę¤ęž‰ę°ęž©ę¼ęŖęžŒęž‹ęž¦ęž”ęž…ęž·ęŸÆęž“ęŸ¬ęž³ęŸ©ęžøęŸ¤ęŸžęŸęŸ¢ęŸ®ęž¹ęŸŽęŸ†ęŸ§ęŖœę žę”†ę ©ę”€ę”ę ²ę”Žę¢³ę «ę”™ę”£ę”·ę”æę¢Ÿę¢ę¢­ę¢”ę¢ę¢›ę¢ƒęŖ®ę¢¹ę”“ę¢µę¢ ę¢ŗę¤ę¢ę”¾ę¤ę£Šę¤ˆę£˜ę¤¢ę¤¦ę£”ę¤Œę£\"],[\"dca1\",\"ę£”ę£§ę£•ę¤¶ę¤’ę¤„ę£—ę££ę¤„ę£¹ę£ ę£Æę¤Øę¤Ŗę¤šę¤£ę¤”ę£†ę„¹ę„·ę„œę„øę„«ę„”ę„¾ę„®ę¤¹ę„“ę¤½ę„™ę¤°ę„”ę„žę„ę¦ę„Ŗę¦²ę¦®ę§ę¦æę§ę§“ę¦¾ę§ŽåÆØę§Šę§ę¦»ę§ƒę¦§ęØ®ę¦‘ę¦ ę¦œę¦•ę¦“ę§žę§Øę؂ę؛ę§æę¬Šę§¹ę§²ę§§ęØ…ę¦±ęØžę§­ęØ”ę§«ę؊ęØ’ę«ęØ£ęØ“ę©„ęØŒę©²ęضę©øę©‡ę©¢ę©™ę©¦ę©ˆęØøęØ¢ęŖęŖęŖ ęŖ„ęŖ¢ęŖ£\"],[\"dda1\",\"ęŖ—č˜—ęŖ»ę«ƒę«‚ęŖøęŖ³ęŖ¬ę«žę«‘ę«ŸęŖŖę«šę«Ŗę«»ę¬…č˜–ę«ŗę¬’ę¬–é¬±ę¬Ÿę¬øꬷē›œę¬¹é£®ę­‡ę­ƒę­‰ę­ę­™ę­”ę­›ę­Ÿę­”ę­øę­¹ę­æę®€ę®„ę®ƒę®ę®˜ę®•ę®žę®¤ę®Ŗꮫę®Æę®²ę®±ę®³ę®·ę®¼ęƆęƋęƓęƟęƬęÆ«ęƳęÆÆéŗ¾ę°ˆę°“ę°”ę°›ę°¤ę°£ę±žę±•ę±¢ę±Ŗę²‚ę²ę²šę²ę²›ę±¾ę±Øę±³ę²’ę²ę³„ę³±ę³“ę²½ę³—ę³…ę³ę²®ę²±ę²¾\"],[\"dea1\",\"ę²ŗę³›ę³Æę³™ę³Ŗę“Ÿč”ę“¶ę“«ę“½ę“øę“™ę“µę“³ę“’ę“Œęµ£ę¶“ęµ¤ęµšęµ¹ęµ™ę¶Žę¶•ęæ¤ę¶…ę·¹ęø•ęøŠę¶µę·‡ę·¦ę¶øę·†ę·¬ę·žę·Œę·Øę·’ę·…ę·ŗ귙귤귕ę·Ŗę·®ęø­ę¹®ęø®ęø™ę¹²ę¹Ÿęø¾ęø£ę¹«ęø«ę¹¶ę¹ęøŸę¹ƒęøŗę¹Žęø¤ę»æęøęøøęŗ‚ęŗŖęŗ˜ę»‰ęŗ·ę»“ęŗ½ęŗÆ껄ęŗ²ę»”껕ęŗęŗ„껂ęŗŸę½ę¼‘ēŒę»¬ę»øę»¾ę¼æę»²ę¼±ę»Æę¼²ę»Œ\"],[\"dfa1\",\"ę¼¾ę¼“ę»·ę¾†ę½ŗę½øę¾ę¾€ę½Æę½›ęæ³ę½­ę¾‚ę½¼ę½˜ę¾Žę¾‘ęæ‚ę½¦ę¾³ę¾£ę¾”ę¾¤ę¾¹ęæ†ę¾ŖęæŸęæ•ęæ¬ęæ”ęæ˜ęæ±ęæ®ęæ›ē€‰ē€‹ęæŗē€‘ē€ē€ęæ¾ē€›ē€šę½“ē€ē€˜ē€Ÿē€°ē€¾ē€²ē‘ē£ē‚™ē‚’ē‚Æēƒ±ē‚¬ē‚øē‚³ē‚®ēƒŸēƒ‹ēƒēƒ™ē„‰ēƒ½ē„œē„™ē…„ē…•ē†ˆē…¦ē…¢ē…Œē…–ē…¬ē†ē‡»ē†„ē†•ē†Øē†¬ē‡—ē†¹ē†¾ē‡’ē‡‰ē‡”ē‡Žē‡ ē‡¬ē‡§ē‡µē‡¼\"],[\"e0a1\",\"ē‡¹ē‡æēˆēˆēˆ›ēˆØēˆ­ēˆ¬ēˆ°ēˆ²ēˆ»ēˆ¼ēˆæē‰€ē‰†ē‰‹ē‰˜ē‰“ē‰¾ēŠ‚ēŠēŠ‡ēŠ’ēŠ–ēŠ¢ēŠ§ēŠ¹ēŠ²ē‹ƒē‹†ē‹„ē‹Žē‹’ē‹¢ē‹ ē‹”ē‹¹ē‹·å€ēŒ—ēŒŠēŒœēŒ–ēŒēŒ“ēŒÆēŒ©ēŒ„ēŒ¾ēŽēé»˜ē—ēŖēØē°ēøēµē»ēŗēˆēŽ³ēŽēŽ»ē€ē„ē®ēžē’¢ē…ē‘Æē„ēøē²ēŗē‘•ēæē‘Ÿē‘™ē‘ē‘œē‘©ē‘°ē‘£ē‘Ŗē‘¶ē‘¾ē’‹ē’žē’§ē“Šē“ē“”ē±\"],[\"e1a1\",\"ē“ ē“£ē“§ē“©ē“®ē“²ē“°ē“±ē“øē“·ē”„ē”ƒē”…ē”Œē”Žē”ē”•ē”“ē”žē”¦ē”¬ē”¼ē•„ē•ē•Šē•‰ē•›ē•†ē•šē•©ē•¤ē•§ē•«ē•­ē•øē•¶ē–†ē–‡ē•“ē–Šē–‰ē–‚ē–”ē–šē–ē–„ē–£ē—‚ē–³ē—ƒē–µē–½ē–øē–¼ē–±ē—ē—Šē—’ē—™ē—£ē—žē—¾ē—æē—¼ē˜ē—°ē—ŗē—²ē—³ē˜‹ē˜ē˜‰ē˜Ÿē˜§ē˜ ē˜”ē˜¢ē˜¤ē˜“ē˜°ē˜»ē™‡ē™ˆē™†ē™œē™˜ē™”ē™¢ē™Øē™©ē™Ŗē™§ē™¬ē™°\"],[\"e2a1\",\"ē™²ē™¶ē™øē™¼ēš€ēšƒēšˆēš‹ēšŽēš–ēš“ēš™ēššēš°ēš“ēšøēš¹ēšŗē›‚ē›ē›–ē›’ē›žē›”ē›„ē›§ē›Ŗč˜Æē›»ēœˆēœ‡ēœ„ēœ©ēœ¤ēœžēœ„ēœ¦ēœ›ēœ·ēœøē‡ēšēØē«ē›ē„ēæē¾ē¹ēžŽēž‹ēž‘ēž ēžžēž°ēž¶ēž¹ēžæēž¼ēž½ēž»ēŸ‡ēŸēŸ—ēŸšēŸœēŸ£ēŸ®ēŸ¼ē Œē ’ē¤¦ē  ē¤Ŗē”…ē¢Žē”“ē¢†ē”¼ē¢šē¢Œē¢£ē¢µē¢Ŗē¢Æē£‘ē£†ē£‹ē£”ē¢¾ē¢¼ē£…ē£Šē£¬\"],[\"e3a1\",\"ē£§ē£šē£½ē£“ē¤‡ē¤’ē¤‘ē¤™ē¤¬ē¤«ē„€ē„ ē„—ē„Ÿē„šē„•ē„“ē„ŗē„æē¦Šē¦ē¦§é½‹ē¦Ŗē¦®ē¦³ē¦¹ē¦ŗē§‰ē§•ē§§ē§¬ē§”ē§£ē؈ē؍ēؘēؙēØ ē؟ē¦€ēرēØ»ēؾēØ·ē©ƒē©—ē©‰ē©”ē©¢ē©©é¾ē©°ē©¹ē©½ēŖˆēŖ—ēŖ•ēŖ˜ēŖ–ēŖ©ē«ˆēŖ°ēŖ¶ē«…ē«„ēŖæ邃ē«‡ē«Šē«ē«ē«•ē«“ē«™ē«šē«ē«”ē«¢ē«¦ē«­ē«°ē¬‚ē¬ē¬Šē¬†ē¬³ē¬˜ē¬™ē¬žē¬µē¬Øē¬¶ē­\"],[\"e4a1\",\"ē­ŗē¬„ē­ē¬‹ē­Œē­…ē­µē­„ē­“ē­§ē­°ē­±ē­¬ē­®ē®ē®˜ē®Ÿē®ē®œē®šē®‹ē®’ē®ē­ē®™ēƋēƁēƌēƏē®“ēƆēƝēÆ©ē°‘ē°”ēƦēÆ„ē± ē°€ē°‡ē°“ēƳēÆ·ē°—ē°ēƶē°£ē°§ē°Ŗē°Ÿē°·ē°«ē°½ē±Œē±ƒē±”ē±ē±€ē±ē±˜ē±Ÿē±¤ē±–ē±„ē±¬ē±µē²ƒē²ē²¤ē²­ē²¢ē²«ē²”ē²Øē²³ē²²ē²±ē²®ē²¹ē²½ē³€ē³…ē³‚ē³˜ē³’ē³œē³¢é¬»ē³Æē³²ē³“ē³¶ē³ŗē“†\"],[\"e5a1\",\"ē“‚ē“œē“•ē“Šēµ…ēµ‹ē“®ē“²ē“æē“µēµ†ēµ³ēµ–ēµŽēµ²ēµØēµ®ēµēµ£ē¶“ē¶‰ēµ›ē¶ēµ½ē¶›ē¶ŗē¶®ē¶£ē¶µē·‡ē¶½ē¶«ēø½ē¶¢ē¶Æē·œē¶øē¶Ÿē¶°ē·˜ē·ē·¤ē·žē·»ē·²ē·”ēø…ēøŠēø£ēø”ēø’ēø±ēøŸēø‰ēø‹ēø¢ē¹†ē¹¦ēø»ēøµēø¹ē¹ƒēø·ēø²ēøŗē¹§ē¹ē¹–ē¹žē¹™ē¹šē¹¹ē¹Ŗē¹©ē¹¼ē¹»ēŗƒē·•ē¹½č¾®ē¹æēŗˆēŗ‰ēŗŒēŗ’ēŗēŗ“ēŗ”ēŗ–ēŗŽēŗ›ēŗœē¼øē¼ŗ\"],[\"e6a1\",\"ē½…ē½Œē½ē½Žē½ē½‘ē½•ē½”ē½˜ē½Ÿē½ ē½Øē½©ē½§ē½øē¾‚ē¾†ē¾ƒē¾ˆē¾‡ē¾Œē¾”ē¾žē¾ē¾šē¾£ē¾Æē¾²ē¾¹ē¾®ē¾¶ē¾øč­±ēæ…ēæ†ēæŠēæ•ēæ”ēæ”ēæ¦ēæ©ēæ³ēæ¹é£œč€†č€„č€‹č€’č€˜č€™č€œč€”č€Øč€æč€»čŠč†č’č˜čščŸč¢čØč³č²č°č¶č¹č½čæč‚„č‚†č‚…č‚›č‚“č‚šč‚­å†č‚¬čƒ›čƒ„čƒ™čƒčƒ„čƒščƒ–č„‰čƒÆčƒ±č„›č„©č„£č„Æ腋\"],[\"e7a1\",\"éš‹č…†č„¾č…“č…‘čƒ¼č…±č…®č…„č…¦č…“č†ƒč†ˆč†Šč†€č†‚č† č†•č†¤č†£č…Ÿč†“č†©č†°č†µč†¾č†øč†½č‡€č‡‚č†ŗ臉臍臑臙臘臈臚臟臠臧č‡ŗč‡»č‡¾čˆčˆ‚čˆ…čˆ‡čˆŠčˆčˆčˆ–čˆ©čˆ«čˆøčˆ³č‰€č‰™č‰˜č‰č‰šč‰Ÿč‰¤č‰¢č‰Øč‰Ŗč‰«čˆ®č‰±č‰·č‰øč‰¾čŠčŠ’čŠ«čŠŸčŠ»čŠ¬č‹”č‹£č‹Ÿč‹’č‹“č‹³č‹ŗčŽ“čŒƒč‹»č‹¹č‹žčŒ†č‹œčŒ‰č‹™\"],[\"e8a1\",\"čŒµčŒ“čŒ–čŒ²čŒ±č€čŒ¹čč…čŒÆčŒ«čŒ—čŒ˜čŽ…čŽščŽŖčŽŸčŽ¢čŽ–čŒ£čŽŽčŽ‡čŽŠč¼čŽµč³čµčŽ čŽ‰čŽØč“č“č«čŽč½čƒč˜č‹čč·č‡č č²čč¢č čŽ½čøč”†č»č‘­čŖč¼č•šč’„č‘·č‘«č’­č‘®č’‚č‘©č‘†č¬č‘Æč‘¹čµč“Šč‘¢č’¹č’æč’Ÿč“™č“č’»č“šč“č“č“†č“–č’”č””č“æč““č”—č”˜č”¬č”Ÿč”•č””č“¼č•€č•£č•˜č•ˆ\"],[\"e9a1\",\"蕁蘂蕋蕕薀薤薈薑薊č–Ø蕭薔薛č—Ŗč–‡č–œč•·č•¾č–č—‰č–ŗč—č–¹č—č—•č—č—„č—œč—¹č˜Šč˜“č˜‹č—¾č—ŗč˜†č˜¢č˜šč˜°č˜æč™ä¹•č™”č™Ÿč™§č™±čš“čš£čš©čšŖčš‹čšŒčš¶čšÆč›„č›†čš°č›‰č £čš«č›”č›žč›©č›¬č›Ÿč››č›Æčœ’čœ†čœˆčœ€čœƒč›»čœ‘čœ‰čœč›¹čœŠčœ“čœæčœ·čœ»čœ„čœ©čœšč čŸčøčŒčŽč“č—čØč®č™\"],[\"eaa1\",\"č“č£čŖč …čž¢čžŸčž‚čžÆčŸ‹čž½čŸ€čŸé›–čž«čŸ„čž³čŸ‡čŸ†čž»čŸÆčŸ²čŸ č č čŸ¾čŸ¶čŸ·č ŽčŸ’č ‘č –č •č ¢č ”č ±č ¶č ¹č §č »č”„č”‚č”’č”™č”žč”¢č”«č¢č”¾č¢žč”µč”½č¢µč”²č¢‚č¢—č¢’č¢®č¢™č¢¢č¢č¢¤č¢°č¢æč¢±č£ƒč£„č£”č£˜č£™č£č£¹č¤‚č£¼č£“č£Øč£²č¤„č¤Œč¤Šč¤“č„ƒč¤žč¤„č¤Ŗ褫脁脄褻褶č¤øč„Œč¤č„ č„ž\"],[\"eba1\",\"脦脤脭č„Ŗč„Æč„“č„·č„¾č¦ƒč¦ˆč¦Šč¦“č¦˜č¦”č¦©č¦¦č¦¬č¦Æč¦²č¦ŗč¦½č¦æč§€č§šč§œč§č§§č§“č§øč؃čؖčؐč،č؛č؝čØ„čØ¶č©č©›č©’č©†č©ˆč©¼č©­č©¬č©¢čŖ…čŖ‚čŖ„čŖØčŖ”čŖ‘čŖ„čŖ¦čŖščŖ£č«„č«č«‚č«šč««č«³č«§č«¤č«±č¬”č« č«¢č«·č«žč«›č¬Œč¬‡č¬šč«”č¬–č¬č¬—č¬ č¬³éž«č¬¦č¬«č¬¾č¬Øč­č­Œč­č­Žč­‰č­–č­›č­šč­«\"],[\"eca1\",\"č­Ÿč­¬č­Æč­“č­½č®€č®Œč®Žč®’č®“č®–č®™č®šč°ŗ豁č°æč±ˆč±Œč±Žč±č±•č±¢č±¬č±øč±ŗč²‚č²‰č²…č²Šč²č²Žč²”č±¼č²˜ęˆč²­č²Ŗč²½č²²č²³č²®č²¶č³ˆč³č³¤č³£č³šč³½č³ŗč³»č“„č“…č“Šč“‡č“č“č“é½Žč““č³č“”č“–čµ§čµ­čµ±čµ³č¶č¶™č·‚č¶¾č¶ŗč·č·šč·–č·Œč·›č·‹č·Ŗč·«č·Ÿč·£č·¼čøˆčø‰č·æčøčøžčøčøŸč¹‚čøµčø°čø“č¹Š\"],[\"eda1\",\"č¹‡č¹‰č¹Œč¹č¹ˆč¹™č¹¤č¹ čøŖč¹£č¹•č¹¶č¹²č¹¼čŗčŗ‡čŗ…čŗ„čŗ‹čŗŠčŗ“čŗ‘čŗ”čŗ™čŗŖčŗ”čŗ¬čŗ°č»†čŗ±čŗ¾č»…č»ˆč»‹č»›č»£č»¼č»»č»«č»¾č¼Šč¼…č¼•č¼’č¼™č¼“č¼œč¼Ÿč¼›č¼Œč¼¦č¼³č¼»č¼¹č½…č½‚č¼¾č½Œč½‰č½†č½Žč½—č½œč½¢č½£č½¤č¾œč¾Ÿč¾£č¾­č¾Æč¾·čæščæ„čæ¢čæŖčæÆ邇čæ“逅čæ¹čæŗ逑逕途逍逞逖逋逧逶逵逹čæø\"],[\"eea1\",\"遏遐遑遒逎遉逾遖遘遞éØéÆ遶éšØ遲邂遽邁邀邊邉邏é‚Øé‚Æé‚±é‚µéƒ¢éƒ¤ę‰ˆéƒ›é„‚é„’é„™é„²é„°é…Šé…–é…˜é…£é…„é…©é…³é…²é†‹é†‰é†‚é†¢é†«é†Æé†Ŗ醵醓é†ŗ釀釁釉釋釐釖釟釔釛釼釵釶鈞é‡æ鈔鈬鈕鈑鉞鉗鉅鉉鉤鉈銕éˆæ鉋鉐銜銖銓銛鉚鋏銹銷鋩錏é‹ŗ鍄錮\"],[\"efa1\",\"錙錢錚錣éŒŗ錵錻鍜鍠鍼鍮鍖鎰鎬鎭鎔鎹鏖鏗éØ鏄鏘鏃鏝鏐鏈鏤鐚鐔鐓鐃鐇鐐鐶鐫鐵鐔éŗ鑁鑒鑄鑛鑠鑢鑞é‘Ŗ鈩鑰鑵鑷鑽鑚鑼鑾钁é‘æ閂閇閊閔閖閘閙閠é–Ø閧閭閼閻閹閾闊ęæ¶é—ƒé—é—Œé—•é—”闖關闔闄闢阔é˜Ø阮é˜Æ陂陌陏陋陷陜陞\"],[\"f0a1\",\"陝陟陦陲陬隍隘隕隗éšŖ隧隱隲隰隓隶éšøéš¹é›Žé›‹é›‰é›č„é›œéœé›•é›¹éœ„éœ†éœˆéœ“éœŽéœ‘éœéœ–éœ™éœ¤éœŖ霰霹霽霾靄靆靈靂靉靜靠靤靦éØ勒靫靱靹鞅靼鞁éŗ鞆鞋鞏鞐鞜éžØ鞦鞣鞳鞓韃韆韈韋韜韭齏韲ē«ŸéŸ¶éŸµé é Œé ø頤頔頷頽锆锏锋锫é”Æé”°\"],[\"f1a1\",\"锱锓锳é¢Ŗé¢Æ颱颶飄飃飆飩飫餃餉餒餔餘餔餝餞餤餠餬餮餽餾鄂鄉鄅鄐鄋鄑鄒鄌鄕馗馘馄馭馮馼駟駛駝駘駑駭駮駱駲駻é§øé؁é؏é؅駢éؙéØ«éط驅驂驀驃éؾ驕驍驛驗驟驢驄驤驩驫é©ŖéŖ­éŖ°éŖ¼é«€é«é«‘髓體髞髟髢髣髦é«Æ髫髮髓髱髷\"],[\"f2a1\",\"髻鬆鬘鬚鬟鬢鬣鬄鬧é¬Ø鬩é¬Ŗ鬮é¬Æ鬲魄魃魏魍魎魑魘魓鮓鮃鮑鮖鮗鮟鮠é®Ø鮓éƀéƊ鮹éƆéƏéƑéƒéÆ£éÆ¢éƤéƔéÆ”é°ŗéƲéƱéư鰕鰔鰉鰓鰌鰆鰈鰒鰊鰄鰮鰛鰄鰤鰔鰰鱇鰲鱆鰾鱚鱠鱧鱶é±ø鳧鳬鳰铉铈鳫铃铆é“Ŗ铦é¶Æ铣铟鵄铕铒鵁é“æ链鵆鵈\"],[\"f3a1\",\"鵝鵞鵤鵑鵐鵙鵲鶉鶇鶫éµÆéµŗ鶚鶤鶩鶲鷄鷁鶻é¶øé¶ŗ鷆鷏鷂鷙鷓é·ø鷦鷭é·Æé·½éøšéø›éøžé¹µé¹¹é¹½éŗéŗˆéŗ‹éŗŒéŗ’éŗ•éŗ‘éŗéŗ„éŗ©éŗøéŗŖéŗ­é”黌黎黏黐黔黜點黝黠黄é»Øé»Æ黓黶黷黹黻黼黽鼇鼈ēš·é¼•é¼”鼬鼾齊齒齔齣齟齠齔齦齧齬é½Ŗ齷齲齶龕龜龠\"],[\"f4a1\",\"å Æ꧇遙ē‘¤å‡œē†™\"],[\"f9a1\",\"ēŗŠč¤œéˆéŠˆč“œäæ‰ē‚»ę˜±ę£ˆé‹¹ę›»å½…äøØ仔仼伀伃伹佖侒侊侚侔äæå€å€¢äææ倞偆偰偂傔僓僘兊兤冝冾凬刕劜劦勀勛匀匇匤卲厓厲叝ļ؎咜咊咩å“æ喆坙坄垬埈埇ļ؏ļؐ增墲夋儓儛儝儣妤å¦ŗ孖åƀē”ÆåƘåƬ尞岦å²ŗ峵哧嵓ļؑ嵂嵭å¶ø嶹巐弔弓彧德\"],[\"faa1\",\"åæžęę‚…ę‚Šęƒžęƒ•ę„ ęƒ²ę„‘ę„·ę„°ę†˜ęˆ“ęŠ¦ęµę‘ ę’ę“Žę•Žę˜€ę˜•ę˜»ę˜‰ę˜®ę˜žę˜¤ę™„ꙗꙙļØ’ę™³ęš™ęš ęš²ęšæę›ŗ꜎ļ¤©ę¦ęž»ę”’ęŸ€ę ę”„ę£ļؓę„ØļØ”ę¦˜ę§¢ęØ°ę©«ę©†ę©³ę©¾ę«¢ę«¤ęƖę°æę±œę²†ę±Æę³šę“„ę¶‡ęµÆę¶–ę¶¬ę·ę·øę·²ę·¼ęø¹ę¹œęø§ęø¼ęŗæę¾ˆę¾µęæµē€…ē€‡ē€Øē‚…ē‚«ē„ē„„ē…œē…†ē…‡ļؕē‡ē‡¾ēŠ±\"],[\"fba1\",\"ēŠ¾ēŒ¤ļؖē·ēŽ½ē‰ē–ē£ē’ē‡ēµē¦ēŖē©ē®ē‘¢ē’‰ē’Ÿē”ē•Æēš‚ēšœēšžēš›ēš¦ļؗē†åŠÆē ”ē”Žē”¤ē”ŗē¤°ļؘļؙļؚē¦”ļ؛ē¦›ē«‘ē«§ļ؜ē««ē®žļ؝ēµˆēµœē¶·ē¶ ē·–ē¹’ē½‡ē¾”ļØžčŒč¢čæč‡č¶č‘ˆč’“č•“č•™č•«ļØŸč–°ļØ ļØ”č ‡č£µčؒčØ·č©¹čŖ§čŖ¾č«ŸļØ¢č«¶č­“č­æč³°č³“č“’čµ¶ļØ£č»ļؤļ؄遧郞ļئ鄕鄧釚\"],[\"fca1\",\"釗釞釭釮釤釄鈆鈐鈊éˆŗ鉀鈼鉎鉙鉑鈹鉧銧鉷é‰ø鋧鋗鋙鋐ļا鋕鋠鋓錄錔鋻ļØØ錞é‹æ錝錂鍰鍗鎤鏆鏞éø鐱鑅鑈閒ļ§œļة隝éšÆ霳霻靃靍靏靑靕锗锄ļØŖļث餧ļج馞驎髙髜魵魲鮏鮱鮻鰀鵰鵫ļØ­éø™é»‘\"],[\"fcf1\",\"ā…°\",9,\"ļæ¢ļæ¤ļ¼‡ļ¼‚\"],[\"8fa2af\",\"Ė˜Ė‡ĀøĖ™ĖĀÆĖ›Ėšļ½žĪ„Ī…\"],[\"8fa2c2\",\"Ā”Ā¦Āæ\"],[\"8fa2eb\",\"ĀŗĀŖĀ©Ā®ā„¢Ā¤ā„–\"],[\"8fa6e1\",\"Ī†ĪˆĪ‰ĪŠĪŖ\"],[\"8fa6e7\",\"ĪŒ\"],[\"8fa6e9\",\"ĪŽĪ«\"],[\"8fa6ec\",\"Ī\"],[\"8fa6f1\",\"Ī¬Ī­Ī®ĪÆĻŠĪĻŒĻ‚ĻĻ‹Ī°ĻŽ\"],[\"8fa7c2\",\"Š‚\",10,\"ŠŽŠ\"],[\"8fa7f2\",\"ђ\",10,\"ўџ\"],[\"8fa9a1\",\"ƆĐ\"],[\"8fa9a4\",\"Ħ\"],[\"8fa9a6\",\"IJ\"],[\"8fa9a8\",\"ŁÄæ\"],[\"8fa9ab\",\"ÅŠĆ˜Å’\"],[\"8fa9af\",\"Å¦Ćž\"],[\"8fa9c1\",\"Ć¦Ä‘Ć°Ä§Ä±Ä³ÄøłŀʼnŋĆøÅ“ĆŸÅ§Ć¾\"],[\"8faaa1\",\"ƁƀƄƂĂĒÄ€Ä„Ć…ĆƒÄ†ÄˆÄŒĆ‡ÄŠÄŽĆ‰ĆˆĆ‹ĆŠÄšÄ–Ä’Ä˜\"],[\"8faaba\",\"ÄœÄžÄ¢Ä Ä¤ĆĆŒĆĆŽĒÄ°ÄŖÄ®ÄØÄ“Ä¶Ä¹Ä½Ä»ÅƒÅ‡Å…Ć‘Ć“Ć’Ć–Ć”Ē‘ÅÅŒĆ•Å”Å˜Å–ÅšÅœÅ ÅžÅ¤Å¢ĆšĆ™ĆœĆ›Å¬Ē“Å°ÅŖŲŮÅØĒ—Ē›Ē™Ē•Å“ƝÅøŶŹŽŻ\"],[\"8faba1\",\"Ć”Ć Ć¤Ć¢ÄƒĒŽÄÄ…Ć„Ć£Ä‡Ä‰ÄĆ§Ä‹ÄĆ©ĆØĆ«ĆŖěėēęĒµÄÄŸ\"],[\"8fabbd\",\"ĔĄƭƬĆÆĆ®Ē\"],[\"8fabc5\",\"Ä«ÄÆĩĵķÄŗÄ¾Ä¼Å„ÅˆÅ†Ć±Ć³Ć²Ć¶Ć“Ē’Å‘ÅĆµÅ•Å™Å—Å›ÅÅ”ÅŸÅ„Å£ĆŗĆ¹Ć¼Ć»Å­Ē”űūųÅÆÅ©Ē˜ĒœĒšĒ–ÅµĆ½ĆæÅ·Åŗžż\"],[\"8fb0a1\",\"äø‚äø„äø…äøŒäø’äøŸäø£äø¤äøØäø«äø®äøÆäø°äøµä¹€ä¹ä¹„乇乑乚乜乣ä¹Ø乩乓乵乹ä¹æäŗäŗ–äŗ—äŗäŗÆäŗ¹ä»ƒä»ä»šä»›ä» ä»”仢ä»Øä»Æ仱仳仵份仾ä»æ伀伂伃伈伋伌伒伕伖众伙伮伱你伳伵伷伹伻伾佀佂佈佉佋佌佒佔佖佘佟佣ä½Ŗ佬佮佱佷ä½øä½¹ä½ŗ佽佾侁侂侄\"],[\"8fb1a1\",\"侅侉侊侌侎侐侒侓侔侗侙侚侞侟侲侷侹侻侼侽侾äæ€äæäæ…äæ†äæˆäæ‰äæ‹äæŒäæäæäæ’äæœäæ äæ¢äæ°äæ²äæ¼äæ½äææ倀倁倄倇倊倌倎倐倓倗倘倛倜倝倞倢倧倮倰倲倳倵偀偁偂偅偆偊偌偎偑偒偓偗偙偟偠偢偣偦偧åŖ偭偰偱倻傁傃傄傆傊傎傏傐\"],[\"8fb2a1\",\"傒傓傔傖傛傜傞\",4,\"å‚Ŗå‚Æ傰傹å‚ŗ傽僀僃僄僇僌僎僐僓僔僘僜僝僟僢僤僦åƒØ僩åƒÆ僱僶åƒŗ僾儃儆儇儈儋儌儍儎僲儐儗儙儛儜儝儞儣儧å„Ø儬儭å„Æ儱儳儓儵å„ø儹兂兊兏兓兕兗兘兟兤兦兾冃冄冋冎冘冝冔冣冭å†øå†ŗ冼冾å†æ凂\"],[\"8fb3a1\",\"凈减凑凒凓凕凘凞凢凄凮凲凳凓凷刁刂刅划刓刕刖刘刢åˆØ刱刲刵刼剅剉剕剗剘剚剜剟剠剔剦剮剷å‰ø剹劀劂劅劊劌劓劕劖劗劘劚劜劤劄劦劧åŠÆ劰劶劷åŠøåŠŗ劻劽勀勄勆勈勌勏勑勔勖勛勜勔勄å‹Ø勩å‹Ŗ勬勰勱勓勶勷匀匃匊匋\"],[\"8fb4a1\",\"匌匑匓匘匛匜匞匟匄匧åŒØ匩匫匬匭匰匲匵匼匽匾卂卌卋卙卛協卣卄卬卭卲卹卾厃厇厈厎厓厔厙厝厔厤åŽŖ厫åŽÆ厲厓厵厷åŽøåŽŗ厽叀叅叏叒叓叕叚叝叞叠另叧叵吂吓吚吔吧åØåŖåÆ吱吓吵呃呄呇呍呏呞呢呤呦呧呩呫呭呮呓å‘æ\"],[\"8fb5a1\",\"咁咃咅咈咉咍咑咕咖咜咟咔咦咧咩å’Ŗ咭咮咱咷咹å’ŗ咻å’æ哆哊响哎哠å“Ŗ哬å“Æ哶哼哾å“æ唀唁唅唈唉唌唍唎唕å”Ŗ唫唲唵唶唻唼唽啁啇啉啊啍啐啑啘啚啛啞啠啔啤啦å•æ喁喂喆喈喎喏喑喒喓喔喗喣喤喭喲å–æ嗁嗃嗆嗉嗋嗌嗎嗑嗒\"],[\"8fb6a1\",\"嗓嗗嗘嗛嗞嗢嗩嗶å—æ嘅嘈嘊嘍\",5,\"嘙嘬嘰嘳嘵嘷嘹嘻嘼嘽å˜æ噀噁噃噄噆噉噋噍噏噔噞噠噔噢噣噦噩噭å™Æ噱噲噵嚄嚅嚈嚋嚌嚕嚙嚚嚝嚞嚟嚦嚧åšØ嚩嚫嚬嚭嚱嚳嚷嚾囅囉囊囋囏囐囌囍囙囜囝囟囔囤\",4,\"囱囫园\"],[\"8fb7a1\",\"囶囷圁圂圇圊圌圑圕圚圛圝圠圢圣圤圄圩åœŖ圬圮åœÆ圳圓圽圾åœæ坅坆坌坍坒坢坄坧åØ坫坭\",4,\"坳坓坵坷坹åŗ坻坼坾垁垃垌垔垗垙垚垜垝垞垟垔垕垧åžØ垩垬åžø垽埇埈埌埏埕埝埞埤埦埧埩埭埰埵埶åŸø埽埾åŸæ堃堄堈堉埔\"],[\"8fb8a1\",\"堌堍堛堞堟堠堦堧堭堲堹å æ唉唌唍唏唐唕唟唔唤唧å”Øå”ø唼å”æå¢€å¢å¢‡å¢ˆå¢‰å¢Šå¢Œå¢å¢å¢å¢”å¢–å¢å¢ å¢”å¢¢å¢¦å¢©å¢±å¢²å£„å¢¼å£‚å£ˆå£å£Žå£å£’å£”å£–å£šå£å£”å£¢å£©å£³å¤…å¤†å¤‹å¤Œå¤’å¤“å¤”č™å¤å¤”å¤£å¤¤å¤Øå¤Æ夰夳夵夶å¤æ儃儆儒儓儙儛儝儞償儔儣儫儭\"],[\"8fb9a1\",\"å„Æ儲儵儶儹儻儼妋妌妎妒妕妗妟妤妧妭妮å¦Æ妰妳妷å¦ŗ妼姁姃姄姈姊姍姒姝姞姟姣姤姧姮å§Æ姱姲姓姷å؀å؄å،å؍å؎åؒåؓå؞åØ£åؤåاåØØåØŖåØ­åذ婄婅婇婈婌婐婕婞婣婄婧婭婷å©ŗ婻婾åŖ‹åŖåŖ“åŖ–åŖ™åŖœåŖžåŖŸåŖ åŖ¢åŖ§åŖ¬åŖ±åŖ²åŖ³åŖµåŖøåŖŗåŖ»åŖæ\"],[\"8fbaa1\",\"嫄嫆嫈嫏嫚嫜嫠嫄å«Ŗ嫮嫵嫶嫽嬀嬁嬈嬗嬓嬙嬛嬝嬔嬄嬭å¬ø孁孋孌孒孖孞å­Øå­®å­Æ孼孽孾å­æ宁宄宆宊宎宐宑宓宔宖å®Ø宩宬宭å®Æ宱宲宷å®ŗ宼åƀåƁåƍåƏåƖ\",4,\"åÆ åÆÆåƱåÆ“åƽ尌尗尞尟尣尦尩尫尬尮尰尲尵尶屙屚屜屢屣屧å±Ø屩\"],[\"8fbba1\",\"屭屰屓屵å±ŗ屻屼屽岇岈岊岏岒岝岟岠岢岣岦å²Ŗ岲岓岵å²ŗ峉峋峒峝峗峮峱峲峓品哆响哒哫哣哤哦哧哱哓哹哽å“æ嵂嵃嵆嵈嵕嵑嵙嵊嵟嵠嵔嵢嵤åµŖåµ­åµ°åµ¹åµŗåµ¾åµæ嶁嶃嶈嶊嶒嶓嶔嶕嶙嶛嶟嶠嶧嶫嶰嶓å¶ø嶹巃巇巋巐巎巘巙巠巤\"],[\"8fbca1\",\"å·©å·øå·¹åø€åø‡åøåø’åø”åø•åø˜åøŸåø åø®åøØåø²åøµåø¾å¹‹å¹å¹‰å¹‘幖幘幛幜幞å¹Øå¹Ŗ\",4,\"å¹°åŗ€åŗ‹åŗŽåŗ¢åŗ¤åŗ„åŗØåŗŖåŗ¬åŗ±åŗ³åŗ½åŗ¾åŗæ廆廌廋廎廑廒廔廕廜廞廄廫异弆弇弈弎弙弜弝弔弢弣弤å¼Ø弫弬弮弰弓弶弻弽å¼æ彀彄彅彇彍彐彔彘彛彠彣彤彧\"],[\"8fbda1\",\"å½Æ彲当彵å½øå½ŗ彽彾徉徍徏徖徜徝徢徧徫徤徬å¾Æå¾°å¾±å¾øåæ„åæ‡åæˆåæ‰åæ‹åæ\",4,\"åæžåæ”åæ¢åæØåæ©åæŖåæ¬åæ­åæ®åæÆåæ²åæ³åæ¶åæŗåæ¼ę€‡ę€Šę€ę€“ę€”ę€—ę€˜ę€šę€Ÿę€¤ę€­ę€³ę€µę€ę‡ęˆę‰ęŒę‘ę”ę–ę—ęę”ę§ę±ę¾ęæę‚‚ę‚†ę‚ˆę‚Šę‚Žę‚‘ę‚“ę‚•ę‚˜ę‚ę‚žę‚¢ę‚¤ę‚„ę‚Øꂰꂱꂷ\"],[\"8fbea1\",\"ę‚»ę‚¾ęƒ‚ęƒ„ęƒˆęƒ‰ęƒŠęƒ‹ęƒŽęƒęƒ”ęƒ•ęƒ™ęƒ›ęƒęƒžęƒ¢ęƒ„ęƒ²ęƒµęƒøęƒ¼ęƒ½ę„‚ę„‡ę„Šę„Œę„\",4,\"ę„–ę„—ę„™ę„œę„žę„¢ę„Ŗę„«ę„°ę„±ę„µę„¶ę„·ę„¹ę…ę……ę…†ę…‰ę…žę… ę…¬ę…²ę…øę…»ę…¼ę…æę†€ę†ę†ƒę†„ę†‹ę†ę†’ę†“ę†—ę†˜ę†œę†ę†Ÿę† ę†„ę†Øę†Ŗꆭę†øę†¹ę†¼ę‡€ę‡ę‡‚ę‡Žę‡ę‡•ę‡œę‡ę‡žę‡Ÿę‡”ę‡¢ę‡§ę‡©ę‡„\"],[\"8fbfa1\",\"ꇬꇭę‡Æęˆęˆƒęˆ„ęˆ‡ęˆ“ęˆ•ęˆœęˆ ęˆ¢ęˆ£ęˆ§ęˆ©ęˆ«ęˆ¹ęˆ½ę‰‚ę‰ƒę‰„ę‰†ę‰Œę‰ę‰‘ę‰’ę‰”ę‰–ę‰šę‰œę‰¤ę‰­ę‰Æę‰³ę‰ŗę‰½ęŠęŠŽęŠęŠęŠ¦ęŠØęŠ³ęŠ¶ęŠ·ęŠŗęŠ¾ęŠæꋄꋎꋕꋖꋚę‹Ŗę‹²ę‹“ę‹¼ę‹½ęŒƒęŒ„ęŒŠęŒ‹ęŒęŒęŒ“ęŒ–ęŒ˜ęŒ©ęŒŖęŒ­ęŒµęŒ¶ęŒ¹ęŒ¼ęę‚ęƒę„ę†ęŠę‹ęŽę’ę“ę”ę˜ę›ę„ę¦ę¬ę­ę±ę“ęµ\"],[\"8fc0a1\",\"ęøę¼ę½ęæꎂꎄꎇꎊꎐꎔꎕꎙꎚꎞꎤꎦꎭꎮęŽÆęŽ½ęę…ęˆęŽę‘ę“ę”ę•ęœę ę„ęŖę¬ę²ę³ęµęøę¹ę‰ęŠęę’ę”ę˜ęžę ę¢ę¤ę„ę©ęŖęÆę°ęµę½ęæę‘‹ę‘ę‘‘ę‘’ę‘“ę‘”ę‘šę‘›ę‘œę‘ę‘Ÿę‘ ę‘”ę‘£ę‘­ę‘³ę‘“ę‘»ę‘½ę’…ę’‡ę’ę’ę’‘ę’˜ę’™ę’›ę’ę’Ÿę’”ę’£ę’¦ę’Øę’¬ę’³ę’½ę’¾ę’æ\"],[\"8fc1a1\",\"ę“„ę“‰ę“Šę“‹ę“Œę“Žę“ę“‘ę“•ę“—ę“¤ę“„ę“©ę“Ŗꓭꓰꓵꓷꓻę“æę”ę”„ę”ˆę”‰ę”Šę”ę”“ę””ę”–ę”™ę”›ę”žę”Ÿę”¢ę”¦ę”©ę”®ę”±ę”ŗę”¼ę”½ę•ƒę•‡ę•‰ę•ę•’ę•”ę•Ÿę• ę•§ę•«ę•ŗę•½ę–ę–…ę–Šę–’ę–•ę–˜ę–ę– ę–£ę–¦ę–®ę–²ę–³ę–“ę–æę—‚ę—ˆę—‰ę—Žę—ę—”ę—–ę—˜ę—Ÿę—°ę—²ę—“ę—µę—¹ę—¾ę—æꘀꘄꘈꘉ꘍ꘑꘒꘕꘖꘝ\"],[\"8fc2a1\",\"ę˜žę˜”ę˜¢ę˜£ę˜¤ę˜¦ę˜©ę˜Ŗę˜«ę˜¬ę˜®ę˜°ę˜±ę˜³ę˜¹ę˜·ę™€ę™…ę™†ę™Šę™Œę™‘ę™Žę™—ę™˜ę™™ę™›ę™œę™ ę™”ę›»ę™Ŗę™«ę™¬ę™¾ę™³ę™µę™æę™·ę™øę™¹ę™»ęš€ę™¼ęš‹ęšŒęšęšęš’ęš™ęššęš›ęšœęšŸęš ęš¤ęš­ęš±ęš²ęšµęš»ęšæꛀꛂꛃꛈꛌꛎꛏꛔꛛꛟę›Øꛫꛬꛮę›ŗęœ…ęœ‡ęœŽęœ“ęœ™ęœœęœ ęœ¢ęœ³ęœ¾ę…ę‡ęˆęŒę”ę•ę\"],[\"8fc3a1\",\"ę¦ę¬ę®ę“ę¶ę»ęžęž„ęžŽęžęž‘ęž“ęž–ęž˜ęž™ęž›ęž°ęž±ęž²ęžµęž»ęž¼ęž½ęŸ¹ęŸ€ęŸ‚ęŸƒęŸ…ęŸˆęŸ‰ęŸ’ęŸ—ęŸ™ęŸœęŸ”ęŸ¦ęŸ°ęŸ²ęŸ¶ęŸ·ę”’ę ”ę ™ę ę Ÿę Øꠧ꠬꠭ę Æę °ę ±ę ³ę »ę æę”„ę”…ę”Šę”Œę”•ę”—ę”˜ę”›ę”«ę”®\",4,\"ę”µę”¹ę”ŗę”»ę”¼ę¢‚ę¢„ę¢†ę¢ˆę¢–ę¢˜ę¢šę¢œę¢”ę¢£ę¢„ę¢©ę¢Ŗę¢®ę¢²ę¢»ę£…ę£ˆę£Œę£\"],[\"8fc4a1\",\"ę£ę£‘ę£“ę£–ę£™ę£œę£ę£„ę£Øę£Ŗę£«ę£¬ę£­ę£°ę£±ę£µę£¶ę£»ę£¼ę£½ę¤†ę¤‰ę¤Šę¤ę¤‘ę¤“ę¤–ę¤—ę¤±ę¤³ę¤µę¤øę¤»ę„‚ę„…ę„‰ę„Žę„—ę„›ę„£ę„¤ę„„ę„¦ę„Øę„©ę„¬ę„°ę„±ę„²ę„ŗę„»ę„æę¦€ę¦ę¦’ę¦–ę¦˜ę¦”ę¦„ę¦¦ę¦Øꦫꦭę¦Æꦷę¦øę¦ŗę¦¼ę§…ę§ˆę§‘ę§–ę§—ę§¢ę§„ę§®ę§Æę§±ę§³ę§µę§¾ę؀ę؁ę؃ę؏ęؑęؕęؚę؝ęØ ęؤęØØęØ°ęز\"],[\"8fc5a1\",\"ęØ“ęØ·ęØ»ęؾęØæꩅꩆꩉꩊ꩎꩐꩑꩒꩕꩖꩛ꩤꩧę©Ŗę©±ę©³ę©¾ęŖęŖƒęŖ†ęŖ‡ęŖ‰ęŖ‹ęŖ‘ęŖ›ęŖęŖžęŖŸęŖ„ęŖ«ęŖÆęŖ°ęŖ±ęŖ“ęŖ½ęŖ¾ęŖæę«†ę«‰ę«ˆę«Œę«ę«”ę«•ę«–ę«œę«ę«¤ę«§ę«¬ę«°ę«±ę«²ę«¼ę«½ę¬‚ę¬ƒę¬†ę¬‡ę¬‰ę¬ę¬ę¬‘ę¬—ę¬›ę¬žę¬¤ę¬Øꬫꬬę¬Æꬵꬶꬻę¬æę­†ę­Šę­ę­’ę­–ę­˜ę­ę­ ę­§ę­«ę­®ę­°ę­µę­½\"],[\"8fc6a1\",\"ę­¾ę®‚ę®…ę®—ę®›ę®Ÿę® ę®¢ę®£ę®Øꮩꮬꮭꮮꮰę®øę®¹ę®½ę®¾ęƃęƄęƉęƌęƖęƚęÆ”ęÆ£ęƦęƧęÆ®ęƱęÆ·ęƹęÆæę°‚ę°„ę°…ę°‰ę°ę°Žę°ę°’ę°™ę°Ÿę°¦ę°§ę°Øę°¬ę°®ę°³ę°µę°¶ę°ŗę°»ę°æę±Šę±‹ę±ę±ę±’ę±”ę±™ę±›ę±œę±«ę±­ę±Æ걓걶ę±øę±¹ę±»ę²…ę²†ę²‡ę²‰ę²”ę²•ę²—ę²˜ę²œę²Ÿę²°ę²²ę²“ę³‚ę³†ę³ę³ę³ę³‘ę³’ę³”ę³–\"],[\"8fc7a1\",\"ę³šę³œę³ ę³§ę³©ę³«ę³¬ę³®ę³²ę³“ę“„ę“‡ę“Šę“Žę“ę“‘ę““ę“šę“¦ę“§ę“Ø걧ꓮę“Æę“±ę“¹ę“¼ę“æęµ—ęµžęµŸęµ”ęµ„ęµ§ęµÆęµ°ęµ¼ę¶‚ę¶‡ę¶‘ę¶’ę¶”ę¶–ę¶—ę¶˜ę¶Ŗę¶¬ę¶“ę¶·ę¶¹ę¶½ę¶æę·„ę·ˆę·Šę·Žę·ę·–ę·›ę·ę·Ÿę· ę·¢ę·„ę·©ę·Æę·°ę·“ę·¶ę·¼ęø€ęø„ęøžęø¢ęø§ęø²ęø¶ęø¹ęø»ęø¼ę¹„ę¹…ę¹ˆę¹‰ę¹‹ę¹ę¹‘ę¹’ę¹“ę¹”ę¹—ę¹œę¹ę¹ž\"],[\"8fc8a1\",\"ę¹¢ę¹£ę¹Øę¹³ę¹»ę¹½ęŗęŗ“ęŗ™ęŗ ęŗ§ęŗ­ęŗ®ęŗ±ęŗ³ęŗ»ęŗæę»€ę»ę»ƒę»‡ę»ˆę»Šę»ę»Žę»ę»«ę»­ę»®ę»¹ę»»ę»½ę¼„ę¼ˆę¼Šę¼Œę¼ę¼–ę¼˜ę¼šę¼›ę¼¦ę¼©ę¼Ŗę¼Æę¼°ę¼³ę¼¶ę¼»ę¼¼ę¼­ę½ę½‘ę½’ę½“ę½—ę½™ę½šę½ę½žę½”ę½¢ę½Øę½¬ę½½ę½¾ę¾ƒę¾‡ę¾ˆę¾‹ę¾Œę¾ę¾ę¾’ę¾“ę¾”ę¾–ę¾šę¾Ÿę¾ ę¾„ę¾¦ę¾§ę¾Øę¾®ę¾Æę¾°ę¾µę¾¶ę¾¼ęæ…ęæ‡ęæˆęæŠ\"],[\"8fc9a1\",\"ęæšęæžęæØęæ©ęæ°ęæµęæ¹ęæ¼ęæ½ē€€ē€…ē€†ē€‡ē€ē€—ē€ ē€£ē€Æē€“ē€·ē€¹ē€¼ēƒē„ēˆē‰ēŠē‹ē”ē•ēēžēŽē¤ē„ē¬ē®ēµē¶ē¾ē‚ē‚…ē‚†ē‚”\",4,\"ē‚›ē‚¤ē‚«ē‚°ē‚±ē‚“ē‚·ēƒŠēƒ‘ēƒ“ēƒ”ēƒ•ēƒ–ēƒ˜ēƒœēƒ¤ēƒŗē„ƒ\",4,\"ē„‹ē„Œē„ē„žē„ ē„«ē„­ē„Æē„°ē„±ē„øē…ē……ē…†ē…‡ē…Šē…‹ē…ē…’ē…—ē…šē…œē…žē… \"],[\"8fcaa1\",\"ē…Øē…¹ē†€ē†…ē†‡ē†Œē†’ē†šē†›ē† ē†¢ē†Æē†°ē†²ē†³ē†ŗē†æē‡€ē‡ē‡„ē‡‹ē‡Œē‡“ē‡–ē‡™ē‡šē‡œē‡øē‡¾ēˆ€ēˆ‡ēˆˆēˆ‰ēˆ“ēˆ—ēˆšēˆēˆŸēˆ¤ēˆ«ēˆÆēˆ“ēˆøēˆ¹ē‰ē‰‚ē‰ƒē‰…ē‰Žē‰ē‰ē‰“ē‰•ē‰–ē‰šē‰œē‰žē‰ ē‰£ē‰Øē‰«ē‰®ē‰Æē‰±ē‰·ē‰øē‰»ē‰¼ē‰æēŠ„ēŠ‰ēŠēŠŽēŠ“ēŠ›ēŠØēŠ­ēŠ®ēŠ±ēŠ“ēŠ¾ē‹ē‹‡ē‹‰ē‹Œē‹•ē‹–ē‹˜ē‹Ÿē‹„ē‹³ē‹“ē‹ŗē‹»\"],[\"8fcba1\",\"ē‹¾ēŒ‚ēŒ„ēŒ…ēŒ‡ēŒ‹ēŒēŒ’ēŒ“ēŒ˜ēŒ™ēŒžēŒ¢ēŒ¤ēŒ§ēŒØēŒ¬ēŒ±ēŒ²ēŒµēŒŗēŒ»ēŒ½ēƒēēē’ē–ē˜ēēžēŸē ē¦ē§ē©ē«ē¬ē®ēÆē±ē·ē¹ē¼ēŽ€ēŽēŽƒēŽ…ēŽ†ēŽŽēŽēŽ“ēŽ•ēŽ—ēŽ˜ēŽœēŽžēŽŸēŽ ēŽ¢ēŽ„ēŽ¦ēŽŖēŽ«ēŽ­ēŽµēŽ·ēŽ¹ēŽ¼ēŽ½ēŽæē…ē†ē‰ē‹ēŒēē’ē“ē–ē™ēē”ē£ē¦ē§ē©ē“ēµē·ē¹ēŗē»ē½\"],[\"8fcca1\",\"ēæē€ēē„ē‡ēŠē‘ēšē›ē¤ē¦ēØ\",9,\"ē¹ē‘€ē‘ƒē‘„ē‘†ē‘‡ē‘‹ē‘ē‘‘ē‘’ē‘—ē‘ē‘¢ē‘¦ē‘§ē‘Øē‘«ē‘­ē‘®ē‘±ē‘²ē’€ē’ē’…ē’†ē’‡ē’‰ē’ē’ē’‘ē’’ē’˜ē’™ē’šē’œē’Ÿē’ ē’”ē’£ē’¦ē’Øē’©ē’Ŗē’«ē’®ē’Æē’±ē’²ē’µē’¹ē’»ē’æē“ˆē“‰ē“Œē“ē““ē“˜ē“šē“›ē“žē“Ÿē“¤ē“Øē“Ŗē“«ē“Æē““ē“ŗē“»ē“¼ē“æē”†\"],[\"8fcda1\",\"ē”’ē”–ē”—ē” ē””ē”¤ē”§ē”©ē”Ŗē”Æē”¶ē”¹ē”½ē”¾ē”æē•€ē•ƒē•‡ē•ˆē•Žē•ē•’ē•—ē•žē•Ÿē•”ē•Æē•±ē•¹\",5,\"ē–ē–…ē–ē–’ē–“ē–•ē–™ē–œē–¢ē–¤ē–“ē–ŗē–æē—€ē—ē—„ē—†ē—Œē—Žē—ē——ē—œē—Ÿē— ē—”ē—¤ē—§ē—¬ē—®ē—Æē—±ē—¹ē˜€ē˜‚ē˜ƒē˜„ē˜‡ē˜ˆē˜Šē˜Œē˜ē˜’ē˜“ē˜•ē˜–ē˜™ē˜›ē˜œē˜ē˜žē˜£ē˜„ē˜¦ē˜©ē˜­ē˜²ē˜³ē˜µē˜øē˜¹\"],[\"8fcea1\",\"ē˜ŗē˜¼ē™Šē™€ē™ē™ƒē™„ē™…ē™‰ē™‹ē™•ē™™ē™Ÿē™¤ē™„ē™­ē™®ē™Æē™±ē™“ēšēš…ēšŒēšēš•ēš›ēšœēšēšŸēš ēš¢\",6,\"ēšŖēš­ēš½ē›ē›…ē›‰ē›‹ē›Œē›Žē›”ē›™ē› ē›¦ē›Øē›¬ē›°ē›±ē›¶ē›¹ē›¼ēœ€ēœ†ēœŠēœŽēœ’ēœ”ēœ•ēœ—ēœ™ēœšēœœēœ¢ēœØēœ­ēœ®ēœÆēœ“ēœµēœ¶ēœ¹ēœ½ēœ¾ē‚ē…ē†ēŠēēŽēē’ē–ē—ēœēžēŸē ē¢\"],[\"8fcfa1\",\"ē¤ē§ēŖē¬ē°ē²ē³ē“ēŗē½ēž€ēž„ēžŒēžēž”ēž•ēž–ēžšēžŸēž¢ēž§ēžŖēž®ēžÆēž±ēžµēž¾ēŸƒēŸ‰ēŸ‘ēŸ’ēŸ•ēŸ™ēŸžēŸŸēŸ ēŸ¤ēŸ¦ēŸŖēŸ¬ēŸ°ēŸ±ēŸ“ēŸøēŸ»ē …ē †ē ‰ē ē Žē ‘ē ē ”ē ¢ē £ē ­ē ®ē °ē µē ·ē”ƒē”„ē”‡ē”ˆē”Œē”Žē”’ē”œē”žē” ē””ē”£ē”¤ē”Øē”Ŗē”®ē”ŗē”¾ē¢Šē¢ē¢”ē¢˜ē¢”ē¢ē¢žē¢Ÿē¢¤ē¢Øē¢¬ē¢­ē¢°ē¢±ē¢²ē¢³\"],[\"8fd0a1\",\"ē¢»ē¢½ē¢æē£‡ē£ˆē£‰ē£Œē£Žē£’ē£“ē£•ē£–ē£¤ē£›ē£Ÿē£ ē£”ē£¦ē£Ŗē£²ē£³ē¤€ē£¶ē£·ē£ŗē£»ē£æē¤†ē¤Œē¤ē¤šē¤œē¤žē¤Ÿē¤ ē¤„ē¤§ē¤©ē¤­ē¤±ē¤“ē¤µē¤»ē¤½ē¤æē„„ē„…ē„†ē„Šē„‹ē„ē„‘ē„”ē„˜ē„›ē„œē„§ē„©ē„«ē„²ē„¹ē„»ē„¼ē„¾ē¦‹ē¦Œē¦‘ē¦“ē¦”ē¦•ē¦–ē¦˜ē¦›ē¦œē¦”ē¦Øē¦©ē¦«ē¦Æē¦±ē¦“ē¦øē¦»ē§‚ē§„ē§‡ē§ˆē§Šē§ē§”ē§–ē§šē§ē§ž\"],[\"8fd1a1\",\"ē§ ē§¢ē§„ē§Ŗē§«ē§­ē§±ē§øē§¼ē؂ē؃ē؇ē؉ē؊ē،ēؑēؕē؛ē؞ēØ”ēاēØ«ēØ­ēØÆēØ°ēØ“ēصēØøēعēØŗē©„ē©…ē©‡ē©ˆē©Œē©•ē©–ē©™ē©œē©ē©Ÿē© ē©„ē©§ē©Ŗē©­ē©µē©øē©¾ēŖ€ēŖ‚ēŖ…ēŖ†ēŖŠēŖ‹ēŖēŖ‘ēŖ”ēŖžēŖ ēŖ£ēŖ¬ēŖ³ēŖµēŖ¹ēŖ»ēŖ¼ē«†ē«‰ē«Œē«Žē«‘ē«›ē«Øē«©ē««ē«¬ē«±ē«“ē«»ē«½ē«¾ē¬‡ē¬”ē¬Ÿē¬£ē¬§ē¬©ē¬Ŗē¬«ē¬­ē¬®ē¬Æē¬°\"],[\"8fd2a1\",\"ē¬±ē¬“ē¬½ē¬æē­€ē­ē­‡ē­Žē­•ē­ ē­¤ē­¦ē­©ē­Ŗē­­ē­Æē­²ē­³ē­·ē®„ē®‰ē®Žē®ē®‘ē®–ē®›ē®žē® ē®„ē®¬ē®Æē®°ē®²ē®µē®¶ē®ŗē®»ē®¼ē®½ēƂēƅēƈēƊēƔēƖēƗēƙēƚēƛēÆØēÆŖēƲēÆ“ēƵēÆøēƹēÆŗēƼēƾē°ē°‚ē°ƒē°„ē°†ē°‰ē°‹ē°Œē°Žē°ē°™ē°›ē° ē°„ē°¦ē°Øē°¬ē°±ē°³ē°“ē°¶ē°¹ē°ŗē±†ē±Šē±•ē±‘ē±’ē±“ē±™\",5],[\"8fd3a1\",\"ē±”ē±£ē±§ē±©ē±­ē±®ē±°ē±²ē±¹ē±¼ē±½ē²†ē²‡ē²ē²”ē²žē² ē²¦ē²°ē²¶ē²·ē²ŗē²»ē²¼ē²æē³„ē³‡ē³ˆē³‰ē³ē³ē³“ē³”ē³•ē³—ē³™ē³šē³ē³¦ē³©ē³«ē³µē“ƒē“‡ē“ˆē“‰ē“ē“‘ē“’ē““ē“–ē“ē“žē“£ē“¦ē“Ŗē“­ē“±ē“¼ē“½ē“¾ēµ€ēµēµ‡ēµˆēµēµ‘ēµ“ēµ—ēµ™ēµšēµœēµēµ„ēµ§ēµŖēµ°ēµøēµŗēµ»ēµæē¶ē¶‚ē¶ƒē¶…ē¶†ē¶ˆē¶‹ē¶Œē¶ē¶‘ē¶–ē¶—ē¶\"],[\"8fd4a1\",\"ē¶žē¶¦ē¶§ē¶Ŗē¶³ē¶¶ē¶·ē¶¹ē·‚\",4,\"ē·Œē·ē·Žē·—ē·™ēø€ē·¢ē·„ē·¦ē·Ŗē·«ē·­ē·±ē·µē·¶ē·¹ē·ŗēøˆēøēø‘ēø•ēø—ēøœēøēø ēø§ēøØēø¬ēø­ēøÆēø³ēø¶ēøæē¹„ē¹…ē¹‡ē¹Žē¹ē¹’ē¹˜ē¹Ÿē¹”ē¹¢ē¹„ē¹«ē¹®ē¹Æē¹³ē¹øē¹¾ēŗēŗ†ēŗ‡ēŗŠēŗēŗ‘ēŗ•ēŗ˜ēŗšēŗēŗžē¼¼ē¼»ē¼½ē¼¾ē¼æē½ƒē½„ē½‡ē½ē½’ē½“ē½›ē½œē½ē½”ē½£ē½¤ē½„ē½¦ē½­\"],[\"8fd5a1\",\"ē½±ē½½ē½¾ē½æē¾€ē¾‹ē¾ē¾ē¾ē¾‘ē¾–ē¾—ē¾œē¾”ē¾¢ē¾¦ē¾Ŗē¾­ē¾“ē¾¼ē¾æēæ€ēæƒēæˆēæŽēæēæ›ēæŸēæ£ēæ„ēæØēæ¬ēæ®ēæÆēæ²ēæŗēæ½ēæ¾ēææč€‡č€ˆč€Šč€č€Žč€č€‘č€“č€”č€–č€č€žč€Ÿč€ č€¤č€¦č€¬č€®č€°č€“č€µč€·č€¹č€ŗč€¼č€¾č€č„č č¤č¦č­č±čµč‚č‚ˆč‚Žč‚œč‚žč‚¦č‚§č‚«č‚øč‚¹čƒˆčƒčƒčƒ’čƒ”čƒ•čƒ—čƒ˜čƒ čƒ­čƒ®\"],[\"8fd6a1\",\"čƒ°čƒ²čƒ³čƒ¶čƒ¹čƒŗčƒ¾č„ƒč„‹č„–č„—č„˜č„œč„žč„ č„¤č„§č„¬č„°č„µč„ŗč„¼č……č…‡č…Šč…Œč…’č…—č… č…”č…§č…Øč…©č…­č…Æč…·č†č†č†„č†…č††č†‹č†Žč†–č†˜č†›č†žč†¢č†®č†²č†“č†»č‡‹č‡ƒč‡…č‡Šč‡Žč‡č‡•č‡—č‡›č‡č‡žč‡”č‡¤č‡«č‡¬č‡°č‡±č‡²č‡µč‡¶č‡øč‡¹č‡½č‡æčˆ€čˆƒčˆčˆ“čˆ”čˆ™čˆščˆčˆ”čˆ¢čˆØčˆ²čˆ“čˆŗ艃艄艅艆\"],[\"8fd7a1\",\"č‰‹č‰Žč‰č‰‘č‰–č‰œč‰ č‰£č‰§č‰­č‰“č‰»č‰½č‰æčŠ€čŠčŠƒčŠ„čŠ‡čŠ‰čŠŠčŠŽčŠ‘čŠ”čŠ–čŠ˜čŠščŠ›čŠ čŠ”čŠ£čŠ¤čŠ§čŠØ芩čŠŖčŠ®čŠ°čŠ²čŠ“čŠ·čŠŗčŠ¼čŠ¾čŠæč‹†č‹č‹•č‹šč‹ č‹¢č‹¤č‹Øč‹Ŗ苭č‹Æč‹¶č‹·č‹½č‹¾čŒ€čŒčŒ‡čŒˆčŒŠčŒ‹č”čŒ›čŒčŒžčŒŸčŒ”čŒ¢čŒ¬čŒ­čŒ®čŒ°čŒ³čŒ·čŒŗčŒ¼čŒ½č‚čƒč„č‡ččŽč‘č•č–č—č°čø\"],[\"8fd8a1\",\"č½čæčŽ€čŽ‚čŽ„čŽ†čŽčŽ’čŽ”čŽ•čŽ˜čŽ™čŽ›čŽœčŽčŽ¦čŽ§čŽ©čŽ¬čŽ¾čŽæ菀菇菉菏菐菑菔菝荓čØčŖč¶čøč¹č¼čč†čŠčč‘č•č™čŽ­čÆč¹č‘…č‘‡č‘ˆč‘Šč‘č‘č‘‘č‘’č‘–č‘˜č‘™č‘šč‘œč‘ č‘¤č‘„č‘§č‘Ŗč‘°č‘³č‘“č‘¶č‘øč‘¼č‘½č’č’…č’’č’“č’•č’žč’¦č’Øč’©č’Ŗč’Æ蒱蒓č’ŗč’½č’¾č“€č“‚č“‡č“ˆč“Œč“č““\"],[\"8fd9a1\",\"蓜蓧č“Ŗč“Æč“°č“±č“²č“·č”²č“ŗč“»č“½č”‚č”ƒč”‡č”Œč”Žč”č”œč”žč”¢č”£č”¤č”„č”§č”Ŗ蔫č”Æč”³č”“č”¶č”æ蕆蕏\",4,\"蕖蕙蕜\",6,\"蕤蕫č•Æč•¹č•ŗč•»č•½č•æč–č–…č–†č–‰č–‹č–Œč–č–“č–˜č–č–Ÿč– č–¢č–„č–§č–“č–¶č–·č–øč–¼č–½č–¾č–æč—‚č—‡č—Šč—‹č—Žč–­č—˜č—šč—Ÿč— č—¦č—Øč—­č—³č—¶č—¼\"],[\"8fdaa1\",\"č—æč˜€č˜„č˜…č˜č˜Žč˜č˜‘č˜’č˜˜č˜™č˜›č˜žč˜”č˜§č˜©č˜¶č˜øč˜ŗč˜¼č˜½č™€č™‚č™†č™’č™“č™–č™—č™˜č™™č™č™ \",4,\"虩虬č™Æ虵虶虷č™ŗčščš‘čš–čš˜čšščšœčš”čš¦čš§čšØčš­čš±čš³čš“čšµčš·čšøčš¹čšæč›€č›č›ƒč›…č›‘č›’č›•č›—č›šč›œč› č›£č›„č›§čšˆč›ŗč›¼č›½čœ„čœ…čœ‡čœ‹čœŽčœčœčœ“čœ”čœ™čœžčœŸčœ”čœ£\"],[\"8fdba1\",\"čœØčœ®čœÆčœ±čœ²čœ¹čœŗčœ¼čœ½čœ¾č€čƒč…čč˜čč”č¤č„čÆč±č²č»čžƒ\",6,\"čž‹čžŒčžčž“čž•čž—čž˜čž™čžžčž čž£čž§čž¬čž­čž®čž±čžµčž¾čžæčŸčŸˆčŸ‰čŸŠčŸŽčŸ•čŸ–čŸ™čŸščŸœčŸŸčŸ¢čŸ£čŸ¤čŸŖčŸ«čŸ­čŸ±čŸ³čŸøčŸŗčŸæ蠁蠃蠆蠉蠊蠋蠐蠙蠒蠓蠔蠘蠚蠛蠜蠞蠟č Øč ­č ®č °č ²č µ\"],[\"8fdca1\",\"č ŗč ¼č”č”ƒč”…č”ˆč”‰č”Šč”‹č”Žč”‘č”•č”–č”˜č”šč”œč”Ÿč” č”¤č”©č”±č”¹č”»č¢€č¢˜č¢šč¢›č¢œč¢Ÿč¢ č¢Øč¢Ŗč¢ŗč¢½č¢¾č£€č£Š\",4,\"č£‘č£’č£“č£›č£žč£§č£Æč£°č£±č£µč£·č¤č¤†č¤č¤Žč¤č¤•č¤–č¤˜č¤™č¤šč¤œč¤ č¤¦č¤§č¤Øč¤°č¤±č¤²č¤µč¤¹č¤ŗč¤¾č„€č„‚č„…č„†č„‰č„č„’č„—č„šč„›č„œč„”č„¢č„£č„«č„®č„°č„³č„µč„ŗ\"],[\"8fdda1\",\"č„»č„¼č„½č¦‰č¦č¦č¦”č¦•č¦›č¦œč¦Ÿč¦ č¦„č¦°č¦“č¦µč¦¶č¦·č¦¼č§”\",4,\"č§„č§©č§«č§­č§±č§³č§¶č§¹č§½č§æč؄č؅č؇č؏čؑčؒčؔčؕč؞čØ čØ¢čؤčئčØ«čجčØÆčصčØ·čؽčØ¾č©€č©ƒč©…č©‡č©‰č©č©Žč©“č©–č©—č©˜č©œč©č©”č©„č©§č©µč©¶č©·č©¹č©ŗč©»č©¾č©æčŖ€čŖƒčŖ†čŖ‹čŖčŖčŖ’čŖ–čŖ—čŖ™čŖŸčŖ§čŖ©čŖ®čŖÆčŖ³\"],[\"8fdea1\",\"čŖ¶čŖ·čŖ»čŖ¾č«ƒč«†č«ˆč«‰č«Šč«‘č«“č«”č«•č«—č«č«Ÿč«¬č«°č«“č«µč«¶č«¼č«æč¬…č¬†č¬‹č¬‘č¬œč¬žč¬Ÿč¬Šč¬­č¬°č¬·č¬¼č­‚\",4,\"č­ˆč­’č­“č­”č­™č­č­žč­£č­­č­¶č­øč­¹č­¼č­¾č®č®„č®…č®‹č®č®č®”č®•č®œč®žč®Ÿč°øč°¹č°½č°¾č±…č±‡č±‰č±‹č±č±‘č±“č±”č±—č±˜č±›č±č±™č±£č±¤č±¦č±Øč±©č±­č±³č±µč±¶č±»č±¾č²†\"],[\"8fdfa1\",\"č²‡č²‹č²č²’č²“č²™č²›č²œč²¤č²¹č²ŗč³…č³†č³‰č³‹č³č³–č³•č³™č³č³”č³Øč³¬č³Æč³°č³²č³µč³·č³øč³¾č³æč“č“ƒč“‰č“’č“—č“›čµ„čµ©čµ¬čµ®čµæč¶‚č¶„č¶ˆč¶č¶č¶‘č¶•č¶žč¶Ÿč¶ č¶¦č¶«č¶¬č¶Æč¶²č¶µč¶·č¶¹č¶»č·€č·…č·†č·‡č·ˆč·Šč·Žč·‘č·”č·•č·—č·™č·¤č·„č·§č·¬č·°č¶¼č·±č·²č·“č·½čøčø„čø…čø†čø‹čø‘čø”čø–čø čø”čø¢\"],[\"8fe0a1\",\"čø£čø¦čø§čø±čø³čø¶čø·čøøčø¹čø½č¹€č¹č¹‹č¹č¹Žč¹č¹”č¹›č¹œč¹č¹žč¹”č¹¢č¹©č¹¬č¹­č¹Æč¹°č¹±č¹¹č¹ŗč¹»čŗ‚čŗƒčŗ‰čŗčŗ’čŗ•čŗščŗ›čŗčŗžčŗ¢čŗ§čŗ©čŗ­čŗ®čŗ³čŗµčŗŗčŗ»č»€č»č»ƒč»„č»‡č»č»‘č»”č»œč»Øč»®č»°č»±č»·č»¹č»ŗč»­č¼€č¼‚č¼‡č¼ˆč¼č¼č¼–č¼—č¼˜č¼žč¼ č¼”č¼£č¼„č¼§č¼Øč¼¬č¼­č¼®č¼“č¼µč¼¶č¼·č¼ŗč½€č½\"],[\"8fe1a1\",\"č½ƒč½‡č½č½‘\",4,\"č½˜č½č½žč½„č¾č¾ č¾”č¾¤č¾„č¾¦č¾µč¾¶č¾øč¾¾čæ€čæčæ†čæŠčæ‹čæčæčæ’čæ“čæ•čæ čæ£čæ¤čæØčæ®čæ±čæµčæ¶čæ»čæ¾é€‚逄逈逌逘逛é€Ø逩é€Æé€Ŗ逬逭逳逓逷é€æ遃遄遌遛遝遢遦遧遬遰道遹邅邈邋邌邎邐邕邗邘邙邛邠邔邢還邰邲邳邓邶邽郌邾郃\"],[\"8fe2a1\",\"郄郅郇郈郕郗郘郙郜郝郟郄郒郶郫éƒÆ郰郓郾éƒæ鄀鄄鄅鄆鄈鄍鄐鄔鄖鄗鄘鄚鄜鄞鄠鄄鄢鄣鄧鄩鄮é„Æ鄱鄓鄶鄷鄹é„ŗ鄼鄽酃酇酈酏酓酗酙酚酛酔酤酧酭酓酹é…ŗ酻醁醃醅醆醊醎醑醓醔醕醘醞醔醦é†Ø醬醭醮醰醱醲醳醶醻醼醽é†æ\"],[\"8fe3a1\",\"釂釃釅釓釔釗釙釚釞釤釄釩é‡Ŗ釬\",5,\"釷釹釻釽鈀鈁鈄鈅鈆鈇鈉鈊鈌鈐鈒鈓鈖鈘鈜鈝鈣鈤鈄鈦éˆØ鈮éˆÆ鈰鈳鈵鈶éˆø鈹éˆŗ鈼鈾鉀鉂鉃鉆鉇鉊鉍鉎鉏鉑鉘鉙鉜鉝鉠鉔鉄鉧é‰Ø鉩鉮é‰Æ鉰鉵\",4,\"鉻鉼鉽é‰æ銈銉銊銍銎銒銗\"],[\"8fe4a1\",\"銙銟銠銤銄銧éŠØ銫éŠÆ銲銶éŠøéŠŗ銻銼銽éŠæ\",4,\"鋅鋆鋇鋈鋋鋌鋍鋎鋐鋓鋕鋗鋘鋙鋜鋝鋟鋠鋔鋣鋄鋧é‹Ø鋬鋮鋰鋹鋻é‹æ錀錂錈錍錑錔錕錜錝錞錟錔錤錄錧錩éŒŖ錳錓錶錷鍇鍈鍉鍐鍑鍒鍕鍗鍘鍚鍞鍤鍄鍧鍩éŖ鍭éÆ鍰鍱鍳鍓鍶\"],[\"8fe5a1\",\"éŗ鍽éæ鎀鎁鎂鎈鎊鎋鎍鎏鎒鎕鎘鎛鎞鎔鎣鎤鎦éŽØ鎫鎓鎵鎶éŽŗ鎩鏁鏄鏅鏆鏇鏉\",4,\"鏓鏙鏜鏞鏟鏢鏦鏧鏹鏷éøéŗ鏻鏽鐁鐂鐄鐈鐉鐍鐎鐏鐕鐖鐗鐟鐮éÆ鐱鐲鐳鐓鐻éæ鐽鑃鑅鑈鑊鑌鑕鑙鑜鑟鑔鑣é‘Ø鑫鑭鑮é‘Æ鑱鑲钄钃é•ø镹\"],[\"8fe6a1\",\"镾閄閈閌閍閎閝閞閟閔閦閩閫閬間閶é–ŗ閽é–æ闆闈闉闋闐闑闒闓闙闚闝闞闟闠闤闦阝阞阢阤阄阦阬阱阳阷é˜ø阹é˜ŗ阼阽陁陒陔陖陗陘陔陮陓陻陼陾é™æ隁隂隃隄隉隑隖隚隝隟隤隄隦隩隮éšÆ隳éšŗ雊雒嶲雘雚雝雞雟雩é›Æ雱é›ŗ霂\"],[\"8fe7a1\",\"霃霅霉霚霛霝霔霢霣éœØ霱霳靁靃靊靎靏靕靗靘靚靛靣靧éŖ靮靳靶靷éø靻靽éæ鞀鞉鞕鞖鞗鞙鞚鞞鞟鞢鞬鞮鞱鞲鞵鞶éžø鞹éžŗ鞼鞾éžæ韁韄韅韇韉韊韌韍韎韐韑韔韗韘韙韝韞韠韛韔韤éŸÆ韱韓韷éŸøéŸŗ頇頊頙頍頎頔頖頜頞頠頣頦\"],[\"8fe8a1\",\"é «é ®é Æ頰頲頳頵頄頾锄锇锊锑锒锓锖锗错锚锢锣锄锦é”Ŗ锬颫颭颮颰颓颷é¢øé¢ŗ颻é¢æ飂飅飈飌飔飣飄飦飧é£Ŗ飳飶餂餇餈餑餕餖餗餚餛餜餟餢餦餧餫餱\",4,\"餹é¤ŗ餻餼鄀鄁鄆鄇鄈鄍鄎鄔鄘鄙鄛鄜鄞鄟鄠馛馝馟馦馰馱馲馵\"],[\"8fe9a1\",\"馹é¦ŗ馽é¦æ駃駉駓駔駙駚駜駞駧é§Ŗ駫駬駰駓駵駹駽駾é؂é؃é؄é؋é،éؐéؑéؖé؞éØ éØ¢éØ£éؤéاéØ­éØ®éسéصéضéØø驇驁驄驊驋驌驎驑驔驖驝éŖŖéŖ¬éŖ®éŖÆéŖ²éŖ“éŖµéŖ¶éŖ¹éŖ»éŖ¾éŖæ髁髃髆髈髎髐髒髕髖髗髛髜髠髤髄髧髩髬髲髳髵髹é«ŗ髽é«æ\",4],[\"8feaa1\",\"鬄鬅鬈鬉鬋鬌鬍鬎鬐鬒鬖鬙鬛鬜鬠鬦鬫鬭鬳鬓鬵鬷鬹é¬ŗ鬽魈魋魌魕魖魗魛魞魔魣魄魦é­Øé­Ŗ\",4,\"魳魵魷é­øé­¹é­æ鮀鮄鮅鮆鮇鮉鮊鮋鮍鮏鮐鮔鮚鮝鮞鮦鮧鮩鮬鮰鮱鮲鮷é®ø鮻鮼鮾é®æéƁéƇéƈéƎéƐéƗéƘéƝéƟéÆ„éƧéÆŖéÆ«éÆÆéƳéÆ·éÆø\"],[\"8feba1\",\"éƹéÆŗéƽéÆæ鰀鰂鰋鰏鰑鰖鰘鰙鰚鰜鰞鰢鰣鰦\",4,\"鰱鰵鰶鰷鰽鱁鱃鱄鱅鱉鱊鱎鱏鱐鱓鱔鱖鱘鱛鱝鱞鱟鱣鱩é±Ŗ鱜鱫é±Ø鱮鱰鱲鱵鱷鱻鳦鳲鳷鳹铋铂铑铗铘铜铝铞é“Æ铰铲铳铓é“ŗ铼鵅铽鵂鵃鵇鵊鵓鵔鵟鵣鵢鵄鵩éµŖ鵫鵰鵶鵷鵻\"],[\"8feca1\",\"鵼鵾鶃鶄鶆鶊鶍鶎鶒鶓鶕鶖鶗鶘鶔é¶Ŗ鶬鶮鶱鶵鶹鶼é¶æ鷃鷇鷉鷊鷔鷕鷖鷗鷚鷞鷟鷠鷄鷧鷩鷫鷮鷰鷳鷓鷾éøŠéø‚éø‡éøŽéøéø‘éø’éø•éø–éø™éøœéøé¹ŗ鹻鹼éŗ€éŗ‚éŗƒéŗ„éŗ…éŗ‡éŗŽéŗéŗ–éŗ˜éŗ›éŗžéŗ¤éŗØéŗ¬éŗ®éŗÆéŗ°éŗ³éŗ“éŗµé»†é»ˆé»‹é»•é»Ÿé»¤é»§é»¬é»­é»®é»°é»±é»²é»µ\"],[\"8feda1\",\"é»øé»æ鼂鼃鼉鼏鼐鼑鼒鼔鼖鼗鼙鼚鼛鼟鼢鼦é¼Ŗ鼫é¼Æ鼱鼲鼓鼷鼹é¼ŗ鼼鼽é¼æ齁齃\",4,\"齓齕齖齗齘齚齝齞é½Ø齩齭\",4,\"齳齵é½ŗ齽龏龐龑龒龔龖龗龞龔龢龣龄\"]]"); + +/***/ }), + +/***/ 2297: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("{\"uChars\":[128,165,169,178,184,216,226,235,238,244,248,251,253,258,276,284,300,325,329,334,364,463,465,467,469,471,473,475,477,506,594,610,712,716,730,930,938,962,970,1026,1104,1106,8209,8215,8218,8222,8231,8241,8244,8246,8252,8365,8452,8454,8458,8471,8482,8556,8570,8596,8602,8713,8720,8722,8726,8731,8737,8740,8742,8748,8751,8760,8766,8777,8781,8787,8802,8808,8816,8854,8858,8870,8896,8979,9322,9372,9548,9588,9616,9622,9634,9652,9662,9672,9676,9680,9702,9735,9738,9793,9795,11906,11909,11913,11917,11928,11944,11947,11951,11956,11960,11964,11979,12284,12292,12312,12319,12330,12351,12436,12447,12535,12543,12586,12842,12850,12964,13200,13215,13218,13253,13263,13267,13270,13384,13428,13727,13839,13851,14617,14703,14801,14816,14964,15183,15471,15585,16471,16736,17208,17325,17330,17374,17623,17997,18018,18212,18218,18301,18318,18760,18811,18814,18820,18823,18844,18848,18872,19576,19620,19738,19887,40870,59244,59336,59367,59413,59417,59423,59431,59437,59443,59452,59460,59478,59493,63789,63866,63894,63976,63986,64016,64018,64021,64025,64034,64037,64042,65074,65093,65107,65112,65127,65132,65375,65510,65536],\"gbChars\":[0,36,38,45,50,81,89,95,96,100,103,104,105,109,126,133,148,172,175,179,208,306,307,308,309,310,311,312,313,341,428,443,544,545,558,741,742,749,750,805,819,820,7922,7924,7925,7927,7934,7943,7944,7945,7950,8062,8148,8149,8152,8164,8174,8236,8240,8262,8264,8374,8380,8381,8384,8388,8390,8392,8393,8394,8396,8401,8406,8416,8419,8424,8437,8439,8445,8482,8485,8496,8521,8603,8936,8946,9046,9050,9063,9066,9076,9092,9100,9108,9111,9113,9131,9162,9164,9218,9219,11329,11331,11334,11336,11346,11361,11363,11366,11370,11372,11375,11389,11682,11686,11687,11692,11694,11714,11716,11723,11725,11730,11736,11982,11989,12102,12336,12348,12350,12384,12393,12395,12397,12510,12553,12851,12962,12973,13738,13823,13919,13933,14080,14298,14585,14698,15583,15847,16318,16434,16438,16481,16729,17102,17122,17315,17320,17402,17418,17859,17909,17911,17915,17916,17936,17939,17961,18664,18703,18814,18962,19043,33469,33470,33471,33484,33485,33490,33497,33501,33505,33513,33520,33536,33550,37845,37921,37948,38029,38038,38064,38065,38066,38069,38075,38076,38078,39108,39109,39113,39114,39115,39116,39265,39394,189000]}"); + +/***/ }), + +/***/ 4152: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"a140\",\"ī“†\",62],[\"a180\",\"ī”…\",32],[\"a240\",\"ī”¦\",62],[\"a280\",\"ī•„\",32],[\"a2ab\",\"ī¦\",5],[\"a2e3\",\"ā‚¬ī­\"],[\"a2ef\",\"ī®īÆ\"],[\"a2fd\",\"ī°ī±\"],[\"a340\",\"ī–†\",62],[\"a380\",\"ī—…\",31,\"怀\"],[\"a440\",\"ī—¦\",62],[\"a480\",\"ī˜„\",32],[\"a4f4\",\"ī²\",10],[\"a540\",\"ī™†\",62],[\"a580\",\"īš…\",32],[\"a5f7\",\"ī½\",7],[\"a640\",\"īš¦\",62],[\"a680\",\"ī›„\",32],[\"a6b9\",\"īž…\",7],[\"a6d9\",\"īž\",6],[\"a6ec\",\"īž”īž•\"],[\"a6f3\",\"īž–\"],[\"a6f6\",\"īž—\",8],[\"a740\",\"īœ†\",62],[\"a780\",\"ī…\",32],[\"a7c2\",\"īž \",14],[\"a7f2\",\"īžÆ\",12],[\"a896\",\"īž¼\",10],[\"a8bc\",\"įøæ\"],[\"a8bf\",\"Ē¹\"],[\"a8c1\",\"īŸ‰īŸŠīŸ‹īŸŒ\"],[\"a8ea\",\"īŸ\",20],[\"a958\",\"īŸ¢\"],[\"a95b\",\"īŸ£\"],[\"a95d\",\"īŸ¤īŸ„īŸ¦\"],[\"a989\",\"ć€¾āæ°\",11],[\"a997\",\"īŸ“\",12],[\"a9f0\",\"ī \",14],[\"aaa1\",\"ī€€\",93],[\"aba1\",\"īž\",93],[\"aca1\",\"ī‚¼\",93],[\"ada1\",\"ī„š\",93],[\"aea1\",\"ī…ø\",93],[\"afa1\",\"ī‡–\",93],[\"d7fa\",\"ī \",4],[\"f8a1\",\"īˆ“\",93],[\"f9a1\",\"īŠ’\",93],[\"faa1\",\"ī‹°\",93],[\"fba1\",\"īŽ\",93],[\"fca1\",\"īŽ¬\",93],[\"fda1\",\"īŠ\",93],[\"fe50\",\"āŗī –ī —ī ˜āŗ„ć‘³ć‘‡āŗˆāŗ‹ī žć–žć˜šć˜ŽāŗŒāŗ—ć„®ć¤˜ī ¦ć§ć§Ÿć©³ć§ī «ī ¬ć­Žć±®ć³ āŗ§ī ±ī ²āŗŖ䁖䅟āŗ®äŒ·āŗ³āŗ¶āŗ·ī »äŽ±äŽ¬āŗ»ää“–ä™”䙌ī”ƒ\"],[\"fe80\",\"䜣䜩䝼䞍ā»Šä„‡ä„ŗ䄽䦂䦃䦅䦆䦟䦛䦷䦶ī””ī”•ä²£ä²Ÿä² ä²”䱷䲢䓓\",6,\"䶮ī”¤ī‘Ø\",93],[\"8135f437\",\"īŸ‡\"]]"); + +/***/ }), + +/***/ 7566: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse("[[\"0\",\"\\u0000\",128],[\"a1\",\"ļ½”\",62],[\"8140\",\"怀态怂ļ¼Œļ¼Žćƒ»ļ¼šļ¼›ļ¼Ÿļ¼ć‚›ć‚œĀ“ļ½€ĀØļ¼¾ļæ£ļ¼æćƒ½ćƒ¾ć‚ć‚žć€ƒä»ć€…ć€†ć€‡ćƒ¼ā€•ā€ļ¼ļ¼¼ļ½žāˆ„ļ½œā€¦ā€„ā€˜ā€™ā€œā€ļ¼ˆļ¼‰ć€”怕ļ¼»ļ¼½ļ½›ļ½ć€ˆ\",9,\"ļ¼‹ļ¼Ā±Ć—\"],[\"8180\",\"Ć·ļ¼ā‰ ļ¼œļ¼žā‰¦ā‰§āˆžāˆ“ā™‚ā™€Ā°ā€²ā€³ā„ƒļæ„ļ¼„ļæ ļæ”ļ¼…ļ¼ƒļ¼†ļ¼Šļ¼ Ā§ā˜†ā˜…ā—‹ā—ā—Žā—‡ā—†ā–”ā– ā–³ā–²ā–½ā–¼ā€»ć€’ā†’ā†ā†‘ā†“怓\"],[\"81b8\",\"āˆˆāˆ‹āŠ†āŠ‡āŠ‚āŠƒāˆŖāˆ©\"],[\"81c8\",\"āˆ§āˆØļæ¢ā‡’ā‡”āˆ€āˆƒ\"],[\"81da\",\"āˆ āŠ„āŒ’āˆ‚āˆ‡ā‰”ā‰’ā‰Ŗā‰«āˆšāˆ½āˆāˆµāˆ«āˆ¬\"],[\"81f0\",\"ā„«ā€°ā™Æā™­ā™Ŗā€ ā€”Ā¶\"],[\"81fc\",\"ā—Æ\"],[\"824f\",\"ļ¼\",9],[\"8260\",\"ļ¼”\",25],[\"8281\",\"ļ½\",25],[\"829f\",\"恁\",82],[\"8340\",\"ć‚”\",62],[\"8380\",\"惠\",22],[\"839f\",\"Ī‘\",16,\"Ī£\",6],[\"83bf\",\"Ī±\",16,\"Ļƒ\",6],[\"8440\",\"Š\",5,\"ŠŠ–\",25],[\"8470\",\"Š°\",5,\"ёŠ¶\",7],[\"8480\",\"Š¾\",17],[\"849f\",\"ā”€ā”‚ā”Œā”ā”˜ā””ā”œā”¬ā”¤ā”“ā”¼ā”ā”ƒā”ā”“ā”›ā”—ā”£ā”³ā”«ā”»ā•‹ā” ā”Æā”Øā”·ā”æā”ā”°ā”„ā”øā•‚\"],[\"8740\",\"ā‘ \",19,\"ā… \",9],[\"875f\",\"ć‰ćŒ”ćŒ¢ććŒ˜ćŒ§ćŒƒćŒ¶ć‘ć—ćŒćŒ¦ćŒ£ćŒ«ćŠćŒ»ćŽœćŽćŽžćŽŽćŽć„ćŽ”\"],[\"877e\",\"ć»\"],[\"8780\",\"思怟ā„–揍ā„”护\",4,\"ćˆ±ćˆ²ćˆ¹ć¾ć½ć¼ā‰’ā‰”āˆ«āˆ®āˆ‘āˆšāŠ„āˆ āˆŸāŠæāˆµāˆ©āˆŖ\"],[\"889f\",\"äŗœå”–å؃é˜æå“€ę„›ęŒØå§¶é€¢č‘µčŒœē©ę‚Ŗę”ęø„ꗭ葦芦éÆµę¢“åœ§ę–”ę‰±å®›å§č™»é£“ēµ¢ē¶¾é®Žęˆ–ē²Ÿč¢·å®‰åŗµęŒ‰ęš—ę”ˆé—‡éžęä»„伊位依偉囲夷委åØå°‰ęƒŸę„ę…°ę˜“ę¤…ē‚ŗē•ē•°ē§»ē¶­ē·ÆčƒƒčŽč”£č¬‚é•éŗ医äŗ•äŗ„åŸŸč‚²éƒē£Æäø€å£±ęŗ¢é€øēزčŒØ芋é°Æå…å°å’½å“”å› å§»å¼•é£²ę·«čƒ¤č”­\"],[\"8940\",\"院陰隠韻吋右宇ēƒē¾½čæ‚é›ØåÆ鵜ēŖŗäø‘ē¢“č‡¼ęø¦å˜˜å”„ę¬č”šé°»å§„åŽ©ęµ¦ē“œé–å™‚äŗ‘é‹é›²čé¤Œå”å–¶å¬°å½±ę˜ ę›³ę „ę°øę³³ę“©ē‘›ē›ˆē©Žé “č‹±č”›č© é‹­ę¶²ē–«ē›Šé§…ę‚¦č¬č¶Šé–²ę¦ŽåŽ­å††\"],[\"8980\",\"園堰億宓延ę€ØęŽ©ę“ę²æę¼”ē‚Žē„”ē…™ē‡•ēŒæēøč‰¶č‹‘č–—é é‰›é“›å”©ę–¼ę±šē”„凹央億往åæœęŠ¼ę—ŗęØŖ꬧ꮓēŽ‹ēæč„–é“¬é“Žé»„å²”ę²–č»å„„å±‹ę†¶č‡†ę”¶ē‰”乙äæŗåøꁩęø©ē©éŸ³äø‹åŒ–仮何伽侔佳加åÆ嘉夏嫁家åÆ”ē§‘ęš‡ęžœęž¶ę­Œę²³ē«ē‚ē¦ē¦¾ēؼē®‡čŠ±č‹›čŒ„č·čÆč“č¦čŖ²å˜©č²Øčæ¦éŽéœžčšŠäæ„å³Øꈑē‰™ē”»č‡„čŠ½č›¾č³€é›…é¤“é§•ä»‹ä¼šč§£å›žå”Šå£Šå»»åæ«ę€Ŗę‚”ę¢ę‡ęˆ’ę‹ę”¹\"],[\"8a40\",\"é­ę™¦ę¢°ęµ·ē°ē•Œēš†ēµµčŠ„čŸ¹é–‹éšŽč²å‡±åŠ¾å¤–å’³å®³å“–ę…Øꦂę¶Æē¢č“‹č”—č©²éŽ§éŖø구é¦Øč›™åž£ęŸæč›ŽéˆŽåŠƒåš‡å„å»“ę‹”ę’¹ę ¼ę øę®»ē²ē¢ŗē©«č¦šč§’čµ«č¼ƒéƒ­é–£éš”é©å­¦å²³ę„½é”é”ŽęŽ›ē¬ ęØ«\"],[\"8a80\",\"ę©æę¢¶é°ę½Ÿå‰²å–ę°ę‹¬ę“»ęø‡ę»‘č‘›č¤č½„äø”é°¹å¶ę¤›ęØŗ鞄ę Ŗ兜ē«ƒč’²é‡œéŽŒå™›é“Øę ¢čŒ…č±ē²„åˆˆč‹…ē“¦ä¹¾ä¾ƒå† åƒ刊勘勧巻喚å Ŗ姦完官åÆ›å¹²å¹¹ę‚£ę„Ÿę…£ę†¾ę›ę•¢ęŸ‘ę”“ę£ŗę¬¾ę­“ę±—ę¼¢ę¾—ę½…ē’°ē”˜ē›£ēœ‹ē«æē®”ē°”ē·©ē¼¶ēæ°č‚č‰¦čŽžč¦³č«Œč²«é‚„鑑間閑関附韓é¤Ø舘äøø含å²ø巌ēŽ©ē™Œēœ¼å²©ēæ«č“‹é›é ‘锔锘企伎危喜å™ØåŸŗ儇嬉åƄ岐åøŒå¹¾åæŒę®ęœŗę——ę—¢ęœŸę£‹ę£„\"],[\"8b40\",\"ę©Ÿåø°ęÆ…ę°—ę±½ē•æē„ˆå­£ē؀ē“€å¾½č¦čØ˜č²“čµ·č»Œč¼é£¢é؎鬼äŗ€å½å„€å¦“宜ęˆÆꊀꓬę¬ŗēŠ ē–‘ē„‡ē¾©čŸ»čŖ¼č­°ęŽ¬čŠéž å‰åƒå–«ę””ę©˜č©°ē §ęµé»å“å®¢č„šč™é€†äø˜ä¹…仇休及åøå®®å¼“ę€„ę•‘\"],[\"8b80\",\"ęœ½ę±‚ę±²ę³£ēøēƒē©¶ēŖ®ē¬ˆē“šē³¾ēµ¦ę—§ē‰›åŽ»å±…å·Øꋒꋠꌙęø č™ščØ±č·é‹øę¼ē¦¦é­šäŗØäŗ«äŗ¬ä¾›ä¾ åƒ‘å…‡ē«¶å…±å‡¶å”匔åæ叫喬境峔強彊ę€Æęę­ęŒŸę•™ę©‹ę³ē‹‚ē‹­ēŸÆčƒøč„…čˆˆč•Žéƒ·é”éŸæé„—é©šä»°å‡å°­ęšę„­å±€ę›²ę„µēŽ‰ę”ē²åƒ…å‹¤å‡å·¾éŒ¦ę–¤ę¬£ę¬½ē“ē¦ē¦½ē­‹ē·ŠčŠ¹čŒč”æč„Ÿč¬¹čæ‘金吟銀九倶叄åŒŗē‹—ēŽ–ēŸ©č‹¦čŗÆé§†é§ˆé§’å…·ę„šč™žå–°ē©ŗ偶åƓ遇隅äø²ę«›é‡§å±‘屈\"],[\"8c40\",\"ꎘēŖŸę²“é“č½”ēŖŖē†Šéšˆē²‚ę —ē¹°ę”‘é¬å‹²å›č–«čؓē¾¤č»éƒ”å¦č¢ˆē„äæ‚傾刑兄啓圭ēŖåž‹å„‘å½¢å¾„ęµę…¶ę…§ę†©ęŽ²ęŗꕬę™Æꔂęø“ē•¦ēؽē³»ēµŒē¶™ē¹‹ē½«čŒŽčŠč›čØˆč©£č­¦č»½é šé¶čŠøčæŽéÆØ\"],[\"8c80\",\"åŠ‡ęˆŸę’ƒęæ€éš™ę”å‚‘ꬠę±ŗę½”ē©“ēµč”€čØ£ęœˆä»¶å€¹å€¦å„å…¼åˆø剣喧圏堅嫌å»ŗę†²ę‡øę‹³ę²ę¤œęØ©ē‰½ēŠ¬ēŒ®ē ”ē”Æēµ¹ēœŒč‚©č¦‹č¬™č³¢č»’遣鍵é™ŗ锕éؓé¹ø元原厳幻弦ęø›ęŗēŽ„ē¾ēµƒčˆ·č؀č«ŗ限乎個古呼å›ŗ姑孤己åŗ«å¼§ęˆøꕅęžÆę¹–ē‹ē³Šč¢“č‚”čƒ”č°č™ŽčŖ‡č·Ø鈷雇锧鼓äŗ”äŗ’伍午呉吾åØÆå¾Œå¾”ę‚Ÿę¢§ęŖŽē‘šē¢čŖžčŖ¤č­·é†ä¹žéƉäŗ¤ä½¼ä¾Æ候倖光公功効勾厚口向\"],[\"8d40\",\"后喉坑垢儽孔孝宏巄巧巷å¹øåŗƒåŗšåŗ·å¼˜ę’ę…ŒęŠ—ę‹˜ęŽ§ę”»ę˜‚ę™ƒę›“ę­ę ”ę¢—ę§‹ę±Ÿę“Ŗ굩ęøÆęŗē”²ēš‡ē”¬ēØæē³ ē“…ē“˜ēµžē¶±č€•č€ƒč‚Æč‚±č…”č†čˆŖč’č”Œč””č¬›č²¢č³¼éƒŠé…µé‰±ē æ鋼閤降\"],[\"8d80\",\"é …é¦™é«˜é“»å‰›åŠ«å·åˆå£•ę‹·ęæ č±Ŗč½Ÿéŗ¹å…‹åˆ»å‘Šå›½ē©€é…·éµ é»’ē„ę¼‰č…°ē”‘åæ½ęƒšéŖØē‹›č¾¼ę­¤é ƒä»Šå›°å¤å¢¾å©šęØę‡‡ę˜ę˜†ę ¹ę¢±ę··ē—•ē“ŗ艮魂äŗ›ä½å‰å”†åµÆå·¦å·®ęŸ»ę²™ē‘³ē ‚č©éŽ–č£Ÿååŗ§ęŒ«å‚µå‚¬å†ęœ€å“‰å”žå¦»å®°å½©ę‰ęŽ”ę ½ę­³ęøˆē½é‡‡ēŠ€ē •ē ¦ē„­ę–Žē“°čœč£č¼‰éš›å‰¤åœØꝐē½Ŗč²”å†“å‚é˜Ŗå ŗę¦Šč‚“å’²å“ŽåŸ¼ē¢•é·ŗä½œå‰Šå’‹ę¾ę˜Øęœ”ęŸµēŖ„ē­–ē“¢éŒÆę”œé®­ē¬¹åŒ™å†Šåˆ·\"],[\"8e40\",\"åÆŸę‹¶ę’®ę“¦ęœ­ę®ŗ薩雑ēšéÆ–ęŒéŒ†é®«ēšæꙒäø‰å‚˜å‚å±±ęƒØę’’ę•£ę”Ÿē‡¦ēŠē”£ē®—ēŗ‚čš•č®ƒč³›é…ø餐ꖬꚫꮋ仕仔ä¼ŗä½æåˆŗåø史嗣四士始姉å§æ子屍åø‚åø«åæ—ę€ęŒ‡ę”Æ孜ę–Æę–½ę—Øęžę­¢\"],[\"8e80\",\"ę­»ę°ē…ē„‰ē§ē³øē“™ē“«č‚¢č„‚č‡³č¦–č©žč©©č©¦čŖŒč«®č³‡č³œé›Œé£¼ę­Æäŗ‹ä¼¼ä¾å…å­—åÆŗę…ˆęŒę™‚ę¬”ę»‹ę²»ēˆ¾ē’½ē—”ē£ē¤ŗč€Œč€³č‡Ŗč’”č¾žę±é¹æå¼č­˜é“«ē«ŗč»ø宍雫äøƒå±åŸ·å¤±å«‰å®¤ę‚‰ę¹æę¼†ē–¾č³Ŗå®Ÿč”€ēÆ å²ęŸ“čŠå±”č•ŠēøžčˆŽå†™å°„ęØčµ¦ę–œē…®ē¤¾ē“—č€…č¬č»Šé®č›‡é‚Ŗ借å‹ŗå°ŗꝓē¼ēˆµé…Œé‡ˆéŒ«č‹„åÆ‚å¼±ęƒ¹äø»å–å®ˆę‰‹ęœ±ę®Šē‹©ē ēØ®č…«č¶£é…’é¦–å„’å—å‘ŖåÆæꎈęعē¶¬éœ€å›šåŽå‘Ø\"],[\"8f40\",\"宗就州äæ®ę„ę‹¾ę“²ē§€ē§‹ēµ‚ē¹ēæ’č‡­čˆŸč’č”†č„²č®č¹“č¼Æé€±é…‹é…¬é›†é†œä»€ä½å……åå¾“ęˆŽęŸ”ę±ęø‹ē£ēø¦é‡éŠƒå”夙å®æę·‘ē„ēø®ē²›å”¾ē†Ÿå‡ŗ蔓čæ°äæŠå³»ę˜„ēž¬ē«£čˆœé§æ准å¾Ŗę—¬ę„Æę®‰ę·³\"],[\"8f80\",\"ęŗ–ę½¤ē›¾ē“”å·”éµé†‡é †å‡¦åˆę‰€ęš‘ę›™ęøšåŗ¶ē·’ē½²ę›øč–Æč—·č«ø助叙儳åŗå¾ę•é‹¤é™¤å‚·å„Ÿå‹åŒ å‡å¬å“Ø商唱嘗å„Ø妾åؼ宵将小少尚åŗ„åŗŠå» å½°ę‰æęŠ„ę‹›ęŽŒę·ę˜‡ę˜Œę˜­ę™¶ę¾ę¢¢ę؟ęØµę²¼ę¶ˆęø‰ę¹˜ē„¼ē„¦ē…§ē—‡ēœē”ē¤ē„„ē§°ē« ē¬‘ē²§ē“¹č‚–č–č’‹č•‰č”č£³č؟čØ¼č©”č©³č±”č³žé†¤é‰¦é¾é˜éšœéž˜äøŠäøˆäøžä¹—冗剰城堓壌嬢åøøęƒ…ę“¾ę”ę–ęµ„ēŠ¶ē•³ē©£č’øč­²é†ø錠嘱埓飾\"],[\"9040\",\"ę‹­ę¤ę®–ē‡­ē¹”č·č‰²č§¦é£Ÿč•č¾±å°»ä¼øäæ”侵唇åØ åƝåÆ©åæƒę…ŽęŒÆę–°ę™‹ę£®ę¦›ęµøę·±ē”³ē–¹ēœŸē„žē§¦ē“³č‡£čŠÆč–Ŗč¦ŖčØŗčŗ«č¾›é€²é‡éœ‡äŗŗ仁刃唵壬尋ē”šå°½č…Žč؊čæ…陣靭ē¬„č«é ˆé…¢å›³åŽØ\"],[\"9080\",\"逗吹垂åø„ęŽØę°“ē‚Šē”ē²‹ēæ č”°é‚酔錐錘随ē‘žé«„å“‡åµ©ę•°ęž¢č¶Øé››ę®ę‰ę¤™č…é —é›€č£¾ę¾„ę‘ŗåÆøäø–ē€¬ē•ę˜Æå‡„åˆ¶å‹¢å§“å¾ę€§ęˆę”æę•“ę˜Ÿę™“ę£²ę –ę­£ęø…ē‰²ē”Ÿē››ē²¾č–å£°č£½č„æčŖ čŖ“č«‹é€é†’é’é™ę–‰ēØŽč„†éš»åø­ęƒœęˆšę–„ꘔꞐēŸ³ē©ē±ēø¾č„Šč²¬čµ¤č·”č¹Ÿē¢©åˆ‡ę‹™ęŽ„ꑂꊘčØ­ēŖƒēƀčŖ¬é›Ŗēµ¶čˆŒč‰ä»™å…ˆåƒå å®£å°‚å°–å·ęˆ¦ę‰‡ę’°ę “ę “ę³‰ęµ…ę“—ęŸ“ę½œē…Žē…½ę—‹ē©æē®­ē·š\"],[\"9140\",\"ē¹Šē¾Øč…ŗčˆ›čˆ¹č–¦č©®č³Žč·µéø遷銭銑閃鮮前善ę¼øē„¶å…Øē¦…ē¹•č†³ē³Žå™Œå”‘å²ØęŽŖę›¾ę›½ę„šē‹™ē–ē–Žē¤Žē„–ē§Ÿē²—ē“ ēµ„č˜‡čؓ阻達鼠僧創双叢倉å–Ŗ壮儏ēˆ½å®‹å±¤åŒęƒ£ęƒ³ęœęŽƒęŒæꎻ\"],[\"9180\",\"ę“ę—©ę›¹å·£ę§ę§½ę¼•ē‡„äŗ‰ē—©ē›øēŖ“ē³Ÿē·ē¶œč”č‰č˜č‘¬č’¼č—»č£…čµ°é€é­éŽ—éœœéØ’åƒå¢—ę†Žč‡“č”µč“ˆé€ äæƒå“則即ęÆꍉꝟęø¬č¶³é€Ÿäæ—å±žč³Šę—ē¶šå’č¢–å…¶ęƒå­˜å­«å°Šęę‘éœä»–å¤šå¤Ŗę±°č©‘å”¾å •å¦„ęƒ°ę‰“ęŸčˆµę„•é™€é§„éØØ体堆åÆ¾č€å²±åøÆå¾…ę€ ę…‹ęˆ“ę›æę³°ę»žčƒŽč…æč‹”č¢‹č²ø退逮隊黛éƛ代台大ē¬¬é†é”Œé·¹ę»ē€§å“å•„å®…ę‰˜ęŠžę‹“ę²¢ęæÆē¢čؗéøęæč«¾čŒø凧č›øåŖ\"],[\"9240\",\"å©ä½†é”č¾°å„Ŗč„±å·½ē«Ŗč¾æę£šč°·ē‹ø鱈ęؽčŖ°äø¹å˜å˜†å¦ę‹…ęŽ¢ę—¦ę­Žę·”ę¹›ē‚­ēŸ­ē«Æē®Ŗē¶»č€½čƒ†č›‹čŖ•é›å›£å£‡å¼¾ę–­ęš–ęŖ€ę®µē”·č«‡å€¤ēŸ„åœ°å¼›ę„ę™ŗę± ē—“ēؚē½®č‡“čœ˜é…é¦³ēƉē•œē«¹ē­‘č“„\"],[\"9280\",\"逐ē§©ēŖ’čŒ¶å«”ē€äø­ä»²å®™åæ ęŠ½ę˜¼ęŸ±ę³Ø虫蔷čػ酎鋳駐ęؗē€¦ēŒŖ苧著č²Æäøå…†å‡‹å–‹åƵåø–åø³åŗå¼”å¼µå½«å¾“ę‡²ęŒ‘ęš¢ęœę½®ē‰’ē”ŗēœŗč“č„¹č…øč¶čŖæč«œč¶…č·³éŠšé•·é ‚é³„å‹…ę—ē›“ęœ•ę²ˆēč³ƒéŽ®é™³ę“„å¢œę¤Žę§Œčæ½éŽšē—›é€šå”šę ‚ęŽ“ę§»ä½ƒę¼¬ęŸ˜č¾»č”¦ē¶“鍔ę¤æę½°åŖ壷嬬ē“¬ēˆŖ吊釣鶓äŗ­ä½Žåœåµå‰ƒč²žå‘ˆå ¤å®šåøåŗ•åŗ­å»·å¼Ÿę‚ŒęŠµęŒŗꏐę¢Æę±€ē¢‡ē¦Žē؋ē· č‰‡čØ‚č«¦č¹„é€“\"],[\"9340\",\"é‚øé„­é‡˜é¼Žę³„ę‘˜ę“¢ę•µę»“ēš„ē¬›é©é‘ęŗŗå“²å¾¹ę’¤č½čæ­é‰„å…ø唫天展åŗ—ę·»ēŗē”œč²¼č»¢é”›ē‚¹ä¼ę®æę¾±ē”°é›»å…Žåå µå”—å¦¬å± å¾’ę–—ęœęø”ē™»čŸč³­é€”都鍍ē „ē ŗåŠŖåŗ¦åœŸå„“ę€’å€’å…šå†¬\"],[\"9380\",\"å‡åˆ€å”å””å”˜å„—å®•å³¶å¶‹ę‚¼ęŠ•ę­ę±ę”ƒę¢¼ę£Ÿē›—ę·˜ę¹Æ궛ēÆē‡ˆå½“ē—˜ē„·ē­‰ē­”ē­’ē³–ēµ±åˆ°č‘£č•©č—¤čØŽč¬„č±†čøé€ƒé€é™é™¶é ­éØ°é—˜åƒå‹•åŒå ‚å°Žę†§ę’žę“žēž³ē«„čƒ“č„é“éŠ…å³ é“‡åŒæå¾—å¾³ę¶œē‰¹ē£ē¦æēƤęƒē‹¬čŖ­ę ƒę©”å‡øēŖę¤“å±Šé³¶č‹«åƅ酉ē€žå™øå±Æęƒ‡ę•¦ę²Œč±šéé “å‘‘ę›‡éˆå„ˆé‚£å†…ä¹å‡Ŗ薙謎ē˜ęŗé‹ę„¢é¦“ēø„ē•·å—ę„ č»Ÿé›£ę±äŗŒå°¼å¼čæ©åŒ‚č³‘č‚‰č™¹å»æę—„ä¹³å…„\"],[\"9440\",\"如å°æ韮任妊åæčŖęæ”ē¦°ē„¢åÆ§č‘±ēŒ«ē†±å¹“åæµę»ę’šē‡ƒē²˜ä¹ƒå»¼ä¹‹åŸœåš¢ę‚©ęæƒē“čƒ½č„³č†æč¾²č¦—čš¤å·“ęŠŠę’­č¦‡ę·ę³¢ę“¾ē¶ē “婆ē½µčŠ­é¦¬äæ³å»ƒę‹ęŽ’ę•—ęÆē›ƒē‰ŒčƒŒč‚ŗč¼©é…å€åŸ¹åŖ’ę¢…\"],[\"9480\",\"ę„³ē…¤ē‹½č²·å£²č³ é™Ŗ這čæē§¤ēŸ§č©ä¼Æå‰„åšę‹ęŸę³Šē™½ē®”ē²•čˆ¶č–„čæ«ę›ę¼ ēˆ†ēø›čŽ«é§éŗ¦å‡½ē®±ē”²ē®ø肇ē­ˆę«Øå¹”č‚Œē•‘ē• å…«é‰¢ęŗŒē™ŗ醗é«Ŗ伐ē½°ęŠœē­é–„鳩å™ŗå”™č›¤éš¼ä¼“åˆ¤åŠåå›åø†ę¬ę–‘ęæę°¾ę±Žē‰ˆēŠÆē­ē•”ē¹čˆ¬č—©č²©ēƄ釆ē…©é ’é£ÆęŒ½ę™©ē•Ŗē›¤ē£č•ƒč›®åŒŖ卑否妃åŗ‡å½¼ę‚²ę‰‰ę‰¹ęŠ«ę–ęÆ”ę³Œē–²ēš®ē¢‘ē§˜ē·‹ē½·č‚„č¢«čŖ¹č²»éæ非飛ę؋ē°øå‚™å°¾å¾®ęž‡ęƘēµēœ‰ē¾Ž\"],[\"9540\",\"é¼»ęŸŠēؗ匹ē–‹é«­å½¦č†č±č‚˜å¼¼åæ…ē•¢ē­†é€¼ę”§å§«åŖ›ē“ē™¾č¬¬äæµå½ŖęØ™ę°·ę¼‚ē“¢ē„Øč”Øč©•č±¹å»Ÿęē—…ē§’č‹—éŒØé‹²č’œč›­é°­å“å½¬ę–Œęµœē€•č²§č³“é »ę•ē“¶äøä»˜åŸ å¤«å©¦åƌå†Øåøƒåŗœę€–ꉶꕷ\"],[\"9580\",\"ꖧꙮ굮ēˆ¶ē¬¦č…č†ščŠ™č­œč² č³¦čµ“é˜œé™„ä¾®ę’«ę­¦čˆžč‘”č•ŖéƒØå°ę„“é¢Øč‘ŗč•—ä¼å‰Æå¾©å¹…ęœē¦č…¹č¤‡č¦†ę·µå¼—ꉕę²ø仏ē‰©é®’åˆ†å»å™“å¢³ę†¤ę‰®ē„šå„®ē²‰ē³žē“›é›°ę–‡čžäø™ä½µå…µå”€å¹£å¹³å¼ŠęŸ„äø¦č”½é–‰é™›ē±³é åƒ»å£ē™–ē¢§åˆ„ēž„蔑ē®†åå¤‰ē‰‡ēƇē·Øč¾ŗčæ”遍ä¾æ勉åة弁鞭äæčˆ—é‹Ŗåœƒę•ę­©ē”«č£œč¼”ē©‚å‹Ÿå¢“ę…•ęˆŠęš®ęƍē°æč©å€£äæø包呆報儉宝峰å³Æå“©åŗ–ęŠ±ę§ę”¾ę–¹ęœ‹\"],[\"9640\",\"ę³•ę³”ēƒ¹ē ²ēø«čƒžčŠ³čŒč“¬čœ‚褒čØŖč±Šé‚¦é‹’é£½é³³éµ¬ä¹äŗ”傍剖坊å¦Øåø½åæ˜åæ™ęˆæęš“ęœ›ęŸę£’å†’ē“”č‚Ŗč†Øč¬€č²Œč²æ鉾防吠頬北僕卜å¢Øę’²ęœ“ē‰§ē¦ē©†é‡¦å‹ƒę²”ę®†å €å¹Œå„”ęœ¬ēæ»å‡”ē›†\"],[\"9680\",\"ę‘©ē£Ø魔éŗ»åŸ‹å¦¹ę˜§ęžšęÆŽå“©ę§™å¹•č†œęž•é®ŖęŸ¾é±’ę”äŗ¦äæ£åˆęŠ¹ęœ«ę²«čæ„ä¾­ē¹­éŗæäø‡ę…¢ęŗ€ę¼«č”“味ęœŖ魅巳ē®•å²¬åÆ†čœœę¹Šč“‘ēØ”č„ˆå¦™ē²ę°‘ēœ å‹™å¤¢ē„”ē‰ŸēŸ›éœ§éµ”ꤋå©æåØ˜å†„åå‘½ę˜Žē›Ÿčæ·éŠ˜é³“å§Ŗē‰ę»…å…ę£‰ē¶æē·¬é¢éŗŗę‘øęØ”čŒ‚å¦„å­ŸęƛēŒ›ē›²ē¶²č€—č’™å„²ęœØ黙ē›®ę¢å‹æé¤…å°¤ęˆ»ē±¾č²°å•ę‚¶ē“‹é–€åŒä¹Ÿå†¶å¤œēˆŗč€¶é‡Žå¼„ēŸ¢åŽ„å½¹ē“„č–¬čسčŗé–ęŸ³č–®é‘“ę„‰ę„ˆę²¹ē™’\"],[\"9740\",\"č«­č¼øå”Æ佑å„Ŗå‹‡å‹å®„å¹½ę‚ ę†‚ę–ęœ‰ęŸšę¹§ę¶ŒēŒ¶ēŒ·ē”±ē„č£•čŖ˜éŠé‚‘éƒµé›„čžå¤•äŗˆä½™äøŽčŖ‰č¼æ預傭幼妖容åŗøꏚęŗę“ę›œę„Šę§˜ę“‹ęŗ¶ē†”ē”ØēŖÆē¾Šč€€č‘‰č“‰č¦č¬”čøŠé„é™½é¤Šę…¾ęŠ‘ę¬²\"],[\"9780\",\"ę²ƒęµ“ēæŒēæ¼ę·€ē¾…čžŗč£øę„čŽ±é ¼é›·ę“›ēµ”č½é…Ŗä¹±åµåµę¬„ęæ«č—č˜­č¦§åˆ©åå±„Ꝏę¢Øē†ē’ƒē—¢č£č£”里離é™ø律ēŽ‡ē«‹č‘ŽęŽ ē•„åŠ‰ęµęŗœē‰ē•™ē”«ē²’隆ē«œé¾ä¾¶ę…®ę—…č™œäŗ†äŗ®åƒšäø”凌åÆ®ę–™ę¢ę¶¼ēŒŸē™‚ēž­ē؜ē³§č‰Æč«’é¼é‡é™µé ˜åŠ›ē·‘å€«åŽ˜ęž—ę·‹ē‡ē³č‡Øč¼Ŗ隣鱗éŗŸē‘ å”ę¶™ē“Æ锞令伶例冷励å¶ŗꀜēŽ²ē¤¼č‹“鈓隷零霊éŗ—é½¢ęš¦ę­“列劣ēƒˆč£‚å»‰ę‹ę†ę¼£ē…‰ē°¾ē·“čÆ\"],[\"9840\",\"č“®é€£éŒ¬å‘‚é­Æę«“ē‚‰č³‚č·Æéœ²åŠ“å©å»Šå¼„ęœ—ę„¼ę¦”ęµŖę¼ē‰¢ē‹¼ēÆ­č€č¾č‹éƒŽå…­éŗ“ē¦„č‚‹éŒ²č«–å€­å’Œč©±ę­Ŗč³„č„‡ęƒ‘ęž é·²äŗ™äŗ˜é°č©«č—č•Øę¤€ę¹¾ē¢—č…•\"],[\"989f\",\"弌äøäø•äøŖäø±äø¶äø¼äøæ乂乖乘äŗ‚äŗ…豫äŗŠčˆ’弍äŗŽäŗžäŗŸäŗ äŗ¢äŗ°äŗ³äŗ¶ä»Žä»ä»„仆仂仗仞仭仟价伉佚估佛佝佗佇佶侈侏侘佻佩佰侑ä½Æ來侖儘äæ”äæŸäæŽäæ˜äæ›äæ‘äæšäæäæ¤äæ„倚å€Ø倔å€Ŗ倄倅伜äæ¶å€”倩倬äæ¾äæÆå€‘å€†åƒå‡ęœƒå•ååˆåšå–å¬åø傀傚傅傓傲\"],[\"9940\",\"僉僊傳僂僖僞僄僭僣僮價僵儉儁儂儖儕儔儚儔å„ŗ儷儼儻å„æ兀兒兌兔兢ē«ø兩å…Ŗ兮冀冂囘册冉冏冑冓冕冖冤冦冢冩å†Ŗå†«å†³å†±å†²å†°å†µå†½å‡…å‡‰å‡›å‡ č™•å‡©å‡­\"],[\"9980\",\"凰凵凾刄刋刔刎刧åˆŖ刮刳刹剏剄剋剌剞剔å‰Ŗ剓剩剳å‰æ剽劍劔劒剱劈劑č¾Øč¾§åŠ¬åŠ­åŠ¼åŠµå‹å‹å‹—å‹žå‹£å‹¦é£­å‹ å‹³å‹µå‹ø勹匆匈ē”ø匍匐匏匕匚匣åŒÆ匱匳åŒø區卆卅äø—卉卍凖卞卩卮夘卻卷厂厖厠厦厄厮厰厶參ē°’é›™åŸę›¼ē‡®å®åØ叭åŗ吁吽呀听吭吼吮吶吩吝呎咏呵咎呟呱呷呰咒呻咀呶咄咐咆哇咢å’ø咄咬哄哈å’Ø\"],[\"9a40\",\"咫哂咤咾咼哘哄哦唏唔哽哮哭å“ŗ哢唹啀啣啌售啜啅啖啗å”ø唳啝喙喀å’Æ喊喟啻啾喘喞單啼喃喩喇å–Ø嗚嗅嗟嗄嗜嗤嗔嘔嗷嘖嗾嗽嘛嗹噎噐ē‡Ÿå˜“嘶嘲å˜ø\"],[\"9a80\",\"噫噤å˜Æ噬å™Ŗ嚆嚀嚊嚠嚔嚏嚄嚮嚶嚓囂嚼囁囃囀囈囎囑囓囗囮囹圀å›æ圄圉圈國圍圓團圖嗇圜圦圷åœø坎圻址坏坩埀垈坔åæ垉垓垠垳垤åžŖ垰埃埆埔埒埓堊埖埣堋堙堝唲堔唢唋唰ęƀ唒堽唹墅墹墟墫å¢ŗ壞墻å¢ø墮壅壓壑壗壙壘壄壜壤壟å£Æå£ŗå£¹å£»å£¼å£½å¤‚å¤Šå¤å¤›ę¢¦å¤„å¤¬å¤­å¤²å¤ø夾ē«’儕儐儎儚儘儢儠儧儬儩\"],[\"9b40\",\"å„ø妁妝佞侫妣妲姆å§Ø姜妍姙姚åØ„å؟åؑå؜å؉åؚ婀婬婉åصåض婢å©ŖåŖšåŖ¼åŖ¾å«‹å«‚åŖ½å«£å«—嫦嫩嫖å«ŗ嫻嬌嬋嬖嬲嫐å¬Ŗ嬶嬾孃孅孀孑孕孚孛孄孩孰孳孵å­øꖈå­ŗ宀\"],[\"9b80\",\"它宦å®øåƃåƇåƉåƔåƐåƤåƦåÆ¢åƞåÆ„åÆ«åÆ°åƶåƳ尅將專對尓尠尢å°Øå°ø尹屁屆屎屓屐屏孱屬屮乢屶屹岌岑岔妛岫岻岶岼岷峅岾峇峙峩峽å³ŗ峭嶌å³Ŗ哋哕哗嵜哟哛哑哔哢哚哙哘嵌嵒嵎嵋嵬嵳嵶嶇嶄嶂嶢嶝嶬嶮嶽嶐嶷嶼巉巍巓巒巖巛巫已巵åø‹åøšåø™åø‘åø›åø¶åø·å¹„幃幀幎幗幔幟幢幤幇幵并å¹ŗéŗ¼å¹æåŗ å»å»‚廈廐廏\"],[\"9c40\",\"廖廣廝廚廛廢廔å»Ø廩廬廱廳廰廓å»ø廾弃弉彝彜弋弑弖弩弭å¼ø彁彈彌彎å¼Æ彑彖彗彙彔彭彳彷徃徂å½æ徊很徑徇從徙徘徠å¾Øå¾­å¾¼åæ–åæ»åæ¤åæøåæ±åæę‚³åææꀔꁠ\"],[\"9c80\",\"ę€™ę€ę€©ę€Žę€±ę€›ę€•ę€«ę€¦ę€ę€ŗꁚꁁęŖę·ęŸęŠę†ęę£ęƒę¤ę‚ę¬ę«ę™ę‚ę‚ęƒ§ę‚ƒę‚šę‚„ę‚›ę‚–ę‚—ę‚’ę‚§ę‚‹ęƒ”ę‚øęƒ ęƒ“ę‚“åæ°ę‚½ęƒ†ę‚µęƒ˜ę…ę„•ę„†ęƒ¶ęƒ·ę„€ęƒ“ęƒŗę„ƒę„”ęƒ»ęƒ±ę„ę„Žę…‡ę„¾ę„Øꄧꅊę„æę„¼ę„¬ę„“ę„½ę…‚ę…„ę…³ę…·ę…˜ę…™ę…šę…«ę…“ę…Æę…„ę…±ę…Ÿę…ę…“ę…µę†™ę†–ę†‡ę†¬ę†”ę†šę†Šę†‘ę†«ę†®ę‡Œę‡Šę‡‰ę‡·ę‡ˆę‡ƒę‡†ę†ŗꇋē½¹ę‡ę‡¦ę‡£ę‡¶ę‡ŗꇓę‡æę‡½ę‡¼ę‡¾ęˆ€ęˆˆęˆ‰ęˆęˆŒęˆ”ęˆ›\"],[\"9d40\",\"ęˆžęˆ”ęˆŖęˆ®ęˆ°ęˆ²ęˆ³ę‰ę‰Žę‰žę‰£ę‰›ę‰ ę‰Øę‰¼ęŠ‚ęŠ‰ę‰¾ęŠ’ęŠ“ęŠ–ę‹”ęŠƒęŠ”ę‹—ę‹‘ęŠ»ę‹ę‹æę‹†ę“”ę‹ˆę‹œę‹Œę‹Šę‹‚ę‹‡ęŠ›ę‹‰ęŒŒę‹®ę‹±ęŒ§ęŒ‚ęŒˆę‹Æę‹µęęŒ¾ęęœęęŽ–ęŽŽęŽ€ęŽ«ę¶ęŽ£ęŽęŽ‰ęŽŸęŽµę«\"],[\"9d80\",\"ę©ęŽ¾ę©ę€ę†ę£ę‰ę’ę¶ę„ę–ę“ę†ę“ę¦ę¶ę”ę—ęØꐏꑧę‘Æꑶꑎę”Ŗę’•ę’“ę’„ę’©ę’ˆę’¼ę“šę“’ę“…ę“‡ę’»ę“˜ę“‚ę“±ę“§čˆ‰ę“ ę“”ęŠ¬ę“£ę“Æę”¬ę“¶ę““ę“²ę“ŗę”€ę“½ę”˜ę”œę”…ę”¤ę”£ę”«ę”“ę”µę”·ę”¶ę”øē•‹ę•ˆę•–ę••ę•ę•˜ę•žę•ę•²ę•øę–‚ę–ƒč®Šę–›ę–Ÿę–«ę–·ę—ƒę—†ę—ę—„ę—Œę—’ę—›ę—™ę— ę—”ę—±ę²ę˜Šę˜ƒę—»ę³ę˜µę˜¶ę˜“ę˜œę™ę™„ę™‰ę™ę™žę™ę™¤ę™§ę™Øę™Ÿę™¢ę™°ęšƒęšˆęšŽęš‰ęš„ęš˜ęšę›ęš¹ę›‰ęš¾ęš¼\"],[\"9e40\",\"ꛄęšøꛖꛚꛠę˜æę›¦ę›©ę›°ę›µę›·ęœęœ–ęœžęœ¦ęœ§éœøęœ®ęœæęœ¶ęęœøęœ·ę†ęžę ę™ę£ę¤ęž‰ę°ęž©ę¼ęŖęžŒęž‹ęž¦ęž”ęž…ęž·ęŸÆęž“ęŸ¬ęž³ęŸ©ęžøęŸ¤ęŸžęŸęŸ¢ęŸ®ęž¹ęŸŽęŸ†ęŸ§ęŖœę žę”†ę ©ę”€ę”ę ²ę”Ž\"],[\"9e80\",\"ę¢³ę «ę”™ę”£ę”·ę”æę¢Ÿę¢ę¢­ę¢”ę¢ę¢›ę¢ƒęŖ®ę¢¹ę”“ę¢µę¢ ę¢ŗę¤ę¢ę”¾ę¤ę£Šę¤ˆę£˜ę¤¢ę¤¦ę£”ę¤Œę£ę£”ę£§ę£•ę¤¶ę¤’ę¤„ę£—ę££ę¤„ę£¹ę£ ę£Æę¤Øę¤Ŗę¤šę¤£ę¤”ę£†ę„¹ę„·ę„œę„øę„«ę„”ę„¾ę„®ę¤¹ę„“ę¤½ę„™ę¤°ę„”ę„žę„ę¦ę„Ŗę¦²ę¦®ę§ę¦æę§ę§“ę¦¾ę§ŽåÆØę§Šę§ę¦»ę§ƒę¦§ęØ®ę¦‘ę¦ ę¦œę¦•ę¦“ę§žę§Øę؂ę؛ę§æę¬Šę§¹ę§²ę§§ęØ…ę¦±ęØžę§­ęØ”ę§«ę؊ęØ’ę«ęØ£ęØ“ę©„ęØŒę©²ęضę©øę©‡ę©¢ę©™ę©¦ę©ˆęØøęØ¢ęŖęŖęŖ ęŖ„ęŖ¢ęŖ£\"],[\"9f40\",\"ęŖ—č˜—ęŖ»ę«ƒę«‚ęŖøęŖ³ęŖ¬ę«žę«‘ę«ŸęŖŖę«šę«Ŗę«»ę¬…č˜–ę«ŗę¬’ę¬–é¬±ę¬Ÿę¬øꬷē›œę¬¹é£®ę­‡ę­ƒę­‰ę­ę­™ę­”ę­›ę­Ÿę­”ę­øę­¹ę­æę®€ę®„ę®ƒę®ę®˜ę®•ę®žę®¤ę®Ŗꮫę®Æę®²ę®±ę®³ę®·ę®¼ęƆęƋęƓęƟęƬęÆ«ęƳęÆÆ\"],[\"9f80\",\"éŗ¾ę°ˆę°“ę°”ę°›ę°¤ę°£ę±žę±•ę±¢ę±Ŗę²‚ę²ę²šę²ę²›ę±¾ę±Øę±³ę²’ę²ę³„ę³±ę³“ę²½ę³—ę³…ę³ę²®ę²±ę²¾ę²ŗę³›ę³Æę³™ę³Ŗę“Ÿč”ę“¶ę“«ę“½ę“øę“™ę“µę“³ę“’ę“Œęµ£ę¶“ęµ¤ęµšęµ¹ęµ™ę¶Žę¶•ęæ¤ę¶…ę·¹ęø•ęøŠę¶µę·‡ę·¦ę¶øę·†ę·¬ę·žę·Œę·Øę·’ę·…ę·ŗ귙귤귕ę·Ŗę·®ęø­ę¹®ęø®ęø™ę¹²ę¹Ÿęø¾ęø£ę¹«ęø«ę¹¶ę¹ęøŸę¹ƒęøŗę¹Žęø¤ę»æęøęøøęŗ‚ęŗŖęŗ˜ę»‰ęŗ·ę»“ęŗ½ęŗÆ껄ęŗ²ę»”껕ęŗęŗ„껂ęŗŸę½ę¼‘ēŒę»¬ę»øę»¾ę¼æę»²ę¼±ę»Æę¼²ę»Œ\"],[\"e040\",\"ę¼¾ę¼“ę»·ę¾†ę½ŗę½øę¾ę¾€ę½Æę½›ęæ³ę½­ę¾‚ę½¼ę½˜ę¾Žę¾‘ęæ‚ę½¦ę¾³ę¾£ę¾”ę¾¤ę¾¹ęæ†ę¾ŖęæŸęæ•ęæ¬ęæ”ęæ˜ęæ±ęæ®ęæ›ē€‰ē€‹ęæŗē€‘ē€ē€ęæ¾ē€›ē€šę½“ē€ē€˜ē€Ÿē€°ē€¾ē€²ē‘ē£ē‚™ē‚’ē‚Æēƒ±ē‚¬ē‚øē‚³ē‚®ēƒŸēƒ‹ēƒ\"],[\"e080\",\"ēƒ™ē„‰ēƒ½ē„œē„™ē…„ē…•ē†ˆē…¦ē…¢ē…Œē…–ē…¬ē†ē‡»ē†„ē†•ē†Øē†¬ē‡—ē†¹ē†¾ē‡’ē‡‰ē‡”ē‡Žē‡ ē‡¬ē‡§ē‡µē‡¼ē‡¹ē‡æēˆēˆēˆ›ēˆØēˆ­ēˆ¬ēˆ°ēˆ²ēˆ»ēˆ¼ēˆæē‰€ē‰†ē‰‹ē‰˜ē‰“ē‰¾ēŠ‚ēŠēŠ‡ēŠ’ēŠ–ēŠ¢ēŠ§ēŠ¹ēŠ²ē‹ƒē‹†ē‹„ē‹Žē‹’ē‹¢ē‹ ē‹”ē‹¹ē‹·å€ēŒ—ēŒŠēŒœēŒ–ēŒēŒ“ēŒÆēŒ©ēŒ„ēŒ¾ēŽēé»˜ē—ēŖēØē°ēøēµē»ēŗēˆēŽ³ēŽēŽ»ē€ē„ē®ēžē’¢ē…ē‘Æē„ēøē²ēŗē‘•ēæē‘Ÿē‘™ē‘ē‘œē‘©ē‘°ē‘£ē‘Ŗē‘¶ē‘¾ē’‹ē’žē’§ē“Šē“ē“”ē±\"],[\"e140\",\"ē“ ē“£ē“§ē“©ē“®ē“²ē“°ē“±ē“øē“·ē”„ē”ƒē”…ē”Œē”Žē”ē”•ē”“ē”žē”¦ē”¬ē”¼ē•„ē•ē•Šē•‰ē•›ē•†ē•šē•©ē•¤ē•§ē•«ē•­ē•øē•¶ē–†ē–‡ē•“ē–Šē–‰ē–‚ē–”ē–šē–ē–„ē–£ē—‚ē–³ē—ƒē–µē–½ē–øē–¼ē–±ē—ē—Šē—’ē—™ē—£ē—žē—¾ē—æ\"],[\"e180\",\"ē—¼ē˜ē—°ē—ŗē—²ē—³ē˜‹ē˜ē˜‰ē˜Ÿē˜§ē˜ ē˜”ē˜¢ē˜¤ē˜“ē˜°ē˜»ē™‡ē™ˆē™†ē™œē™˜ē™”ē™¢ē™Øē™©ē™Ŗē™§ē™¬ē™°ē™²ē™¶ē™øē™¼ēš€ēšƒēšˆēš‹ēšŽēš–ēš“ēš™ēššēš°ēš“ēšøēš¹ēšŗē›‚ē›ē›–ē›’ē›žē›”ē›„ē›§ē›Ŗč˜Æē›»ēœˆēœ‡ēœ„ēœ©ēœ¤ēœžēœ„ēœ¦ēœ›ēœ·ēœøē‡ēšēØē«ē›ē„ēæē¾ē¹ēžŽēž‹ēž‘ēž ēžžēž°ēž¶ēž¹ēžæēž¼ēž½ēž»ēŸ‡ēŸēŸ—ēŸšēŸœēŸ£ēŸ®ēŸ¼ē Œē ’ē¤¦ē  ē¤Ŗē”…ē¢Žē”“ē¢†ē”¼ē¢šē¢Œē¢£ē¢µē¢Ŗē¢Æē£‘ē£†ē£‹ē£”ē¢¾ē¢¼ē£…ē£Šē£¬\"],[\"e240\",\"ē£§ē£šē£½ē£“ē¤‡ē¤’ē¤‘ē¤™ē¤¬ē¤«ē„€ē„ ē„—ē„Ÿē„šē„•ē„“ē„ŗē„æē¦Šē¦ē¦§é½‹ē¦Ŗē¦®ē¦³ē¦¹ē¦ŗē§‰ē§•ē§§ē§¬ē§”ē§£ē؈ē؍ēؘēؙēØ ē؟ē¦€ēرēØ»ēؾēØ·ē©ƒē©—ē©‰ē©”ē©¢ē©©é¾ē©°ē©¹ē©½ēŖˆēŖ—ēŖ•ēŖ˜ēŖ–ēŖ©ē«ˆēŖ°\"],[\"e280\",\"ēŖ¶ē«…ē«„ēŖæ邃ē«‡ē«Šē«ē«ē«•ē«“ē«™ē«šē«ē«”ē«¢ē«¦ē«­ē«°ē¬‚ē¬ē¬Šē¬†ē¬³ē¬˜ē¬™ē¬žē¬µē¬Øē¬¶ē­ē­ŗē¬„ē­ē¬‹ē­Œē­…ē­µē­„ē­“ē­§ē­°ē­±ē­¬ē­®ē®ē®˜ē®Ÿē®ē®œē®šē®‹ē®’ē®ē­ē®™ēƋēƁēƌēƏē®“ēƆēƝēÆ©ē°‘ē°”ēƦēÆ„ē± ē°€ē°‡ē°“ēƳēÆ·ē°—ē°ēƶē°£ē°§ē°Ŗē°Ÿē°·ē°«ē°½ē±Œē±ƒē±”ē±ē±€ē±ē±˜ē±Ÿē±¤ē±–ē±„ē±¬ē±µē²ƒē²ē²¤ē²­ē²¢ē²«ē²”ē²Øē²³ē²²ē²±ē²®ē²¹ē²½ē³€ē³…ē³‚ē³˜ē³’ē³œē³¢é¬»ē³Æē³²ē³“ē³¶ē³ŗē“†\"],[\"e340\",\"ē“‚ē“œē“•ē“Šēµ…ēµ‹ē“®ē“²ē“æē“µēµ†ēµ³ēµ–ēµŽēµ²ēµØēµ®ēµēµ£ē¶“ē¶‰ēµ›ē¶ēµ½ē¶›ē¶ŗē¶®ē¶£ē¶µē·‡ē¶½ē¶«ēø½ē¶¢ē¶Æē·œē¶øē¶Ÿē¶°ē·˜ē·ē·¤ē·žē·»ē·²ē·”ēø…ēøŠēø£ēø”ēø’ēø±ēøŸēø‰ēø‹ēø¢ē¹†ē¹¦ēø»ēøµēø¹ē¹ƒēø·\"],[\"e380\",\"ēø²ēøŗē¹§ē¹ē¹–ē¹žē¹™ē¹šē¹¹ē¹Ŗē¹©ē¹¼ē¹»ēŗƒē·•ē¹½č¾®ē¹æēŗˆēŗ‰ēŗŒēŗ’ēŗēŗ“ēŗ”ēŗ–ēŗŽēŗ›ēŗœē¼øē¼ŗē½…ē½Œē½ē½Žē½ē½‘ē½•ē½”ē½˜ē½Ÿē½ ē½Øē½©ē½§ē½øē¾‚ē¾†ē¾ƒē¾ˆē¾‡ē¾Œē¾”ē¾žē¾ē¾šē¾£ē¾Æē¾²ē¾¹ē¾®ē¾¶ē¾øč­±ēæ…ēæ†ēæŠēæ•ēæ”ēæ”ēæ¦ēæ©ēæ³ēæ¹é£œč€†č€„č€‹č€’č€˜č€™č€œč€”č€Øč€æč€»čŠč†č’č˜čščŸč¢čØč³č²č°č¶č¹č½čæč‚„č‚†č‚…č‚›č‚“č‚šč‚­å†č‚¬čƒ›čƒ„čƒ™čƒčƒ„čƒščƒ–č„‰čƒÆčƒ±č„›č„©č„£č„Æ腋\"],[\"e440\",\"éš‹č…†č„¾č…“č…‘čƒ¼č…±č…®č…„č…¦č…“č†ƒč†ˆč†Šč†€č†‚č† č†•č†¤č†£č…Ÿč†“č†©č†°č†µč†¾č†øč†½č‡€č‡‚č†ŗ臉臍臑臙臘臈臚臟臠臧č‡ŗč‡»č‡¾čˆčˆ‚čˆ…čˆ‡čˆŠčˆčˆčˆ–čˆ©čˆ«čˆøčˆ³č‰€č‰™č‰˜č‰č‰šč‰Ÿč‰¤\"],[\"e480\",\"č‰¢č‰Øč‰Ŗč‰«čˆ®č‰±č‰·č‰øč‰¾čŠčŠ’čŠ«čŠŸčŠ»čŠ¬č‹”č‹£č‹Ÿč‹’č‹“č‹³č‹ŗčŽ“čŒƒč‹»č‹¹č‹žčŒ†č‹œčŒ‰č‹™čŒµčŒ“čŒ–čŒ²čŒ±č€čŒ¹čč…čŒÆčŒ«čŒ—čŒ˜čŽ…čŽščŽŖčŽŸčŽ¢čŽ–čŒ£čŽŽčŽ‡čŽŠč¼čŽµč³čµčŽ čŽ‰čŽØč“č“č«čŽč½čƒč˜č‹čč·č‡č č²čč¢č čŽ½čøč”†č»č‘­čŖč¼č•šč’„č‘·č‘«č’­č‘®č’‚č‘©č‘†č¬č‘Æč‘¹čµč“Šč‘¢č’¹č’æč’Ÿč“™č“č’»č“šč“č“č“†č“–č’”č””č“æč““č”—č”˜č”¬č”Ÿč”•č””č“¼č•€č•£č•˜č•ˆ\"],[\"e540\",\"蕁蘂蕋蕕薀薤薈薑薊č–Ø蕭薔薛č—Ŗč–‡č–œč•·č•¾č–č—‰č–ŗč—č–¹č—č—•č—č—„č—œč—¹č˜Šč˜“č˜‹č—¾č—ŗč˜†č˜¢č˜šč˜°č˜æč™ä¹•č™”č™Ÿč™§č™±čš“čš£čš©čšŖčš‹čšŒčš¶čšÆč›„č›†čš°č›‰č £čš«č›”č›žč›©č›¬\"],[\"e580\",\"蛟蛛č›Æčœ’čœ†čœˆčœ€čœƒč›»čœ‘čœ‰čœč›¹čœŠčœ“čœæčœ·čœ»čœ„čœ©čœšč čŸčøčŒčŽč“č—čØč®č™č“č£čŖč …čž¢čžŸčž‚čžÆčŸ‹čž½čŸ€čŸé›–čž«čŸ„čž³čŸ‡čŸ†čž»čŸÆčŸ²čŸ č č čŸ¾čŸ¶čŸ·č ŽčŸ’č ‘č –č •č ¢č ”č ±č ¶č ¹č §č »č”„č”‚č”’č”™č”žč”¢č”«č¢č”¾č¢žč”µč”½č¢µč”²č¢‚č¢—č¢’č¢®č¢™č¢¢č¢č¢¤č¢°č¢æč¢±č£ƒč£„č£”č£˜č£™č£č£¹č¤‚č£¼č£“č£Øč£²č¤„č¤Œč¤Šč¤“č„ƒč¤žč¤„č¤Ŗ褫脁脄褻褶č¤øč„Œč¤č„ č„ž\"],[\"e640\",\"脦脤脭č„Ŗč„Æč„“č„·č„¾č¦ƒč¦ˆč¦Šč¦“č¦˜č¦”č¦©č¦¦č¦¬č¦Æč¦²č¦ŗč¦½č¦æč§€č§šč§œč§č§§č§“č§øč؃čؖčؐč،č؛č؝čØ„čØ¶č©č©›č©’č©†č©ˆč©¼č©­č©¬č©¢čŖ…čŖ‚čŖ„čŖØčŖ”čŖ‘čŖ„čŖ¦čŖščŖ£č«„č«č«‚č«šč««č«³č«§\"],[\"e680\",\"č«¤č«±č¬”č« č«¢č«·č«žč«›č¬Œč¬‡č¬šč«”č¬–č¬č¬—č¬ č¬³éž«č¬¦č¬«č¬¾č¬Øč­č­Œč­č­Žč­‰č­–č­›č­šč­«č­Ÿč­¬č­Æč­“č­½č®€č®Œč®Žč®’č®“č®–č®™č®šč°ŗ豁č°æč±ˆč±Œč±Žč±č±•č±¢č±¬č±øč±ŗč²‚č²‰č²…č²Šč²č²Žč²”č±¼č²˜ęˆč²­č²Ŗč²½č²²č²³č²®č²¶č³ˆč³č³¤č³£č³šč³½č³ŗč³»č“„č“…č“Šč“‡č“č“č“é½Žč““č³č“”č“–čµ§čµ­čµ±čµ³č¶č¶™č·‚č¶¾č¶ŗč·č·šč·–č·Œč·›č·‹č·Ŗč·«č·Ÿč·£č·¼čøˆčø‰č·æčøčøžčøčøŸč¹‚čøµčø°čø“č¹Š\"],[\"e740\",\"č¹‡č¹‰č¹Œč¹č¹ˆč¹™č¹¤č¹ čøŖč¹£č¹•č¹¶č¹²č¹¼čŗčŗ‡čŗ…čŗ„čŗ‹čŗŠčŗ“čŗ‘čŗ”čŗ™čŗŖčŗ”čŗ¬čŗ°č»†čŗ±čŗ¾č»…č»ˆč»‹č»›č»£č»¼č»»č»«č»¾č¼Šč¼…č¼•č¼’č¼™č¼“č¼œč¼Ÿč¼›č¼Œč¼¦č¼³č¼»č¼¹č½…č½‚č¼¾č½Œč½‰č½†č½Žč½—č½œ\"],[\"e780\",\"č½¢č½£č½¤č¾œč¾Ÿč¾£č¾­č¾Æč¾·čæščæ„čæ¢čæŖčæÆ邇čæ“逅čæ¹čæŗ逑逕途逍逞逖逋逧逶逵逹čæø遏遐遑遒逎遉逾遖遘遞éØéÆ遶éšØ遲邂遽邁邀邊邉邏é‚Øé‚Æé‚±é‚µéƒ¢éƒ¤ę‰ˆéƒ›é„‚é„’é„™é„²é„°é…Šé…–é…˜é…£é…„é…©é…³é…²é†‹é†‰é†‚é†¢é†«é†Æé†Ŗ醵醓é†ŗ釀釁釉釋釐釖釟釔釛釼釵釶鈞é‡æ鈔鈬鈕鈑鉞鉗鉅鉉鉤鉈銕éˆæ鉋鉐銜銖銓銛鉚鋏銹銷鋩錏é‹ŗ鍄錮\"],[\"e840\",\"錙錢錚錣éŒŗ錵錻鍜鍠鍼鍮鍖鎰鎬鎭鎔鎹鏖鏗éØ鏄鏘鏃鏝鏐鏈鏤鐚鐔鐓鐃鐇鐐鐶鐫鐵鐔éŗ鑁鑒鑄鑛鑠鑢鑞é‘Ŗ鈩鑰鑵鑷鑽鑚鑼鑾钁é‘æ閂閇閊閔閖閘閙\"],[\"e880\",\"閠é–Ø閧閭閼閻閹閾闊ęæ¶é—ƒé—é—Œé—•é—”闖關闔闄闢阔é˜Ø阮é˜Æ陂陌陏陋陷陜陞陝陟陦陲陬隍隘隕隗éšŖ隧隱隲隰隓隶éšøéš¹é›Žé›‹é›‰é›č„é›œéœé›•é›¹éœ„éœ†éœˆéœ“éœŽéœ‘éœéœ–éœ™éœ¤éœŖ霰霹霽霾靄靆靈靂靉靜靠靤靦éØ勒靫靱靹鞅靼鞁éŗ鞆鞋鞏鞐鞜éžØ鞦鞣鞳鞓韃韆韈韋韜韭齏韲ē«ŸéŸ¶éŸµé é Œé ø頤頔頷頽锆锏锋锫é”Æé”°\"],[\"e940\",\"锱锓锳é¢Ŗé¢Æ颱颶飄飃飆飩飫餃餉餒餔餘餔餝餞餤餠餬餮餽餾鄂鄉鄅鄐鄋鄑鄒鄌鄕馗馘馄馭馮馼駟駛駝駘駑駭駮駱駲駻é§øé؁é؏é؅駢éؙéØ«éط驅驂驀驃\"],[\"e980\",\"éؾ驕驍驛驗驟驢驄驤驩驫é©ŖéŖ­éŖ°éŖ¼é«€é«é«‘髓體髞髟髢髣髦é«Æ髫髮髓髱髷髻鬆鬘鬚鬟鬢鬣鬄鬧é¬Ø鬩é¬Ŗ鬮é¬Æ鬲魄魃魏魍魎魑魘魓鮓鮃鮑鮖鮗鮟鮠é®Ø鮓éƀéƊ鮹éƆéƏéƑéƒéÆ£éÆ¢éƤéƔéÆ”é°ŗéƲéƱéư鰕鰔鰉鰓鰌鰆鰈鰒鰊鰄鰮鰛鰄鰤鰔鰰鱇鰲鱆鰾鱚鱠鱧鱶é±ø鳧鳬鳰铉铈鳫铃铆é“Ŗ铦é¶Æ铣铟鵄铕铒鵁é“æ链鵆鵈\"],[\"ea40\",\"鵝鵞鵤鵑鵐鵙鵲鶉鶇鶫éµÆéµŗ鶚鶤鶩鶲鷄鷁鶻é¶øé¶ŗ鷆鷏鷂鷙鷓é·ø鷦鷭é·Æé·½éøšéø›éøžé¹µé¹¹é¹½éŗéŗˆéŗ‹éŗŒéŗ’éŗ•éŗ‘éŗéŗ„éŗ©éŗøéŗŖéŗ­é”黌黎黏黐黔黜點黝黠黄é»Øé»Æ\"],[\"ea80\",\"黓黶黷黹黻黼黽鼇鼈ēš·é¼•é¼”鼬鼾齊齒齔齣齟齠齔齦齧齬é½Ŗ齷齲齶龕龜龠å Æ꧇遙ē‘¤å‡œē†™\"],[\"ed40\",\"ēŗŠč¤œéˆéŠˆč“œäæ‰ē‚»ę˜±ę£ˆé‹¹ę›»å½…äøØ仔仼伀伃伹佖侒侊侚侔äæå€å€¢äææ倞偆偰偂傔僓僘兊兤冝冾凬刕劜劦勀勛匀匇匤卲厓厲叝ļ؎咜咊咩å“æ喆坙坄垬埈埇ļ؏\"],[\"ed80\",\"ļؐ增墲夋儓儛儝儣妤å¦ŗ孖åƀē”ÆåƘåƬ尞岦å²ŗ峵哧嵓ļؑ嵂嵭å¶ø嶹巐弔弓彧德åæžęę‚…ę‚Šęƒžęƒ•ę„ ęƒ²ę„‘ę„·ę„°ę†˜ęˆ“ęŠ¦ęµę‘ ę’ę“Žę•Žę˜€ę˜•ę˜»ę˜‰ę˜®ę˜žę˜¤ę™„ꙗꙙļØ’ę™³ęš™ęš ęš²ęšæę›ŗ꜎ļ¤©ę¦ęž»ę”’ęŸ€ę ę”„ę£ļؓę„ØļØ”ę¦˜ę§¢ęØ°ę©«ę©†ę©³ę©¾ę«¢ę«¤ęƖę°æę±œę²†ę±Æę³šę“„ę¶‡ęµÆę¶–ę¶¬ę·ę·øę·²ę·¼ęø¹ę¹œęø§ęø¼ęŗæę¾ˆę¾µęæµē€…ē€‡ē€Øē‚…ē‚«ē„ē„„ē…œē…†ē…‡ļؕē‡ē‡¾ēŠ±\"],[\"ee40\",\"ēŠ¾ēŒ¤ļؖē·ēŽ½ē‰ē–ē£ē’ē‡ēµē¦ēŖē©ē®ē‘¢ē’‰ē’Ÿē”ē•Æēš‚ēšœēšžēš›ēš¦ļؗē†åŠÆē ”ē”Žē”¤ē”ŗē¤°ļؘļؙļؚē¦”ļ؛ē¦›ē«‘ē«§ļ؜ē««ē®žļ؝ēµˆēµœē¶·ē¶ ē·–ē¹’ē½‡ē¾”ļØžčŒč¢čæč‡č¶č‘ˆč’“č•“č•™\"],[\"ee80\",\"č•«ļØŸč–°ļØ ļØ”č ‡č£µčؒčØ·č©¹čŖ§čŖ¾č«ŸļØ¢č«¶č­“č­æč³°č³“č“’čµ¶ļØ£č»ļؤļ؄遧郞ļئ鄕鄧釚釗釞釭釮釤釄鈆鈐鈊éˆŗ鉀鈼鉎鉙鉑鈹鉧銧鉷é‰ø鋧鋗鋙鋐ļا鋕鋠鋓錄錔鋻ļØØ錞é‹æ錝錂鍰鍗鎤鏆鏞éø鐱鑅鑈閒ļ§œļة隝éšÆ霳霻靃靍靏靑靕锗锄ļØŖļث餧ļج馞驎髙髜魵魲鮏鮱鮻鰀鵰鵫ļØ­éø™é»‘\"],[\"eeef\",\"ā…°\",9,\"ļæ¢ļæ¤ļ¼‡ļ¼‚\"],[\"f040\",\"ī€€\",62],[\"f080\",\"ī€æ\",124],[\"f140\",\"ī‚¼\",62],[\"f180\",\"īƒ»\",124],[\"f240\",\"ī…ø\",62],[\"f280\",\"ī†·\",124],[\"f340\",\"īˆ“\",62],[\"f380\",\"ī‰³\",124],[\"f440\",\"ī‹°\",62],[\"f480\",\"īŒÆ\",124],[\"f540\",\"īŽ¬\",62],[\"f580\",\"ī«\",124],[\"f640\",\"ī‘Ø\",62],[\"f680\",\"ī’§\",124],[\"f740\",\"ī”¤\",62],[\"f780\",\"ī•£\",124],[\"f840\",\"ī— \",62],[\"f880\",\"ī˜Ÿ\",124],[\"f940\",\"īšœ\"],[\"fa40\",\"ā…°\",9,\"ā… \",9,\"ļæ¢ļæ¤ļ¼‡ļ¼‚ćˆ±ā„–ā„”āˆµēŗŠč¤œéˆéŠˆč“œäæ‰ē‚»ę˜±ę£ˆé‹¹ę›»å½…äøØ仔仼伀伃伹佖侒侊侚侔äæå€å€¢äææ倞偆偰偂傔僓僘兊\"],[\"fa80\",\"兤冝冾凬刕劜劦勀勛匀匇匤卲厓厲叝ļ؎咜咊咩å“æ喆坙坄垬埈埇ļ؏ļؐ增墲夋儓儛儝儣妤å¦ŗ孖åƀē”ÆåƘåƬ尞岦å²ŗ峵哧嵓ļؑ嵂嵭å¶ø嶹巐弔弓彧德åæžęę‚…ę‚Šęƒžęƒ•ę„ ęƒ²ę„‘ę„·ę„°ę†˜ęˆ“ęŠ¦ęµę‘ ę’ę“Žę•Žę˜€ę˜•ę˜»ę˜‰ę˜®ę˜žę˜¤ę™„ꙗꙙļØ’ę™³ęš™ęš ęš²ęšæę›ŗ꜎ļ¤©ę¦ęž»ę”’ęŸ€ę ę”„ę£ļؓę„ØļØ”ę¦˜ę§¢ęØ°ę©«ę©†ę©³ę©¾ę«¢ę«¤ęƖę°æę±œę²†ę±Æę³šę“„ę¶‡ęµÆ\"],[\"fb40\",\"ę¶–ę¶¬ę·ę·øę·²ę·¼ęø¹ę¹œęø§ęø¼ęŗæę¾ˆę¾µęæµē€…ē€‡ē€Øē‚…ē‚«ē„ē„„ē…œē…†ē…‡ļؕē‡ē‡¾ēŠ±ēŠ¾ēŒ¤ļؖē·ēŽ½ē‰ē–ē£ē’ē‡ēµē¦ēŖē©ē®ē‘¢ē’‰ē’Ÿē”ē•Æēš‚ēšœēšžēš›ēš¦ļؗē†åŠÆē ”ē”Žē”¤ē”ŗē¤°ļؘļؙ\"],[\"fb80\",\"ļؚē¦”ļ؛ē¦›ē«‘ē«§ļ؜ē««ē®žļ؝ēµˆēµœē¶·ē¶ ē·–ē¹’ē½‡ē¾”ļØžčŒč¢čæč‡č¶č‘ˆč’“č•“č•™č•«ļØŸč–°ļØ ļØ”č ‡č£µčؒčØ·č©¹čŖ§čŖ¾č«ŸļØ¢č«¶č­“č­æč³°č³“č“’čµ¶ļØ£č»ļؤļ؄遧郞ļئ鄕鄧釚釗釞釭釮釤釄鈆鈐鈊éˆŗ鉀鈼鉎鉙鉑鈹鉧銧鉷é‰ø鋧鋗鋙鋐ļا鋕鋠鋓錄錔鋻ļØØ錞é‹æ錝錂鍰鍗鎤鏆鏞éø鐱鑅鑈閒ļ§œļة隝éšÆ霳霻靃靍靏靑靕锗锄ļØŖļث餧ļج馞驎髙\"],[\"fc40\",\"髜魵魲鮏鮱鮻鰀鵰鵫ļØ­éø™é»‘\"]]"); + +/***/ }), + +/***/ 2357: +/***/ ((module) => { + +"use strict"; +module.exports = require("assert");; + +/***/ }), + +/***/ 4293: +/***/ ((module) => { + +"use strict"; +module.exports = require("buffer");; + +/***/ }), + +/***/ 8614: +/***/ ((module) => { + +"use strict"; +module.exports = require("events");; + /***/ }), /***/ 5747: @@ -4427,6 +14916,30 @@ module.exports = require("fs");; /***/ }), +/***/ 8605: +/***/ ((module) => { + +"use strict"; +module.exports = require("http");; + +/***/ }), + +/***/ 7211: +/***/ ((module) => { + +"use strict"; +module.exports = require("https");; + +/***/ }), + +/***/ 1631: +/***/ ((module) => { + +"use strict"; +module.exports = require("net");; + +/***/ }), + /***/ 2087: /***/ ((module) => { @@ -4441,6 +14954,54 @@ module.exports = require("os");; "use strict"; module.exports = require("path");; +/***/ }), + +/***/ 2413: +/***/ ((module) => { + +"use strict"; +module.exports = require("stream");; + +/***/ }), + +/***/ 4304: +/***/ ((module) => { + +"use strict"; +module.exports = require("string_decoder");; + +/***/ }), + +/***/ 4016: +/***/ ((module) => { + +"use strict"; +module.exports = require("tls");; + +/***/ }), + +/***/ 8835: +/***/ ((module) => { + +"use strict"; +module.exports = require("url");; + +/***/ }), + +/***/ 1669: +/***/ ((module) => { + +"use strict"; +module.exports = require("util");; + +/***/ }), + +/***/ 8761: +/***/ ((module) => { + +"use strict"; +module.exports = require("zlib");; + /***/ }) /******/ }); diff --git a/.github/actions/isPullRequestMergeable/index.js b/.github/actions/isPullRequestMergeable/index.js index b29edd9eacb7..10f7d165a657 100644 --- a/.github/actions/isPullRequestMergeable/index.js +++ b/.github/actions/isPullRequestMergeable/index.js @@ -10,12 +10,10 @@ module.exports = const _ = __nccwpck_require__(4987); const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = __nccwpck_require__(7999); +const GithubUtils = __nccwpck_require__(7999); const promiseWhile = __nccwpck_require__(4502); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const pullRequestNumber = Number(core.getInput('PULL_REQUEST_NUMBER', {required: true})); const MAX_RETRIES = 30; @@ -25,9 +23,9 @@ const run = function () { console.log(`Checking the mergeability of PR #${pullRequestNumber}`); return promiseWhile( () => !mergeabilityResolved && retryCount < MAX_RETRIES, - _.throttle(() => octokit.pulls.get({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + _.throttle(() => GithubUtils.octokit.pulls.get({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, pull_number: pullRequestNumber, }) .then(({data}) => { @@ -64,6 +62,9 @@ module.exports = run; const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -79,18 +80,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -120,7 +152,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -145,7 +177,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -183,7 +215,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -219,7 +251,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -240,7 +272,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -299,7 +331,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -366,7 +398,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -382,7 +414,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -960,49 +992,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3841,6 +3830,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4283,6 +4570,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/isPullRequestMergeable/isPullRequestMergeable.js b/.github/actions/isPullRequestMergeable/isPullRequestMergeable.js index b506e872c556..71be6f90e2a2 100644 --- a/.github/actions/isPullRequestMergeable/isPullRequestMergeable.js +++ b/.github/actions/isPullRequestMergeable/isPullRequestMergeable.js @@ -1,11 +1,9 @@ const _ = require('underscore'); const core = require('@actions/core'); -const github = require('@actions/github'); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = require('../../libs/GithubUtils'); +const GithubUtils = require('../../libs/GithubUtils'); const promiseWhile = require('../../libs/promiseWhile'); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const pullRequestNumber = Number(core.getInput('PULL_REQUEST_NUMBER', {required: true})); const MAX_RETRIES = 30; @@ -15,9 +13,9 @@ const run = function () { console.log(`Checking the mergeability of PR #${pullRequestNumber}`); return promiseWhile( () => !mergeabilityResolved && retryCount < MAX_RETRIES, - _.throttle(() => octokit.pulls.get({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + _.throttle(() => GithubUtils.octokit.pulls.get({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, pull_number: pullRequestNumber, }) .then(({data}) => { diff --git a/.github/actions/isStagingDeployLocked/index.js b/.github/actions/isStagingDeployLocked/index.js index 34bd574910b7..23b0cc500f57 100644 --- a/.github/actions/isStagingDeployLocked/index.js +++ b/.github/actions/isStagingDeployLocked/index.js @@ -10,14 +10,10 @@ module.exports = const _ = __nccwpck_require__(4987); const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); const GithubUtils = __nccwpck_require__(7999); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); - const githubUtils = new GithubUtils(octokit); - - return githubUtils.getStagingDeployCash() + return GithubUtils.getStagingDeployCash() .then(({labels}) => { console.log(`Found StagingDeployCash with labels: ${_.pluck(labels, 'name')}`); core.setOutput('IS_LOCKED', _.contains(_.pluck(labels, 'name'), 'šŸ” LockCashDeploys šŸ”')); @@ -42,6 +38,9 @@ module.exports = run; const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -57,18 +56,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -98,7 +128,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -123,7 +153,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -161,7 +191,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -197,7 +227,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -218,7 +248,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -277,7 +307,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -344,7 +374,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -360,7 +390,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -908,49 +938,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3789,6 +3776,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4231,6 +4516,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/isStagingDeployLocked/isStagingDeployLocked.js b/.github/actions/isStagingDeployLocked/isStagingDeployLocked.js index fd3464f8d6da..83085d2a8f91 100644 --- a/.github/actions/isStagingDeployLocked/isStagingDeployLocked.js +++ b/.github/actions/isStagingDeployLocked/isStagingDeployLocked.js @@ -1,13 +1,9 @@ const _ = require('underscore'); const core = require('@actions/core'); -const github = require('@actions/github'); const GithubUtils = require('../../libs/GithubUtils'); const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); - const githubUtils = new GithubUtils(octokit); - - return githubUtils.getStagingDeployCash() + return GithubUtils.getStagingDeployCash() .then(({labels}) => { console.log(`Found StagingDeployCash with labels: ${_.pluck(labels, 'name')}`); core.setOutput('IS_LOCKED', _.contains(_.pluck(labels, 'name'), 'šŸ” LockCashDeploys šŸ”')); diff --git a/.github/actions/markPullRequestsAsDeployed/index.js b/.github/actions/markPullRequestsAsDeployed/index.js index e2461d59e59b..c5af123b69df 100644 --- a/.github/actions/markPullRequestsAsDeployed/index.js +++ b/.github/actions/markPullRequestsAsDeployed/index.js @@ -9,39 +9,15 @@ module.exports = /***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require__) => { const core = __nccwpck_require__(2186); -const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); -const {throttling} = __nccwpck_require__(9968); +const {GitHub} = __nccwpck_require__(3030); const ActionUtils = __nccwpck_require__(970); const GithubUtils = __nccwpck_require__(7999); -const OctokitThrottled = GitHub.plugin(throttling); const prList = ActionUtils.getJSONInput('PR_LIST', {required: true}); const isProd = ActionUtils.getJSONInput('IS_PRODUCTION_DEPLOY', {required: true}); const version = core.getInput('DEPLOY_VERSION', {required: true}); -const token = core.getInput('GITHUB_TOKEN', {required: true}); -const octokit = new OctokitThrottled(getOctokitOptions(token, { - throttle: { - onRateLimit: (retryAfter, options) => { - console.warn( - `Request quota exhausted for request ${options.method} ${options.url}`, - ); - - // Retry once after hitting a rate limit error, then give up - if (options.request.retryCount <= 1) { - console.log(`Retrying after ${retryAfter} seconds!`); - return true; - } - }, - onAbuseLimit: (retryAfter, options) => { - // does not retry, only logs a warning - console.warn( - `Abuse detected for request ${options.method} ${options.url}`, - ); - }, - }, -})); -const githubUtils = new GithubUtils(octokit); + /** * Return a nicely formatted message for the table based on the result of the GitHub action job @@ -82,7 +58,7 @@ message += `\nšŸŽ iOS šŸŽ|${iOSResult} \nšŸ•ø web šŸ•ø|${webResult}`; * @returns {Promise} */ function commentPR(pr) { - return githubUtils.createComment(GitHub.context.repo.repo, pr, message, octokit) + return GithubUtils.createComment(GitHub.context.repo.repo, pr, message) .then(() => { console.log(`Comment created on #${pr} successfully šŸŽ‰`); }) @@ -134,6 +110,9 @@ module.exports = { const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -149,18 +128,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -190,7 +200,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -215,7 +225,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -253,7 +263,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -289,7 +299,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -310,7 +320,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -369,7 +379,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -436,7 +446,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -452,7 +462,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, diff --git a/.github/actions/reopenIssueWithComment/index.js b/.github/actions/reopenIssueWithComment/index.js index d9d0e6839273..d227fd7ffb0f 100644 --- a/.github/actions/reopenIssueWithComment/index.js +++ b/.github/actions/reopenIssueWithComment/index.js @@ -9,26 +9,24 @@ module.exports = /***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require__) => { const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = __nccwpck_require__(7999); +const GithubUtils = __nccwpck_require__(7999); -const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const issueNumber = core.getInput('ISSUE_NUMBER', {required: true}); const comment = core.getInput('COMMENT', {required: true}); function reopenIssueWithComment() { console.log(`Reopening issue #${issueNumber}`); - return octokit.issues.update({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.update({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, state: 'open', }) .then(() => { console.log(`Commenting on issue #${issueNumber}`); - return octokit.issues.createComment({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.createComment({ + owner: GithubUtils.GithubUtilsGITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, body: comment, }); @@ -53,6 +51,9 @@ reopenIssueWithComment() const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -68,18 +69,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -109,7 +141,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -134,7 +166,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -172,7 +204,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -208,7 +240,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -229,7 +261,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -288,7 +320,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -355,7 +387,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -371,7 +403,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -919,49 +951,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3800,6 +3789,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4242,6 +4529,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/reopenIssueWithComment/reopenIssueWithComment.js b/.github/actions/reopenIssueWithComment/reopenIssueWithComment.js index c05a15d542f1..f16b21a09a07 100644 --- a/.github/actions/reopenIssueWithComment/reopenIssueWithComment.js +++ b/.github/actions/reopenIssueWithComment/reopenIssueWithComment.js @@ -1,24 +1,22 @@ const core = require('@actions/core'); -const github = require('@actions/github'); -const {GITHUB_OWNER, EXPENSIFY_CASH_REPO} = require('../../libs/GithubUtils'); +const GithubUtils = require('../../libs/GithubUtils'); -const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); const issueNumber = core.getInput('ISSUE_NUMBER', {required: true}); const comment = core.getInput('COMMENT', {required: true}); function reopenIssueWithComment() { console.log(`Reopening issue #${issueNumber}`); - return octokit.issues.update({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.update({ + owner: GithubUtils.GITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, state: 'open', }) .then(() => { console.log(`Commenting on issue #${issueNumber}`); - return octokit.issues.createComment({ - owner: GITHUB_OWNER, - repo: EXPENSIFY_CASH_REPO, + return GithubUtils.octokit.issues.createComment({ + owner: GithubUtils.GithubUtilsGITHUB_OWNER, + repo: GithubUtils.EXPENSIFY_CASH_REPO, issue_number: issueNumber, body: comment, }); diff --git a/.github/actions/triggerWorkflowAndWait/index.js b/.github/actions/triggerWorkflowAndWait/index.js index 0046f8f109f1..2b80ac296a36 100644 --- a/.github/actions/triggerWorkflowAndWait/index.js +++ b/.github/actions/triggerWorkflowAndWait/index.js @@ -10,7 +10,6 @@ module.exports = const _ = __nccwpck_require__(4987); const core = __nccwpck_require__(2186); -const github = __nccwpck_require__(5438); const ActionUtils = __nccwpck_require__(970); const GithubUtils = __nccwpck_require__(7999); const promiseWhile = __nccwpck_require__(4502); @@ -37,8 +36,6 @@ const WORKFLOW_COMPLETION_TIMEOUT = 7200000; const POLL_RATE = 10000; const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); - const githubUtils = new GithubUtils(octokit); const workflow = core.getInput('WORKFLOW', {required: true}); const inputs = ActionUtils.getJSONInput('INPUTS', {required: false}, {}); @@ -60,13 +57,13 @@ const run = function () { let newWorkflowRunID; let hasNewWorkflowStarted = false; let workflowCompleted = false; - return githubUtils.getLatestWorkflowRunID(workflow) + return GithubUtils.getLatestWorkflowRunID(workflow) .then((lastWorkflowRunID) => { console.log(`Latest ${workflow} workflow run has ID: ${lastWorkflowRunID}`); previousWorkflowRunID = lastWorkflowRunID; console.log(`Dispatching workflow: ${workflow}`); - return octokit.actions.createWorkflowDispatch({ + return GithubUtils.octokit.actions.createWorkflowDispatch({ owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, workflow_id: workflow, @@ -89,7 +86,7 @@ const run = function () { _.throttle( () => { console.log(`\nšŸ¤š Waiting for a new ${workflow} workflow run to begin...`); - return githubUtils.getLatestWorkflowRunID(workflow) + return GithubUtils.getLatestWorkflowRunID(workflow) .then((lastWorkflowRunID) => { newWorkflowRunID = lastWorkflowRunID; hasNewWorkflowStarted = newWorkflowRunID !== previousWorkflowRunID; @@ -127,7 +124,7 @@ const run = function () { _.throttle( () => { console.log(`\nā³ Waiting for workflow run ${newWorkflowRunID} to finish...`); - return octokit.actions.getWorkflowRun({ + return GithubUtils.octokit.actions.getWorkflowRun({ owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, run_id: newWorkflowRunID, @@ -205,6 +202,9 @@ module.exports = { const _ = __nccwpck_require__(4987); const lodashGet = __nccwpck_require__(6908); +const core = __nccwpck_require__(2186); +const {GitHub, getOctokitOptions} = __nccwpck_require__(3030); +const {throttling} = __nccwpck_require__(9968); const GITHUB_OWNER = 'Expensify'; const EXPENSIFY_CASH_REPO = 'Expensify.cash'; @@ -220,18 +220,49 @@ const STAGING_DEPLOY_CASH_LABEL = 'StagingDeployCash'; class GithubUtils { /** - * @param {Octokit} octokit - Authenticated Octokit object https://octokit.github.io/rest.js + * Either give an existing instance of Octokit or create a new one + * + * @readonly + * @static + * @memberof GithubUtils */ - constructor(octokit) { - this.octokit = octokit; + static get octokit() { + if (this.octokitInternal) { + return this.octokitInternal; + } + const OctokitThrottled = GitHub.plugin(throttling); + const token = core.getInput('GITHUB_TOKEN', {required: true}); + this.octokitInternal = new OctokitThrottled(getOctokitOptions(token, { + throttle: { + onRateLimit: (retryAfter, options) => { + console.warn( + `Request quota exhausted for request ${options.method} ${options.url}`, + ); + + // Retry once after hitting a rate limit error, then give up + if (options.request.retryCount <= 1) { + console.log(`Retrying after ${retryAfter} seconds!`); + return true; + } + }, + onAbuseLimit: (retryAfter, options) => { + // does not retry, only logs a warning + console.warn( + `Abuse detected for request ${options.method} ${options.url}`, + ); + }, + }, + })); + return this.octokitInternal; } + /** * Finds one open `StagingDeployCash` issue via GitHub octokit library. * * @returns {Promise} */ - getStagingDeployCash() { + static getStagingDeployCash() { return this.octokit.issues.listForRepo({ owner: GITHUB_OWNER, repo: EXPENSIFY_CASH_REPO, @@ -261,7 +292,7 @@ class GithubUtils { * @param {Object} issue * @returns {Object} */ - getStagingDeployCashData(issue) { + static getStagingDeployCashData(issue) { try { const versionRegex = new RegExp('([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9]+))?', 'g'); const tag = issue.body.match(versionRegex)[0].replace(/`/g, ''); @@ -286,7 +317,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{url: String, number: Number, isVerified: Boolean}] */ - getStagingDeployCashPRList(issue) { + static getStagingDeployCashPRList(issue) { let PRListSection = issue.body.match(/pull requests:\*\*\r?\n((?:.*\r?\n)+)\r?\n/) || []; if (PRListSection.length !== 2) { // No PRs, return an empty array @@ -324,7 +355,7 @@ class GithubUtils { * @param {Object} issue * @returns {Array} - [{URL: String, number: Number, isResolved: Boolean}] */ - getStagingDeployCashDeployBlockers(issue) { + static getStagingDeployCashDeployBlockers(issue) { let deployBlockerSection = issue.body.match(/Deploy Blockers:\*\*\r?\n((?:.*\r?\n)+)/) || []; if (deployBlockerSection.length !== 2) { return []; @@ -360,7 +391,7 @@ class GithubUtils { * @param {Array} PRList * @returns {Promise} */ - createNewStagingDeployCash(title, tag, PRList) { + static createNewStagingDeployCash(title, tag, PRList) { return this.generateStagingDeployCashBody(tag, PRList) .then(body => this.octokit.issues.create({ owner: GITHUB_OWNER, @@ -381,7 +412,7 @@ class GithubUtils { * @returns {Promise} * @throws {Error} If the StagingDeployCash could not be found or updated. */ - updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { + static updateStagingDeployCash(newTag = '', newPRs, newDeployBlockers) { let issueNumber; return this.getStagingDeployCash() .then(({ @@ -440,7 +471,7 @@ class GithubUtils { * @param {Array} [resolvedDeployBlockers] - The list of DeployBlockers URLs which have been resolved. * @returns {Promise} */ - generateStagingDeployCashBody( + static generateStagingDeployCashBody( tag, PRList, verifiedPRList = [], @@ -507,7 +538,7 @@ class GithubUtils { * @param {String} messageBody - The comment message * @returns {Promise} */ - createComment(repo, number, messageBody) { + static createComment(repo, number, messageBody) { console.log(`Writing comment on #${number}`); return this.octokit.issues.createComment({ owner: GITHUB_OWNER, @@ -523,7 +554,7 @@ class GithubUtils { * @param {String} workflow * @returns {Promise} */ - getLatestWorkflowRunID(workflow) { + static getLatestWorkflowRunID(workflow) { console.log(`Fetching Expensify.cash workflow runs for ${workflow}...`); return this.octokit.actions.listWorkflowRuns({ owner: GITHUB_OWNER, @@ -1101,49 +1132,6 @@ exports.Context = Context; /***/ }), -/***/ 5438: -/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - -"use strict"; - -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getOctokit = exports.context = void 0; -const Context = __importStar(__nccwpck_require__(4087)); -const utils_1 = __nccwpck_require__(3030); -exports.context = new Context.Context(); -/** - * Returns a hydrated octokit ready to use for GitHub Actions - * - * @param token the repo PAT or GITHUB_TOKEN - * @param options other options to set - */ -function getOctokit(token, options) { - return new utils_1.GitHub(utils_1.getOctokitOptions(token, options)); -} -exports.getOctokit = getOctokit; -//# sourceMappingURL=github.js.map - -/***/ }), - /***/ 7914: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -3982,6 +3970,304 @@ exports.restEndpointMethods = restEndpointMethods; //# sourceMappingURL=index.js.map +/***/ }), + +/***/ 9968: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ value: true })); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var BottleneckLight = _interopDefault(__nccwpck_require__(1174)); + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +const VERSION = "3.4.1"; + +const noop = () => Promise.resolve(); // @ts-ignore + + +function wrapRequest(state, request, options) { + return state.retryLimiter.schedule(doRequest, state, request, options); +} // @ts-ignore + +async function doRequest(state, request, options) { + const isWrite = options.method !== "GET" && options.method !== "HEAD"; + const isSearch = options.method === "GET" && options.url.startsWith("/search/"); + const isGraphQL = options.url.startsWith("/graphql"); + const retryCount = ~~options.request.retryCount; + const jobOptions = retryCount > 0 ? { + priority: 0, + weight: 0 + } : {}; + + if (state.clustering) { + // Remove a job from Redis if it has not completed or failed within 60s + // Examples: Node process terminated, client disconnected, etc. + // @ts-ignore + jobOptions.expiration = 1000 * 60; + } // Guarantee at least 1000ms between writes + // GraphQL can also trigger writes + + + if (isWrite || isGraphQL) { + await state.write.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 3000ms between requests that trigger notifications + + + if (isWrite && state.triggersNotification(options.url)) { + await state.notifications.key(state.id).schedule(jobOptions, noop); + } // Guarantee at least 2000ms between search requests + + + if (isSearch) { + await state.search.key(state.id).schedule(jobOptions, noop); + } + + const req = state.global.key(state.id).schedule(jobOptions, request, options); + + if (isGraphQL) { + const res = await req; + + if (res.data.errors != null && // @ts-ignore + res.data.errors.some(error => error.type === "RATE_LIMITED")) { + const error = Object.assign(new Error("GraphQL Rate Limit Exceeded"), { + headers: res.headers, + data: res.data + }); + throw error; + } + } + + return req; +} + +var triggersNotificationPaths = ["/orgs/{org}/invitations", "/orgs/{org}/invitations/{invitation_id}", "/orgs/{org}/teams/{team_slug}/discussions", "/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "/repos/{owner}/{repo}/collaborators/{username}", "/repos/{owner}/{repo}/commits/{commit_sha}/comments", "/repos/{owner}/{repo}/issues", "/repos/{owner}/{repo}/issues/{issue_number}/comments", "/repos/{owner}/{repo}/pulls", "/repos/{owner}/{repo}/pulls/{pull_number}/comments", "/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", "/repos/{owner}/{repo}/pulls/{pull_number}/merge", "/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "/repos/{owner}/{repo}/pulls/{pull_number}/reviews", "/repos/{owner}/{repo}/releases", "/teams/{team_id}/discussions", "/teams/{team_id}/discussions/{discussion_number}/comments"]; + +// @ts-ignore +function routeMatcher(paths) { + // EXAMPLE. For the following paths: + + /* [ + "/orgs/{org}/invitations", + "/repos/{owner}/{repo}/collaborators/{username}" + ] */ + // @ts-ignore + const regexes = paths.map(path => path.split("/") // @ts-ignore + .map(c => c.startsWith("{") ? "(?:.+?)" : c).join("/")); // 'regexes' would contain: + + /* [ + '/orgs/(?:.+?)/invitations', + '/repos/(?:.+?)/(?:.+?)/collaborators/(?:.+?)' + ] */ + // @ts-ignore + + const regex = `^(?:${regexes.map(r => `(?:${r})`).join("|")})[^/]*$`; // 'regex' would contain: + + /* + ^(?:(?:\/orgs\/(?:.+?)\/invitations)|(?:\/repos\/(?:.+?)\/(?:.+?)\/collaborators\/(?:.+?)))[^\/]*$ + It may look scary, but paste it into https://www.debuggex.com/ + and it will make a lot more sense! + */ + + return new RegExp(regex, "i"); +} + +const regex = routeMatcher(triggersNotificationPaths); +const triggersNotification = regex.test.bind(regex); +const groups = {}; // @ts-ignore + +const createGroups = function (Bottleneck, common) { + // @ts-ignore + groups.global = new Bottleneck.Group(_objectSpread2({ + id: "octokit-global", + maxConcurrent: 10 + }, common)); // @ts-ignore + + groups.search = new Bottleneck.Group(_objectSpread2({ + id: "octokit-search", + maxConcurrent: 1, + minTime: 2000 + }, common)); // @ts-ignore + + groups.write = new Bottleneck.Group(_objectSpread2({ + id: "octokit-write", + maxConcurrent: 1, + minTime: 1000 + }, common)); // @ts-ignore + + groups.notifications = new Bottleneck.Group(_objectSpread2({ + id: "octokit-notifications", + maxConcurrent: 1, + minTime: 3000 + }, common)); +}; + +function throttling(octokit, octokitOptions = {}) { + const { + enabled = true, + Bottleneck = BottleneckLight, + id = "no-id", + timeout = 1000 * 60 * 2, + // Redis TTL: 2 minutes + connection + } = octokitOptions.throttle || {}; + + if (!enabled) { + return; + } + + const common = { + connection, + timeout + }; // @ts-ignore + + if (groups.global == null) { + createGroups(Bottleneck, common); + } + + const state = Object.assign(_objectSpread2({ + clustering: connection != null, + triggersNotification, + minimumAbuseRetryAfter: 5, + retryAfterBaseValue: 1000, + retryLimiter: new Bottleneck(), + id + }, groups), // @ts-ignore + octokitOptions.throttle); + + if (typeof state.onAbuseLimit !== "function" || typeof state.onRateLimit !== "function") { + throw new Error(`octokit/plugin-throttling error: + You must pass the onAbuseLimit and onRateLimit error handlers. + See https://github.com/octokit/rest.js#throttling + + const octokit = new Octokit({ + throttle: { + onAbuseLimit: (retryAfter, options) => {/* ... */}, + onRateLimit: (retryAfter, options) => {/* ... */} + } + }) + `); + } + + const events = {}; + const emitter = new Bottleneck.Events(events); // @ts-ignore + + events.on("abuse-limit", state.onAbuseLimit); // @ts-ignore + + events.on("rate-limit", state.onRateLimit); // @ts-ignore + + events.on("error", e => console.warn("Error in throttling-plugin limit handler", e)); // @ts-ignore + + state.retryLimiter.on("failed", async function (error, info) { + const options = info.args[info.args.length - 1]; + const shouldRetryGraphQL = options.url.startsWith("/graphql") && error.status !== 401; + + if (!(shouldRetryGraphQL || error.status === 403)) { + return; + } + + const retryCount = ~~options.request.retryCount; + options.request.retryCount = retryCount; + const { + wantRetry, + retryAfter + } = await async function () { + if (/\babuse\b/i.test(error.message)) { + // The user has hit the abuse rate limit. (REST and GraphQL) + // https://docs.github.com/en/rest/overview/resources-in-the-rest-api#abuse-rate-limits + // The Retry-After header can sometimes be blank when hitting an abuse limit, + // but is always present after 2-3s, so make sure to set `retryAfter` to at least 5s by default. + const retryAfter = Math.max(~~error.headers["retry-after"], state.minimumAbuseRetryAfter); + const wantRetry = await emitter.trigger("abuse-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + if (error.headers != null && error.headers["x-ratelimit-remaining"] === "0") { + // The user has used all their allowed calls for the current time period (REST and GraphQL) + // https://docs.github.com/en/rest/reference/rate-limit (REST) + // https://docs.github.com/en/graphql/overview/resource-limitations#rate-limit (GraphQL) + const rateLimitReset = new Date(~~error.headers["x-ratelimit-reset"] * 1000).getTime(); + const retryAfter = Math.max(Math.ceil((rateLimitReset - Date.now()) / 1000), 0); + const wantRetry = await emitter.trigger("rate-limit", retryAfter, options, octokit); + return { + wantRetry, + retryAfter + }; + } + + return {}; + }(); + + if (wantRetry) { + options.request.retryCount++; // @ts-ignore + + return retryAfter * state.retryAfterBaseValue; + } + }); + octokit.hook.wrap("request", wrapRequest.bind(null, state)); +} +throttling.VERSION = VERSION; +throttling.triggersNotification = triggersNotification; + +exports.throttling = throttling; +//# sourceMappingURL=index.js.map + + /***/ }), /***/ 537: @@ -4424,6 +4710,1536 @@ function removeHook(state, name, method) { } +/***/ }), + +/***/ 1174: +/***/ (function(module) { + +/** + * This file contains the Bottleneck library (MIT), compiled to ES2017, and without Clustering support. + * https://github.com/SGrondin/bottleneck + */ +(function (global, factory) { + true ? module.exports = factory() : + 0; +}(this, (function () { 'use strict'; + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getCjsExportFromNamespace (n) { + return n && n['default'] || n; + } + + var load = function(received, defaults, onto = {}) { + var k, ref, v; + for (k in defaults) { + v = defaults[k]; + onto[k] = (ref = received[k]) != null ? ref : v; + } + return onto; + }; + + var overwrite = function(received, defaults, onto = {}) { + var k, v; + for (k in received) { + v = received[k]; + if (defaults[k] !== void 0) { + onto[k] = v; + } + } + return onto; + }; + + var parser = { + load: load, + overwrite: overwrite + }; + + var DLList; + + DLList = class DLList { + constructor(incr, decr) { + this.incr = incr; + this.decr = decr; + this._first = null; + this._last = null; + this.length = 0; + } + + push(value) { + var node; + this.length++; + if (typeof this.incr === "function") { + this.incr(); + } + node = { + value, + prev: this._last, + next: null + }; + if (this._last != null) { + this._last.next = node; + this._last = node; + } else { + this._first = this._last = node; + } + return void 0; + } + + shift() { + var value; + if (this._first == null) { + return; + } else { + this.length--; + if (typeof this.decr === "function") { + this.decr(); + } + } + value = this._first.value; + if ((this._first = this._first.next) != null) { + this._first.prev = null; + } else { + this._last = null; + } + return value; + } + + first() { + if (this._first != null) { + return this._first.value; + } + } + + getArray() { + var node, ref, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, ref.value)); + } + return results; + } + + forEachShift(cb) { + var node; + node = this.shift(); + while (node != null) { + (cb(node), node = this.shift()); + } + return void 0; + } + + debug() { + var node, ref, ref1, ref2, results; + node = this._first; + results = []; + while (node != null) { + results.push((ref = node, node = node.next, { + value: ref.value, + prev: (ref1 = ref.prev) != null ? ref1.value : void 0, + next: (ref2 = ref.next) != null ? ref2.value : void 0 + })); + } + return results; + } + + }; + + var DLList_1 = DLList; + + var Events; + + Events = class Events { + constructor(instance) { + this.instance = instance; + this._events = {}; + if ((this.instance.on != null) || (this.instance.once != null) || (this.instance.removeAllListeners != null)) { + throw new Error("An Emitter already exists for this object"); + } + this.instance.on = (name, cb) => { + return this._addListener(name, "many", cb); + }; + this.instance.once = (name, cb) => { + return this._addListener(name, "once", cb); + }; + this.instance.removeAllListeners = (name = null) => { + if (name != null) { + return delete this._events[name]; + } else { + return this._events = {}; + } + }; + } + + _addListener(name, status, cb) { + var base; + if ((base = this._events)[name] == null) { + base[name] = []; + } + this._events[name].push({cb, status}); + return this.instance; + } + + listenerCount(name) { + if (this._events[name] != null) { + return this._events[name].length; + } else { + return 0; + } + } + + async trigger(name, ...args) { + var e, promises; + try { + if (name !== "debug") { + this.trigger("debug", `Event triggered: ${name}`, args); + } + if (this._events[name] == null) { + return; + } + this._events[name] = this._events[name].filter(function(listener) { + return listener.status !== "none"; + }); + promises = this._events[name].map(async(listener) => { + var e, returned; + if (listener.status === "none") { + return; + } + if (listener.status === "once") { + listener.status = "none"; + } + try { + returned = typeof listener.cb === "function" ? listener.cb(...args) : void 0; + if (typeof (returned != null ? returned.then : void 0) === "function") { + return (await returned); + } else { + return returned; + } + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + }); + return ((await Promise.all(promises))).find(function(x) { + return x != null; + }); + } catch (error) { + e = error; + { + this.trigger("error", e); + } + return null; + } + } + + }; + + var Events_1 = Events; + + var DLList$1, Events$1, Queues; + + DLList$1 = DLList_1; + + Events$1 = Events_1; + + Queues = class Queues { + constructor(num_priorities) { + var i; + this.Events = new Events$1(this); + this._length = 0; + this._lists = (function() { + var j, ref, results; + results = []; + for (i = j = 1, ref = num_priorities; (1 <= ref ? j <= ref : j >= ref); i = 1 <= ref ? ++j : --j) { + results.push(new DLList$1((() => { + return this.incr(); + }), (() => { + return this.decr(); + }))); + } + return results; + }).call(this); + } + + incr() { + if (this._length++ === 0) { + return this.Events.trigger("leftzero"); + } + } + + decr() { + if (--this._length === 0) { + return this.Events.trigger("zero"); + } + } + + push(job) { + return this._lists[job.options.priority].push(job); + } + + queued(priority) { + if (priority != null) { + return this._lists[priority].length; + } else { + return this._length; + } + } + + shiftAll(fn) { + return this._lists.forEach(function(list) { + return list.forEachShift(fn); + }); + } + + getFirst(arr = this._lists) { + var j, len, list; + for (j = 0, len = arr.length; j < len; j++) { + list = arr[j]; + if (list.length > 0) { + return list; + } + } + return []; + } + + shiftLastFrom(priority) { + return this.getFirst(this._lists.slice(priority).reverse()).shift(); + } + + }; + + var Queues_1 = Queues; + + var BottleneckError; + + BottleneckError = class BottleneckError extends Error {}; + + var BottleneckError_1 = BottleneckError; + + var BottleneckError$1, DEFAULT_PRIORITY, Job, NUM_PRIORITIES, parser$1; + + NUM_PRIORITIES = 10; + + DEFAULT_PRIORITY = 5; + + parser$1 = parser; + + BottleneckError$1 = BottleneckError_1; + + Job = class Job { + constructor(task, args, options, jobDefaults, rejectOnDrop, Events, _states, Promise) { + this.task = task; + this.args = args; + this.rejectOnDrop = rejectOnDrop; + this.Events = Events; + this._states = _states; + this.Promise = Promise; + this.options = parser$1.load(options, jobDefaults); + this.options.priority = this._sanitizePriority(this.options.priority); + if (this.options.id === jobDefaults.id) { + this.options.id = `${this.options.id}-${this._randomIndex()}`; + } + this.promise = new this.Promise((_resolve, _reject) => { + this._resolve = _resolve; + this._reject = _reject; + }); + this.retryCount = 0; + } + + _sanitizePriority(priority) { + var sProperty; + sProperty = ~~priority !== priority ? DEFAULT_PRIORITY : priority; + if (sProperty < 0) { + return 0; + } else if (sProperty > NUM_PRIORITIES - 1) { + return NUM_PRIORITIES - 1; + } else { + return sProperty; + } + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + doDrop({error, message = "This job has been dropped by Bottleneck"} = {}) { + if (this._states.remove(this.options.id)) { + if (this.rejectOnDrop) { + this._reject(error != null ? error : new BottleneckError$1(message)); + } + this.Events.trigger("dropped", {args: this.args, options: this.options, task: this.task, promise: this.promise}); + return true; + } else { + return false; + } + } + + _assertStatus(expected) { + var status; + status = this._states.jobStatus(this.options.id); + if (!(status === expected || (expected === "DONE" && status === null))) { + throw new BottleneckError$1(`Invalid job status ${status}, expected ${expected}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`); + } + } + + doReceive() { + this._states.start(this.options.id); + return this.Events.trigger("received", {args: this.args, options: this.options}); + } + + doQueue(reachedHWM, blocked) { + this._assertStatus("RECEIVED"); + this._states.next(this.options.id); + return this.Events.trigger("queued", {args: this.args, options: this.options, reachedHWM, blocked}); + } + + doRun() { + if (this.retryCount === 0) { + this._assertStatus("QUEUED"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + return this.Events.trigger("scheduled", {args: this.args, options: this.options}); + } + + async doExecute(chained, clearGlobalState, run, free) { + var error, eventInfo, passed; + if (this.retryCount === 0) { + this._assertStatus("RUNNING"); + this._states.next(this.options.id); + } else { + this._assertStatus("EXECUTING"); + } + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + this.Events.trigger("executing", eventInfo); + try { + passed = (await (chained != null ? chained.schedule(this.options, this.task, ...this.args) : this.task(...this.args))); + if (clearGlobalState()) { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._resolve(passed); + } + } catch (error1) { + error = error1; + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + } + + doExpire(clearGlobalState, run, free) { + var error, eventInfo; + if (this._states.jobStatus(this.options.id === "RUNNING")) { + this._states.next(this.options.id); + } + this._assertStatus("EXECUTING"); + eventInfo = {args: this.args, options: this.options, retryCount: this.retryCount}; + error = new BottleneckError$1(`This job timed out after ${this.options.expiration} ms.`); + return this._onFailure(error, eventInfo, clearGlobalState, run, free); + } + + async _onFailure(error, eventInfo, clearGlobalState, run, free) { + var retry, retryAfter; + if (clearGlobalState()) { + retry = (await this.Events.trigger("failed", error, eventInfo)); + if (retry != null) { + retryAfter = ~~retry; + this.Events.trigger("retry", `Retrying ${this.options.id} after ${retryAfter} ms`, eventInfo); + this.retryCount++; + return run(retryAfter); + } else { + this.doDone(eventInfo); + await free(this.options, eventInfo); + this._assertStatus("DONE"); + return this._reject(error); + } + } + } + + doDone(eventInfo) { + this._assertStatus("EXECUTING"); + this._states.next(this.options.id); + return this.Events.trigger("done", eventInfo); + } + + }; + + var Job_1 = Job; + + var BottleneckError$2, LocalDatastore, parser$2; + + parser$2 = parser; + + BottleneckError$2 = BottleneckError_1; + + LocalDatastore = class LocalDatastore { + constructor(instance, storeOptions, storeInstanceOptions) { + this.instance = instance; + this.storeOptions = storeOptions; + this.clientId = this.instance._randomIndex(); + parser$2.load(storeInstanceOptions, storeInstanceOptions, this); + this._nextRequest = this._lastReservoirRefresh = this._lastReservoirIncrease = Date.now(); + this._running = 0; + this._done = 0; + this._unblockTime = 0; + this.ready = this.Promise.resolve(); + this.clients = {}; + this._startHeartbeat(); + } + + _startHeartbeat() { + var base; + if ((this.heartbeat == null) && (((this.storeOptions.reservoirRefreshInterval != null) && (this.storeOptions.reservoirRefreshAmount != null)) || ((this.storeOptions.reservoirIncreaseInterval != null) && (this.storeOptions.reservoirIncreaseAmount != null)))) { + return typeof (base = (this.heartbeat = setInterval(() => { + var amount, incr, maximum, now, reservoir; + now = Date.now(); + if ((this.storeOptions.reservoirRefreshInterval != null) && now >= this._lastReservoirRefresh + this.storeOptions.reservoirRefreshInterval) { + this._lastReservoirRefresh = now; + this.storeOptions.reservoir = this.storeOptions.reservoirRefreshAmount; + this.instance._drainAll(this.computeCapacity()); + } + if ((this.storeOptions.reservoirIncreaseInterval != null) && now >= this._lastReservoirIncrease + this.storeOptions.reservoirIncreaseInterval) { + ({ + reservoirIncreaseAmount: amount, + reservoirIncreaseMaximum: maximum, + reservoir + } = this.storeOptions); + this._lastReservoirIncrease = now; + incr = maximum != null ? Math.min(amount, maximum - reservoir) : amount; + if (incr > 0) { + this.storeOptions.reservoir += incr; + return this.instance._drainAll(this.computeCapacity()); + } + } + }, this.heartbeatInterval))).unref === "function" ? base.unref() : void 0; + } else { + return clearInterval(this.heartbeat); + } + } + + async __publish__(message) { + await this.yieldLoop(); + return this.instance.Events.trigger("message", message.toString()); + } + + async __disconnect__(flush) { + await this.yieldLoop(); + clearInterval(this.heartbeat); + return this.Promise.resolve(); + } + + yieldLoop(t = 0) { + return new this.Promise(function(resolve, reject) { + return setTimeout(resolve, t); + }); + } + + computePenalty() { + var ref; + return (ref = this.storeOptions.penalty) != null ? ref : (15 * this.storeOptions.minTime) || 5000; + } + + async __updateSettings__(options) { + await this.yieldLoop(); + parser$2.overwrite(options, options, this.storeOptions); + this._startHeartbeat(); + this.instance._drainAll(this.computeCapacity()); + return true; + } + + async __running__() { + await this.yieldLoop(); + return this._running; + } + + async __queued__() { + await this.yieldLoop(); + return this.instance.queued(); + } + + async __done__() { + await this.yieldLoop(); + return this._done; + } + + async __groupCheck__(time) { + await this.yieldLoop(); + return (this._nextRequest + this.timeout) < time; + } + + computeCapacity() { + var maxConcurrent, reservoir; + ({maxConcurrent, reservoir} = this.storeOptions); + if ((maxConcurrent != null) && (reservoir != null)) { + return Math.min(maxConcurrent - this._running, reservoir); + } else if (maxConcurrent != null) { + return maxConcurrent - this._running; + } else if (reservoir != null) { + return reservoir; + } else { + return null; + } + } + + conditionsCheck(weight) { + var capacity; + capacity = this.computeCapacity(); + return (capacity == null) || weight <= capacity; + } + + async __incrementReservoir__(incr) { + var reservoir; + await this.yieldLoop(); + reservoir = this.storeOptions.reservoir += incr; + this.instance._drainAll(this.computeCapacity()); + return reservoir; + } + + async __currentReservoir__() { + await this.yieldLoop(); + return this.storeOptions.reservoir; + } + + isBlocked(now) { + return this._unblockTime >= now; + } + + check(weight, now) { + return this.conditionsCheck(weight) && (this._nextRequest - now) <= 0; + } + + async __check__(weight) { + var now; + await this.yieldLoop(); + now = Date.now(); + return this.check(weight, now); + } + + async __register__(index, weight, expiration) { + var now, wait; + await this.yieldLoop(); + now = Date.now(); + if (this.conditionsCheck(weight)) { + this._running += weight; + if (this.storeOptions.reservoir != null) { + this.storeOptions.reservoir -= weight; + } + wait = Math.max(this._nextRequest - now, 0); + this._nextRequest = now + wait + this.storeOptions.minTime; + return { + success: true, + wait, + reservoir: this.storeOptions.reservoir + }; + } else { + return { + success: false + }; + } + } + + strategyIsBlock() { + return this.storeOptions.strategy === 3; + } + + async __submit__(queueLength, weight) { + var blocked, now, reachedHWM; + await this.yieldLoop(); + if ((this.storeOptions.maxConcurrent != null) && weight > this.storeOptions.maxConcurrent) { + throw new BottleneckError$2(`Impossible to add a job having a weight of ${weight} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`); + } + now = Date.now(); + reachedHWM = (this.storeOptions.highWater != null) && queueLength === this.storeOptions.highWater && !this.check(weight, now); + blocked = this.strategyIsBlock() && (reachedHWM || this.isBlocked(now)); + if (blocked) { + this._unblockTime = now + this.computePenalty(); + this._nextRequest = this._unblockTime + this.storeOptions.minTime; + this.instance._dropAllQueued(); + } + return { + reachedHWM, + blocked, + strategy: this.storeOptions.strategy + }; + } + + async __free__(index, weight) { + await this.yieldLoop(); + this._running -= weight; + this._done += weight; + this.instance._drainAll(this.computeCapacity()); + return { + running: this._running + }; + } + + }; + + var LocalDatastore_1 = LocalDatastore; + + var BottleneckError$3, States; + + BottleneckError$3 = BottleneckError_1; + + States = class States { + constructor(status1) { + this.status = status1; + this._jobs = {}; + this.counts = this.status.map(function() { + return 0; + }); + } + + next(id) { + var current, next; + current = this._jobs[id]; + next = current + 1; + if ((current != null) && next < this.status.length) { + this.counts[current]--; + this.counts[next]++; + return this._jobs[id]++; + } else if (current != null) { + this.counts[current]--; + return delete this._jobs[id]; + } + } + + start(id) { + var initial; + initial = 0; + this._jobs[id] = initial; + return this.counts[initial]++; + } + + remove(id) { + var current; + current = this._jobs[id]; + if (current != null) { + this.counts[current]--; + delete this._jobs[id]; + } + return current != null; + } + + jobStatus(id) { + var ref; + return (ref = this.status[this._jobs[id]]) != null ? ref : null; + } + + statusJobs(status) { + var k, pos, ref, results, v; + if (status != null) { + pos = this.status.indexOf(status); + if (pos < 0) { + throw new BottleneckError$3(`status must be one of ${this.status.join(', ')}`); + } + ref = this._jobs; + results = []; + for (k in ref) { + v = ref[k]; + if (v === pos) { + results.push(k); + } + } + return results; + } else { + return Object.keys(this._jobs); + } + } + + statusCounts() { + return this.counts.reduce(((acc, v, i) => { + acc[this.status[i]] = v; + return acc; + }), {}); + } + + }; + + var States_1 = States; + + var DLList$2, Sync; + + DLList$2 = DLList_1; + + Sync = class Sync { + constructor(name, Promise) { + this.schedule = this.schedule.bind(this); + this.name = name; + this.Promise = Promise; + this._running = 0; + this._queue = new DLList$2(); + } + + isEmpty() { + return this._queue.length === 0; + } + + async _tryToRun() { + var args, cb, error, reject, resolve, returned, task; + if ((this._running < 1) && this._queue.length > 0) { + this._running++; + ({task, args, resolve, reject} = this._queue.shift()); + cb = (await (async function() { + try { + returned = (await task(...args)); + return function() { + return resolve(returned); + }; + } catch (error1) { + error = error1; + return function() { + return reject(error); + }; + } + })()); + this._running--; + this._tryToRun(); + return cb(); + } + } + + schedule(task, ...args) { + var promise, reject, resolve; + resolve = reject = null; + promise = new this.Promise(function(_resolve, _reject) { + resolve = _resolve; + return reject = _reject; + }); + this._queue.push({task, args, resolve, reject}); + this._tryToRun(); + return promise; + } + + }; + + var Sync_1 = Sync; + + var version = "2.19.5"; + var version$1 = { + version: version + }; + + var version$2 = /*#__PURE__*/Object.freeze({ + version: version, + default: version$1 + }); + + var require$$2 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$3 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$4 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var Events$2, Group, IORedisConnection$1, RedisConnection$1, Scripts$1, parser$3; + + parser$3 = parser; + + Events$2 = Events_1; + + RedisConnection$1 = require$$2; + + IORedisConnection$1 = require$$3; + + Scripts$1 = require$$4; + + Group = (function() { + class Group { + constructor(limiterOptions = {}) { + this.deleteKey = this.deleteKey.bind(this); + this.limiterOptions = limiterOptions; + parser$3.load(this.limiterOptions, this.defaults, this); + this.Events = new Events$2(this); + this.instances = {}; + this.Bottleneck = Bottleneck_1; + this._startAutoCleanup(); + this.sharedConnection = this.connection != null; + if (this.connection == null) { + if (this.limiterOptions.datastore === "redis") { + this.connection = new RedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } else if (this.limiterOptions.datastore === "ioredis") { + this.connection = new IORedisConnection$1(Object.assign({}, this.limiterOptions, {Events: this.Events})); + } + } + } + + key(key = "") { + var ref; + return (ref = this.instances[key]) != null ? ref : (() => { + var limiter; + limiter = this.instances[key] = new this.Bottleneck(Object.assign(this.limiterOptions, { + id: `${this.id}-${key}`, + timeout: this.timeout, + connection: this.connection + })); + this.Events.trigger("created", limiter, key); + return limiter; + })(); + } + + async deleteKey(key = "") { + var deleted, instance; + instance = this.instances[key]; + if (this.connection) { + deleted = (await this.connection.__runCommand__(['del', ...Scripts$1.allKeys(`${this.id}-${key}`)])); + } + if (instance != null) { + delete this.instances[key]; + await instance.disconnect(); + } + return (instance != null) || deleted > 0; + } + + limiters() { + var k, ref, results, v; + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + results.push({ + key: k, + limiter: v + }); + } + return results; + } + + keys() { + return Object.keys(this.instances); + } + + async clusterKeys() { + var cursor, end, found, i, k, keys, len, next, start; + if (this.connection == null) { + return this.Promise.resolve(this.keys()); + } + keys = []; + cursor = null; + start = `b_${this.id}-`.length; + end = "_settings".length; + while (cursor !== 0) { + [next, found] = (await this.connection.__runCommand__(["scan", cursor != null ? cursor : 0, "match", `b_${this.id}-*_settings`, "count", 10000])); + cursor = ~~next; + for (i = 0, len = found.length; i < len; i++) { + k = found[i]; + keys.push(k.slice(start, -end)); + } + } + return keys; + } + + _startAutoCleanup() { + var base; + clearInterval(this.interval); + return typeof (base = (this.interval = setInterval(async() => { + var e, k, ref, results, time, v; + time = Date.now(); + ref = this.instances; + results = []; + for (k in ref) { + v = ref[k]; + try { + if ((await v._store.__groupCheck__(time))) { + results.push(this.deleteKey(k)); + } else { + results.push(void 0); + } + } catch (error) { + e = error; + results.push(v.Events.trigger("error", e)); + } + } + return results; + }, this.timeout / 2))).unref === "function" ? base.unref() : void 0; + } + + updateSettings(options = {}) { + parser$3.overwrite(options, this.defaults, this); + parser$3.overwrite(options, options, this.limiterOptions); + if (options.timeout != null) { + return this._startAutoCleanup(); + } + } + + disconnect(flush = true) { + var ref; + if (!this.sharedConnection) { + return (ref = this.connection) != null ? ref.disconnect(flush) : void 0; + } + } + + } + Group.prototype.defaults = { + timeout: 1000 * 60 * 5, + connection: null, + Promise: Promise, + id: "group-key" + }; + + return Group; + + }).call(commonjsGlobal); + + var Group_1 = Group; + + var Batcher, Events$3, parser$4; + + parser$4 = parser; + + Events$3 = Events_1; + + Batcher = (function() { + class Batcher { + constructor(options = {}) { + this.options = options; + parser$4.load(this.options, this.defaults, this); + this.Events = new Events$3(this); + this._arr = []; + this._resetPromise(); + this._lastFlush = Date.now(); + } + + _resetPromise() { + return this._promise = new this.Promise((res, rej) => { + return this._resolve = res; + }); + } + + _flush() { + clearTimeout(this._timeout); + this._lastFlush = Date.now(); + this._resolve(); + this.Events.trigger("batch", this._arr); + this._arr = []; + return this._resetPromise(); + } + + add(data) { + var ret; + this._arr.push(data); + ret = this._promise; + if (this._arr.length === this.maxSize) { + this._flush(); + } else if ((this.maxTime != null) && this._arr.length === 1) { + this._timeout = setTimeout(() => { + return this._flush(); + }, this.maxTime); + } + return ret; + } + + } + Batcher.prototype.defaults = { + maxTime: null, + maxSize: null, + Promise: Promise + }; + + return Batcher; + + }).call(commonjsGlobal); + + var Batcher_1 = Batcher; + + var require$$4$1 = () => console.log('You must import the full version of Bottleneck in order to use this feature.'); + + var require$$8 = getCjsExportFromNamespace(version$2); + + var Bottleneck, DEFAULT_PRIORITY$1, Events$4, Job$1, LocalDatastore$1, NUM_PRIORITIES$1, Queues$1, RedisDatastore$1, States$1, Sync$1, parser$5, + splice = [].splice; + + NUM_PRIORITIES$1 = 10; + + DEFAULT_PRIORITY$1 = 5; + + parser$5 = parser; + + Queues$1 = Queues_1; + + Job$1 = Job_1; + + LocalDatastore$1 = LocalDatastore_1; + + RedisDatastore$1 = require$$4$1; + + Events$4 = Events_1; + + States$1 = States_1; + + Sync$1 = Sync_1; + + Bottleneck = (function() { + class Bottleneck { + constructor(options = {}, ...invalid) { + var storeInstanceOptions, storeOptions; + this._addToQueue = this._addToQueue.bind(this); + this._validateOptions(options, invalid); + parser$5.load(options, this.instanceDefaults, this); + this._queues = new Queues$1(NUM_PRIORITIES$1); + this._scheduled = {}; + this._states = new States$1(["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(this.trackDoneStatus ? ["DONE"] : [])); + this._limiter = null; + this.Events = new Events$4(this); + this._submitLock = new Sync$1("submit", this.Promise); + this._registerLock = new Sync$1("register", this.Promise); + storeOptions = parser$5.load(options, this.storeDefaults, {}); + this._store = (function() { + if (this.datastore === "redis" || this.datastore === "ioredis" || (this.connection != null)) { + storeInstanceOptions = parser$5.load(options, this.redisStoreDefaults, {}); + return new RedisDatastore$1(this, storeOptions, storeInstanceOptions); + } else if (this.datastore === "local") { + storeInstanceOptions = parser$5.load(options, this.localStoreDefaults, {}); + return new LocalDatastore$1(this, storeOptions, storeInstanceOptions); + } else { + throw new Bottleneck.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`); + } + }).call(this); + this._queues.on("leftzero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.ref === "function" ? ref.ref() : void 0 : void 0; + }); + this._queues.on("zero", () => { + var ref; + return (ref = this._store.heartbeat) != null ? typeof ref.unref === "function" ? ref.unref() : void 0 : void 0; + }); + } + + _validateOptions(options, invalid) { + if (!((options != null) && typeof options === "object" && invalid.length === 0)) { + throw new Bottleneck.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."); + } + } + + ready() { + return this._store.ready; + } + + clients() { + return this._store.clients; + } + + channel() { + return `b_${this.id}`; + } + + channel_client() { + return `b_${this.id}_${this._store.clientId}`; + } + + publish(message) { + return this._store.__publish__(message); + } + + disconnect(flush = true) { + return this._store.__disconnect__(flush); + } + + chain(_limiter) { + this._limiter = _limiter; + return this; + } + + queued(priority) { + return this._queues.queued(priority); + } + + clusterQueued() { + return this._store.__queued__(); + } + + empty() { + return this.queued() === 0 && this._submitLock.isEmpty(); + } + + running() { + return this._store.__running__(); + } + + done() { + return this._store.__done__(); + } + + jobStatus(id) { + return this._states.jobStatus(id); + } + + jobs(status) { + return this._states.statusJobs(status); + } + + counts() { + return this._states.statusCounts(); + } + + _randomIndex() { + return Math.random().toString(36).slice(2); + } + + check(weight = 1) { + return this._store.__check__(weight); + } + + _clearGlobalState(index) { + if (this._scheduled[index] != null) { + clearTimeout(this._scheduled[index].expiration); + delete this._scheduled[index]; + return true; + } else { + return false; + } + } + + async _free(index, job, options, eventInfo) { + var e, running; + try { + ({running} = (await this._store.__free__(index, options.weight))); + this.Events.trigger("debug", `Freed ${options.id}`, eventInfo); + if (running === 0 && this.empty()) { + return this.Events.trigger("idle"); + } + } catch (error1) { + e = error1; + return this.Events.trigger("error", e); + } + } + + _run(index, job, wait) { + var clearGlobalState, free, run; + job.doRun(); + clearGlobalState = this._clearGlobalState.bind(this, index); + run = this._run.bind(this, index, job); + free = this._free.bind(this, index, job); + return this._scheduled[index] = { + timeout: setTimeout(() => { + return job.doExecute(this._limiter, clearGlobalState, run, free); + }, wait), + expiration: job.options.expiration != null ? setTimeout(function() { + return job.doExpire(clearGlobalState, run, free); + }, wait + job.options.expiration) : void 0, + job: job + }; + } + + _drainOne(capacity) { + return this._registerLock.schedule(() => { + var args, index, next, options, queue; + if (this.queued() === 0) { + return this.Promise.resolve(null); + } + queue = this._queues.getFirst(); + ({options, args} = next = queue.first()); + if ((capacity != null) && options.weight > capacity) { + return this.Promise.resolve(null); + } + this.Events.trigger("debug", `Draining ${options.id}`, {args, options}); + index = this._randomIndex(); + return this._store.__register__(index, options.weight, options.expiration).then(({success, wait, reservoir}) => { + var empty; + this.Events.trigger("debug", `Drained ${options.id}`, {success, args, options}); + if (success) { + queue.shift(); + empty = this.empty(); + if (empty) { + this.Events.trigger("empty"); + } + if (reservoir === 0) { + this.Events.trigger("depleted", empty); + } + this._run(index, next, wait); + return this.Promise.resolve(options.weight); + } else { + return this.Promise.resolve(null); + } + }); + }); + } + + _drainAll(capacity, total = 0) { + return this._drainOne(capacity).then((drained) => { + var newCapacity; + if (drained != null) { + newCapacity = capacity != null ? capacity - drained : capacity; + return this._drainAll(newCapacity, total + drained); + } else { + return this.Promise.resolve(total); + } + }).catch((e) => { + return this.Events.trigger("error", e); + }); + } + + _dropAllQueued(message) { + return this._queues.shiftAll(function(job) { + return job.doDrop({message}); + }); + } + + stop(options = {}) { + var done, waitForExecuting; + options = parser$5.load(options, this.stopDefaults); + waitForExecuting = (at) => { + var finished; + finished = () => { + var counts; + counts = this._states.counts; + return (counts[0] + counts[1] + counts[2] + counts[3]) === at; + }; + return new this.Promise((resolve, reject) => { + if (finished()) { + return resolve(); + } else { + return this.on("done", () => { + if (finished()) { + this.removeAllListeners("done"); + return resolve(); + } + }); + } + }); + }; + done = options.dropWaitingJobs ? (this._run = function(index, next) { + return next.doDrop({ + message: options.dropErrorMessage + }); + }, this._drainOne = () => { + return this.Promise.resolve(null); + }, this._registerLock.schedule(() => { + return this._submitLock.schedule(() => { + var k, ref, v; + ref = this._scheduled; + for (k in ref) { + v = ref[k]; + if (this.jobStatus(v.job.options.id) === "RUNNING") { + clearTimeout(v.timeout); + clearTimeout(v.expiration); + v.job.doDrop({ + message: options.dropErrorMessage + }); + } + } + this._dropAllQueued(options.dropErrorMessage); + return waitForExecuting(0); + }); + })) : this.schedule({ + priority: NUM_PRIORITIES$1 - 1, + weight: 0 + }, () => { + return waitForExecuting(1); + }); + this._receive = function(job) { + return job._reject(new Bottleneck.prototype.BottleneckError(options.enqueueErrorMessage)); + }; + this.stop = () => { + return this.Promise.reject(new Bottleneck.prototype.BottleneckError("stop() has already been called")); + }; + return done; + } + + async _addToQueue(job) { + var args, blocked, error, options, reachedHWM, shifted, strategy; + ({args, options} = job); + try { + ({reachedHWM, blocked, strategy} = (await this._store.__submit__(this.queued(), options.weight))); + } catch (error1) { + error = error1; + this.Events.trigger("debug", `Could not queue ${options.id}`, {args, options, error}); + job.doDrop({error}); + return false; + } + if (blocked) { + job.doDrop(); + return true; + } else if (reachedHWM) { + shifted = strategy === Bottleneck.prototype.strategy.LEAK ? this._queues.shiftLastFrom(options.priority) : strategy === Bottleneck.prototype.strategy.OVERFLOW_PRIORITY ? this._queues.shiftLastFrom(options.priority + 1) : strategy === Bottleneck.prototype.strategy.OVERFLOW ? job : void 0; + if (shifted != null) { + shifted.doDrop(); + } + if ((shifted == null) || strategy === Bottleneck.prototype.strategy.OVERFLOW) { + if (shifted == null) { + job.doDrop(); + } + return reachedHWM; + } + } + job.doQueue(reachedHWM, blocked); + this._queues.push(job); + await this._drainAll(); + return reachedHWM; + } + + _receive(job) { + if (this._states.jobStatus(job.options.id) != null) { + job._reject(new Bottleneck.prototype.BottleneckError(`A job with the same id already exists (id=${job.options.id})`)); + return false; + } else { + job.doReceive(); + return this._submitLock.schedule(this._addToQueue, job); + } + } + + submit(...args) { + var cb, fn, job, options, ref, ref1, task; + if (typeof args[0] === "function") { + ref = args, [fn, ...args] = ref, [cb] = splice.call(args, -1); + options = parser$5.load({}, this.jobDefaults); + } else { + ref1 = args, [options, fn, ...args] = ref1, [cb] = splice.call(args, -1); + options = parser$5.load(options, this.jobDefaults); + } + task = (...args) => { + return new this.Promise(function(resolve, reject) { + return fn(...args, function(...args) { + return (args[0] != null ? reject : resolve)(args); + }); + }); + }; + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + job.promise.then(function(args) { + return typeof cb === "function" ? cb(...args) : void 0; + }).catch(function(args) { + if (Array.isArray(args)) { + return typeof cb === "function" ? cb(...args) : void 0; + } else { + return typeof cb === "function" ? cb(args) : void 0; + } + }); + return this._receive(job); + } + + schedule(...args) { + var job, options, task; + if (typeof args[0] === "function") { + [task, ...args] = args; + options = {}; + } else { + [options, task, ...args] = args; + } + job = new Job$1(task, args, options, this.jobDefaults, this.rejectOnDrop, this.Events, this._states, this.Promise); + this._receive(job); + return job.promise; + } + + wrap(fn) { + var schedule, wrapped; + schedule = this.schedule.bind(this); + wrapped = function(...args) { + return schedule(fn.bind(this), ...args); + }; + wrapped.withOptions = function(options, ...args) { + return schedule(options, fn, ...args); + }; + return wrapped; + } + + async updateSettings(options = {}) { + await this._store.__updateSettings__(parser$5.overwrite(options, this.storeDefaults)); + parser$5.overwrite(options, this.instanceDefaults, this); + return this; + } + + currentReservoir() { + return this._store.__currentReservoir__(); + } + + incrementReservoir(incr = 0) { + return this._store.__incrementReservoir__(incr); + } + + } + Bottleneck.default = Bottleneck; + + Bottleneck.Events = Events$4; + + Bottleneck.version = Bottleneck.prototype.version = require$$8.version; + + Bottleneck.strategy = Bottleneck.prototype.strategy = { + LEAK: 1, + OVERFLOW: 2, + OVERFLOW_PRIORITY: 4, + BLOCK: 3 + }; + + Bottleneck.BottleneckError = Bottleneck.prototype.BottleneckError = BottleneckError_1; + + Bottleneck.Group = Bottleneck.prototype.Group = Group_1; + + Bottleneck.RedisConnection = Bottleneck.prototype.RedisConnection = require$$2; + + Bottleneck.IORedisConnection = Bottleneck.prototype.IORedisConnection = require$$3; + + Bottleneck.Batcher = Bottleneck.prototype.Batcher = Batcher_1; + + Bottleneck.prototype.jobDefaults = { + priority: DEFAULT_PRIORITY$1, + weight: 1, + expiration: null, + id: "" + }; + + Bottleneck.prototype.storeDefaults = { + maxConcurrent: null, + minTime: 0, + highWater: null, + strategy: Bottleneck.prototype.strategy.LEAK, + penalty: null, + reservoir: null, + reservoirRefreshInterval: null, + reservoirRefreshAmount: null, + reservoirIncreaseInterval: null, + reservoirIncreaseAmount: null, + reservoirIncreaseMaximum: null + }; + + Bottleneck.prototype.localStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 250 + }; + + Bottleneck.prototype.redisStoreDefaults = { + Promise: Promise, + timeout: null, + heartbeatInterval: 5000, + clientTimeout: 10000, + Redis: null, + clientOptions: {}, + clusterNodes: null, + clearDatastore: false, + connection: null + }; + + Bottleneck.prototype.instanceDefaults = { + datastore: "local", + connection: null, + id: "", + rejectOnDrop: true, + trackDoneStatus: false, + Promise: Promise + }; + + Bottleneck.prototype.stopDefaults = { + enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs.", + dropWaitingJobs: true, + dropErrorMessage: "This limiter has been stopped." + }; + + return Bottleneck; + + }).call(commonjsGlobal); + + var Bottleneck_1 = Bottleneck; + + var lib = Bottleneck_1; + + return lib; + +}))); + + /***/ }), /***/ 8932: diff --git a/.github/actions/triggerWorkflowAndWait/triggerWorkflowAndWait.js b/.github/actions/triggerWorkflowAndWait/triggerWorkflowAndWait.js index 008f3b396ef2..91fc6fe774b5 100644 --- a/.github/actions/triggerWorkflowAndWait/triggerWorkflowAndWait.js +++ b/.github/actions/triggerWorkflowAndWait/triggerWorkflowAndWait.js @@ -1,6 +1,5 @@ const _ = require('underscore'); const core = require('@actions/core'); -const github = require('@actions/github'); const ActionUtils = require('../../libs/ActionUtils'); const GithubUtils = require('../../libs/GithubUtils'); const promiseWhile = require('../../libs/promiseWhile'); @@ -27,8 +26,6 @@ const WORKFLOW_COMPLETION_TIMEOUT = 7200000; const POLL_RATE = 10000; const run = function () { - const octokit = github.getOctokit(core.getInput('GITHUB_TOKEN', {required: true})); - const githubUtils = new GithubUtils(octokit); const workflow = core.getInput('WORKFLOW', {required: true}); const inputs = ActionUtils.getJSONInput('INPUTS', {required: false}, {}); @@ -50,13 +47,13 @@ const run = function () { let newWorkflowRunID; let hasNewWorkflowStarted = false; let workflowCompleted = false; - return githubUtils.getLatestWorkflowRunID(workflow) + return GithubUtils.getLatestWorkflowRunID(workflow) .then((lastWorkflowRunID) => { console.log(`Latest ${workflow} workflow run has ID: ${lastWorkflowRunID}`); previousWorkflowRunID = lastWorkflowRunID; console.log(`Dispatching workflow: ${workflow}`); - return octokit.actions.createWorkflowDispatch({ + return GithubUtils.octokit.actions.createWorkflowDispatch({ owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, workflow_id: workflow, @@ -79,7 +76,7 @@ const run = function () { _.throttle( () => { console.log(`\nšŸ¤š Waiting for a new ${workflow} workflow run to begin...`); - return githubUtils.getLatestWorkflowRunID(workflow) + return GithubUtils.getLatestWorkflowRunID(workflow) .then((lastWorkflowRunID) => { newWorkflowRunID = lastWorkflowRunID; hasNewWorkflowStarted = newWorkflowRunID !== previousWorkflowRunID; @@ -117,7 +114,7 @@ const run = function () { _.throttle( () => { console.log(`\nā³ Waiting for workflow run ${newWorkflowRunID} to finish...`); - return octokit.actions.getWorkflowRun({ + return GithubUtils.octokit.actions.getWorkflowRun({ owner: GithubUtils.GITHUB_OWNER, repo: GithubUtils.EXPENSIFY_CASH_REPO, run_id: newWorkflowRunID, diff --git a/tests/unit/GithubUtilsTest.js b/tests/unit/GithubUtilsTest.js index 0c914b3f42bf..c0eb6c15dd66 100644 --- a/tests/unit/GithubUtilsTest.js +++ b/tests/unit/GithubUtilsTest.js @@ -1,7 +1,6 @@ /** * @jest-environment node */ -const {Octokit} = require('@octokit/rest'); const GithubUtils = require('../../.github/libs/GithubUtils'); describe('GithubUtils', () => { @@ -81,8 +80,6 @@ describe('GithubUtils', () => { ]; test('Test finding an open issue with no PRs successfully', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); const bareIssue = { ...baseIssue, // eslint-disable-next-line max-len @@ -94,62 +91,50 @@ describe('GithubUtils', () => { PRList: [], }; - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [bareIssue]}); - return github.getStagingDeployCash().then(data => expect(data).toStrictEqual(bareExpectedResponse)); + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [bareIssue]}); + return GithubUtils.getStagingDeployCash().then(data => expect(data).toStrictEqual(bareExpectedResponse)); }); test('Test finding an open issue successfully', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [baseIssue]}); - return github.getStagingDeployCash().then(data => expect(data).toStrictEqual(baseExpectedResponse)); + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [baseIssue]}); + return GithubUtils.getStagingDeployCash().then(data => expect(data).toStrictEqual(baseExpectedResponse)); }); test('Test finding an open issue successfully and parsing with deploy blockers', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueWithDeployBlockers]}); - return github.getStagingDeployCash() + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueWithDeployBlockers]}); + return GithubUtils.getStagingDeployCash() .then(data => expect(data).toStrictEqual(expectedResponseWithDeployBlockers)); }); test('Test finding an open issue successfully and parsing with blockers w/o carriage returns', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - const modifiedIssueWithDeployBlockers = {...issueWithDeployBlockers}; modifiedIssueWithDeployBlockers.body = modifiedIssueWithDeployBlockers.body.replace(/\r/g, ''); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [modifiedIssueWithDeployBlockers]}); - return github.getStagingDeployCash() + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({ + data: [modifiedIssueWithDeployBlockers], + }); + return GithubUtils.getStagingDeployCash() .then(data => expect(data).toStrictEqual(expectedResponseWithDeployBlockers)); }); test('Test finding an open issue without a body', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - const noBodyIssue = baseIssue; noBodyIssue.body = ''; - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [noBodyIssue]}); - return github.getStagingDeployCash() + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [noBodyIssue]}); + return GithubUtils.getStagingDeployCash() .catch(e => expect(e).toEqual(new Error('Unable to find StagingDeployCash issue with correct data.'))); }); test('Test finding more than one issue', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [{a: 1}, {b: 2}]}); - return github.getStagingDeployCash() + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [{a: 1}, {b: 2}]}); + return GithubUtils.getStagingDeployCash() .catch(e => expect(e).toEqual(new Error('Found more than one StagingDeployCash issue.'))); }); test('Test finding no issues', () => { - const octokit = new Octokit(); - const github = new GithubUtils(octokit); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: []}); - return github.getStagingDeployCash() + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: []}); + return GithubUtils.getStagingDeployCash() .catch(e => expect(e).toEqual(new Error('Unable to find StagingDeployCash issue.'))); }); }); @@ -174,19 +159,17 @@ describe('GithubUtils', () => { body: '**Release Version:** `1.0.1-47`\r\n**Compare Changes:** https://github.com/Expensify/Expensify.cash/compare/production...staging\r\n\r\n**This release contains changes from the following pull requests:**\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/21\r\n- [x] https://github.com/Expensify/Expensify.cash/pull/22\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/23\r\n\r\n**Deploy Blockers:**\r\n- [ ] https://github.com/Expensify/Expensify.cash/issues/1\r\n- [x] https://github.com/Expensify/Expensify.cash/issues/2\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/1234\r\n', }; - const octokit = new Octokit(); - octokit.repos.listTags = jest.fn().mockResolvedValue({ + GithubUtils.octokit.repos.listTags = jest.fn().mockResolvedValue({ data: [ {name: '1.0.1-0'}, {name: '1.0.1-47'}, {name: '1.0.1-48'}, ], }); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueBefore]}); - octokit.issues.update = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - const githubUtils = new GithubUtils(octokit); + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueBefore]}); + GithubUtils.octokit.issues.update = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - return githubUtils.updateStagingDeployCash( + return GithubUtils.updateStagingDeployCash( '1.0.1-48', [ 'https://github.com/Expensify/Expensify.cash/pull/24', @@ -226,19 +209,17 @@ describe('GithubUtils', () => { body: '**Release Version:** `1.0.1-47`\r\n**Compare Changes:** https://github.com/Expensify/Expensify.cash/compare/production...staging\r\n\r\n**This release contains changes from the following pull requests:**\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/21\r\n- [x] https://github.com/Expensify/Expensify.cash/pull/22\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/23\r\n\r\n', }; - const octokit = new Octokit(); - octokit.repos.listTags = jest.fn().mockResolvedValue({ + GithubUtils.octokit.repos.listTags = jest.fn().mockResolvedValue({ data: [ {name: '1.0.1-0'}, {name: '1.0.1-47'}, {name: '1.0.1-48'}, ], }); - octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueBefore]}); - octokit.issues.update = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - const githubUtils = new GithubUtils(octokit); + GithubUtils.octokit.issues.listForRepo = jest.fn().mockResolvedValue({data: [issueBefore]}); + GithubUtils.octokit.issues.update = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - return githubUtils.updateStagingDeployCash( + return GithubUtils.updateStagingDeployCash( undefined, undefined, ['https://github.com/Expensify/Expensify.cash/pull/24', @@ -339,10 +320,8 @@ describe('GithubUtils', () => { }); describe('createNewStagingDeployCash', () => { - const octokit = new Octokit(); - octokit.repos.listTags = jest.fn().mockResolvedValue({data: [{name: '1.0.2-0'}]}); - octokit.issues.create = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - const githubUtils = new GithubUtils(octokit); + GithubUtils.octokit.repos.listTags = jest.fn().mockResolvedValue({data: [{name: '1.0.2-0'}]}); + GithubUtils.octokit.issues.create = jest.fn().mockImplementation(arg => Promise.resolve(arg)); const title = 'Test StagingDeployCash title'; const tag = '1.0.2-12'; @@ -354,7 +333,7 @@ describe('GithubUtils', () => { ]; test('Issue is successfully created', () => ( - githubUtils.createNewStagingDeployCash(title, tag, PRList) + GithubUtils.createNewStagingDeployCash(title, tag, PRList) .then((newIssue) => { expect(newIssue).toStrictEqual({ owner: GithubUtils.GITHUB_OWNER, @@ -409,8 +388,8 @@ describe('GithubUtils', () => { })); const octokit = mockGithub().getOctokit(); - const githubUtils = new GithubUtils(octokit); - + const githubUtils = class extends GithubUtils {}; + githubUtils.octokitInternal = octokit; const tag = '1.0.2-12'; const basePRList = [ 'https://github.com/Expensify/Expensify.cash/pull/2', From 8aeeef78592ca47deb34602569481538f4085205 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Sun, 16 May 2021 22:57:39 +0530 Subject: [PATCH 8/9] test refactor --- tests/unit/GithubUtilsTest.js | 21 ++++++++++++++++++++- tests/unit/checkDeployBlockersTest.js | 4 ++-- tests/unit/isPullRequestMergeableTest.js | 4 ++-- tests/unit/isStagingDeployLockedTest.js | 15 +++++---------- 4 files changed, 29 insertions(+), 15 deletions(-) diff --git a/tests/unit/GithubUtilsTest.js b/tests/unit/GithubUtilsTest.js index c0eb6c15dd66..cc9efe67574a 100644 --- a/tests/unit/GithubUtilsTest.js +++ b/tests/unit/GithubUtilsTest.js @@ -1,8 +1,27 @@ /** * @jest-environment node */ +const core = require('@actions/core'); +const {Octokit} = require('@octokit/rest'); const GithubUtils = require('../../.github/libs/GithubUtils'); +// Static mock function for core.getInput +const mockGetInput = jest.fn().mockImplementation((arg) => { + if (arg === 'GITHUB_TOKEN') { + return 'fake_token'; + } + + if (arg === 'ISSUE_NUMBER') { + return 1; + } +}); + +beforeAll(() => { + // Mock core module + core.getInput = mockGetInput; + GithubUtils.octokitInternal = new Octokit(); +}); + describe('GithubUtils', () => { describe('getStagingDeployCash', () => { const baseIssue = { @@ -388,7 +407,7 @@ describe('GithubUtils', () => { })); const octokit = mockGithub().getOctokit(); - const githubUtils = class extends GithubUtils {}; + const githubUtils = class extends GithubUtils { }; githubUtils.octokitInternal = octokit; const tag = '1.0.2-12'; const basePRList = [ diff --git a/tests/unit/checkDeployBlockersTest.js b/tests/unit/checkDeployBlockersTest.js index 97fa639b40cf..da61431d907f 100644 --- a/tests/unit/checkDeployBlockersTest.js +++ b/tests/unit/checkDeployBlockersTest.js @@ -2,7 +2,7 @@ * @jest-environment node */ const core = require('@actions/core'); -const github = require('@actions/github'); +const GithubUtils = require('../../.github/libs/GithubUtils'); const run = require('../../.github/actions/checkDeployBlockers/checkDeployBlockers'); // Static mock function for core.getInput @@ -32,7 +32,7 @@ beforeAll(() => { listComments: mockListComments, }, }; - github.getOctokit = jest.fn().mockImplementation(() => mocktokit); + GithubUtils.octokitInternal = mocktokit; }); afterEach(() => { diff --git a/tests/unit/isPullRequestMergeableTest.js b/tests/unit/isPullRequestMergeableTest.js index 653f58f7b4df..ea98dba2b818 100644 --- a/tests/unit/isPullRequestMergeableTest.js +++ b/tests/unit/isPullRequestMergeableTest.js @@ -1,6 +1,6 @@ const core = require('@actions/core'); -const github = require('@actions/github'); +const GithubUtils = require('../../.github/libs/GithubUtils'); const run = require('../../.github/actions/isPullRequestMergeable/isPullRequestMergeable'); // Static mock function for core.getInput @@ -31,7 +31,7 @@ beforeAll(() => { get: mockGetPullRequest, }, }; - github.getOctokit = jest.fn().mockImplementation(() => mocktokit); + GithubUtils.octokitInternal = mocktokit; }); afterEach(() => { diff --git a/tests/unit/isStagingDeployLockedTest.js b/tests/unit/isStagingDeployLockedTest.js index fb57b5c06bc7..1442dde5bdd6 100644 --- a/tests/unit/isStagingDeployLockedTest.js +++ b/tests/unit/isStagingDeployLockedTest.js @@ -1,6 +1,9 @@ const core = require('@actions/core'); const run = require('../../.github/actions/isStagingDeployLocked/isStagingDeployLocked'); +const GithubUtils = require('../../.github/libs/GithubUtils'); +// Mock the entire GitHubUtils module +jest.mock('../../.github/libs/GithubUtils'); beforeAll(() => { // Mock required GITHUB_TOKEN process.env.INPUT_GITHUB_TOKEN = 'fake_token'; @@ -16,19 +19,11 @@ afterAll(() => { delete process.env.INPUT_GITHUB_TOKEN; }); -// Our mock function that we can adjust in each test -let mockGetStagingDeployCash = jest.fn(); - -// Mock the entire GitHubUtils module -jest.mock('../../.github/libs/GithubUtils', () => jest.fn().mockImplementation(() => ({ - getStagingDeployCash: mockGetStagingDeployCash, -}))); - describe('isStagingDeployLockedTest', () => { describe('GitHub action run function', () => { test('Test returning empty result', () => { // Mock the return value of GitHubUtils.getStagingDeployCash() to return an empty object - mockGetStagingDeployCash = jest.fn().mockResolvedValue({}); + GithubUtils.getStagingDeployCash = jest.fn().mockResolvedValue({}); const setOutputMock = jest.spyOn(core, 'setOutput'); const isStagingDeployLocked = run(); return isStagingDeployLocked.then(() => { @@ -43,7 +38,7 @@ describe('isStagingDeployLockedTest', () => { }; // Mock the return value of GitHubUtils.getStagingDeployCash() to return the correct label - mockGetStagingDeployCash = jest.fn().mockResolvedValue(mockData); + GithubUtils.getStagingDeployCash = jest.fn().mockResolvedValue(mockData); const setOutputMock = jest.spyOn(core, 'setOutput'); const isStagingDeployLocked = run(); return isStagingDeployLocked.then(() => { From a1ada55f01485bce22af9eebeb28aab67f204602 Mon Sep 17 00:00:00 2001 From: Rajat Parashar Date: Mon, 17 May 2021 02:13:00 +0530 Subject: [PATCH 9/9] refactor github actions Tests --- tests/unit/GithubUtilsTest.js | 47 ++++++++++++----------------------- 1 file changed, 16 insertions(+), 31 deletions(-) diff --git a/tests/unit/GithubUtilsTest.js b/tests/unit/GithubUtilsTest.js index cc9efe67574a..d1764089845e 100644 --- a/tests/unit/GithubUtilsTest.js +++ b/tests/unit/GithubUtilsTest.js @@ -1,24 +1,10 @@ /** * @jest-environment node */ -const core = require('@actions/core'); const {Octokit} = require('@octokit/rest'); const GithubUtils = require('../../.github/libs/GithubUtils'); -// Static mock function for core.getInput -const mockGetInput = jest.fn().mockImplementation((arg) => { - if (arg === 'GITHUB_TOKEN') { - return 'fake_token'; - } - - if (arg === 'ISSUE_NUMBER') { - return 1; - } -}); - -beforeAll(() => { - // Mock core module - core.getInput = mockGetInput; +beforeEach(() => { GithubUtils.octokitInternal = new Octokit(); }); @@ -339,20 +325,19 @@ describe('GithubUtils', () => { }); describe('createNewStagingDeployCash', () => { - GithubUtils.octokit.repos.listTags = jest.fn().mockResolvedValue({data: [{name: '1.0.2-0'}]}); - GithubUtils.octokit.issues.create = jest.fn().mockImplementation(arg => Promise.resolve(arg)); - - const title = 'Test StagingDeployCash title'; - const tag = '1.0.2-12'; - const PRList = [ - 'https://github.com/Expensify/Expensify.cash/pull/2', - 'https://github.com/Expensify/Expensify.cash/pull/3', - 'https://github.com/Expensify/Expensify.cash/pull/3', - 'https://github.com/Expensify/Expensify.cash/pull/1', - ]; - - test('Issue is successfully created', () => ( - GithubUtils.createNewStagingDeployCash(title, tag, PRList) + test('Issue is successfully created', () => { + GithubUtils.octokit.repos.listTags = jest.fn().mockResolvedValue({data: [{name: '1.0.2-0'}]}); + GithubUtils.octokit.issues.create = jest.fn().mockImplementation(arg => Promise.resolve(arg)); + + const title = 'Test StagingDeployCash title'; + const tag = '1.0.2-12'; + const PRList = [ + 'https://github.com/Expensify/Expensify.cash/pull/2', + 'https://github.com/Expensify/Expensify.cash/pull/3', + 'https://github.com/Expensify/Expensify.cash/pull/3', + 'https://github.com/Expensify/Expensify.cash/pull/1', + ]; + return GithubUtils.createNewStagingDeployCash(title, tag, PRList) .then((newIssue) => { expect(newIssue).toStrictEqual({ owner: GithubUtils.GITHUB_OWNER, @@ -363,8 +348,8 @@ describe('GithubUtils', () => { // eslint-disable-next-line max-len body: `**Release Version:** \`${tag}\`\r\n**Compare Changes:** https://github.com/Expensify/Expensify.cash/compare/production...staging\r\n\r\n**This release contains changes from the following pull requests:**\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/1\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/2\r\n- [ ] https://github.com/Expensify/Expensify.cash/pull/3\r\n\r\ncc @Expensify/applauseleads\r\n`, }); - }) - )); + }); + }); }); describe('generateStagingDeployCashBody', () => {