From 08cc22105f092f556f463e9245a3427d319d4b13 Mon Sep 17 00:00:00 2001 From: Divy Srivastava Date: Fri, 31 Jan 2025 11:38:26 +0530 Subject: [PATCH 01/12] fix(ext/node): set process.env as own property (#27891) Fixes `gcp-metadata@6.1.1` ``` % deno eval "import 'npm:gcp-metadata@6.1.1'" # main error: Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'GOOGLE_SDK_NODE_LOGGING') at Object.log (file:///Users/divy/Library/Caches/deno/npm/registry.npmjs.org/google-logging-utils/0.0.2/build/src/logging-utils.js:356:36) at Object. (file:///Users/divy/Library/Caches/deno/npm/registry.npmjs.org/gcp-metadata/6.1.1/build/src/index.js:52:20) at Object. (file:///Users/divy/Library/Caches/deno/npm/registry.npmjs.org/gcp-metadata/6.1.1/build/src/index.js:409:4) at Module._compile (node:module:745:34) at loadMaybeCjs (node:module:770:10) at Object.Module._extensions..js (node:module:755:12) at Module.load (node:module:662:32) at Function.Module._load (node:module:534:12) at Module.require (node:module:681:19) at require (node:module:812:16) % target/debug/deno eval "import 'npm:gcp-metadata@6.1.1'" # this PR ``` --------- Signed-off-by: Divy Srivastava Co-authored-by: Yoshiya Hinosawa --- ext/node/polyfills/process.ts | 1 + tests/unit_node/process_test.ts | 2 ++ 2 files changed, 3 insertions(+) diff --git a/ext/node/polyfills/process.ts b/ext/node/polyfills/process.ts index e10f2d67d4..3e63b9a076 100644 --- a/ext/node/polyfills/process.ts +++ b/ext/node/polyfills/process.ts @@ -780,6 +780,7 @@ const process = new Process(); /* Set owned property */ process.versions = versions; +process.env = env; Object.defineProperty(process, Symbol.toStringTag, { enumerable: false, diff --git a/tests/unit_node/process_test.ts b/tests/unit_node/process_test.ts index 592bd6497f..fe6f43b3e5 100644 --- a/tests/unit_node/process_test.ts +++ b/tests/unit_node/process_test.ts @@ -390,6 +390,8 @@ Deno.test({ Deno.test({ name: "process.env", fn() { + assert(Object.prototype.hasOwnProperty.call(process, "env")); + Deno.env.set("HELLO", "WORLD"); assertObjectMatch(process.env, Deno.env.toObject()); From 057f257052ce23ffc437d9e71318d807ae789eca Mon Sep 17 00:00:00 2001 From: Divy Srivastava Date: Fri, 31 Jan 2025 17:53:48 +0530 Subject: [PATCH 02/12] fix(ext/node): represent sqlite blob as Uint8Array (#27889) --- ext/node/ops/sqlite/statement.rs | 8 ++++---- tests/unit_node/sqlite_test.ts | 11 ++++++++++- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/ext/node/ops/sqlite/statement.rs b/ext/node/ops/sqlite/statement.rs index eb121be5ea..90dc91dc13 100644 --- a/ext/node/ops/sqlite/statement.rs +++ b/ext/node/ops/sqlite/statement.rs @@ -155,10 +155,10 @@ impl StatementSync { let size = ffi::sqlite3_column_bytes(self.inner, index); let value = std::slice::from_raw_parts(value as *const u8, size as usize); - let value = - v8::ArrayBuffer::new_backing_store_from_vec(value.to_vec()) - .make_shared(); - v8::ArrayBuffer::with_backing_store(scope, &value).into() + let bs = v8::ArrayBuffer::new_backing_store_from_vec(value.to_vec()) + .make_shared(); + let ab = v8::ArrayBuffer::with_backing_store(scope, &bs); + v8::Uint8Array::new(scope, ab, 0, size as _).unwrap().into() } ffi::SQLITE_NULL => v8::null(scope).into(), _ => v8::undefined(scope).into(), diff --git a/tests/unit_node/sqlite_test.ts b/tests/unit_node/sqlite_test.ts index 6c71ea5346..eef0309e2e 100644 --- a/tests/unit_node/sqlite_test.ts +++ b/tests/unit_node/sqlite_test.ts @@ -1,6 +1,6 @@ // Copyright 2018-2025 the Deno authors. MIT license. import { DatabaseSync } from "node:sqlite"; -import { assertEquals, assertThrows } from "@std/assert"; +import { assert, assertEquals, assertThrows } from "@std/assert"; Deno.test("[node/sqlite] in-memory databases", () => { const db1 = new DatabaseSync(":memory:"); @@ -63,3 +63,12 @@ Deno.test("[node/sqlite] StatementSync read bigints are supported", () => { stmt.setReadBigInts(true); assertEquals(stmt.get(), { key: 1n, __proto__: null }); }); + +Deno.test("[node/sqlite] StatementSync blob are Uint8Array", () => { + const db = new DatabaseSync(":memory:"); + const obj = db.prepare("select cast('test' as blob)").all(); + + assertEquals(obj.length, 1); + const row = obj[0] as Record; + assert(row["cast('test' as blob)"] instanceof Uint8Array); +}); From 1cecc0a8b0229ec922727ea7ce6f71872a11bc51 Mon Sep 17 00:00:00 2001 From: Yoshiya Hinosawa Date: Fri, 31 Jan 2025 21:46:54 +0900 Subject: [PATCH 03/12] fix(ext/node): support proxy http request (#27871) --- ext/node/ops/http.rs | 20 +++++++++++++++----- ext/node/polyfills/http.ts | 10 ++++++++++ tests/unit_node/http_test.ts | 24 ++++++++++++++++++++++++ 3 files changed, 49 insertions(+), 5 deletions(-) diff --git a/ext/node/ops/http.rs b/ext/node/ops/http.rs index 57bcf69a47..1da630f97e 100644 --- a/ext/node/ops/http.rs +++ b/ext/node/ops/http.rs @@ -113,6 +113,9 @@ pub enum ConnError { #[error("Invalid URL {0}")] InvalidUrl(Url), #[class(type)] + #[error("Invalid Path {0}")] + InvalidPath(String), + #[class(type)] #[error(transparent)] InvalidHeaderName(#[from] http::header::InvalidHeaderName), #[class(type)] @@ -150,6 +153,7 @@ pub async fn op_node_http_request_with_conn

( state: Rc>, #[serde] method: ByteString, #[string] url: String, + #[string] request_path: Option, #[serde] headers: Vec<(ByteString, ByteString)>, #[smi] body: Option, #[smi] conn_rid: ResourceId, @@ -247,11 +251,17 @@ where *request.method_mut() = method.clone(); let path = url_parsed.path(); let query = url_parsed.query(); - *request.uri_mut() = query - .map(|q| format!("{}?{}", path, q)) - .unwrap_or_else(|| path.to_string()) - .parse() - .map_err(|_| ConnError::InvalidUrl(url_parsed.clone()))?; + if let Some(request_path) = request_path { + *request.uri_mut() = request_path + .parse() + .map_err(|_| ConnError::InvalidPath(request_path.clone()))?; + } else { + *request.uri_mut() = query + .map(|q| format!("{}?{}", path, q)) + .unwrap_or_else(|| path.to_string()) + .parse() + .map_err(|_| ConnError::InvalidUrl(url_parsed.clone()))?; + } *request.headers_mut() = header_map; if let Some((username, password)) = maybe_authority { diff --git a/ext/node/polyfills/http.ts b/ext/node/polyfills/http.ts index dd94c9d025..0438f9af22 100644 --- a/ext/node/polyfills/http.ts +++ b/ext/node/polyfills/http.ts @@ -479,6 +479,7 @@ class ClientRequest extends OutgoingMessage { this._req = await op_node_http_request_with_conn( this.method, url, + this._createRequestPath(), headers, this._bodyWriteRid, baseConnRid, @@ -817,6 +818,15 @@ class ClientRequest extends OutgoingMessage { return url.href; } + _createRequestPath(): string | undefined { + // If the path starts with protocol, pass this to op_node_http_request_with_conn + // This will be used as Request.uri in hyper for supporting http proxy + if (this.path?.startsWith("http://") || this.path?.startsWith("https://")) { + return this.path; + } + return undefined; + } + setTimeout(msecs: number, callback?: () => void) { if (msecs === 0) { if (this._timeout) { diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts index b4f0d260aa..54803ab995 100644 --- a/tests/unit_node/http_test.ts +++ b/tests/unit_node/http_test.ts @@ -1892,3 +1892,27 @@ Deno.test("[node/http] an error with DNS propagates to request object", async () }); await promise; }); + +Deno.test("[node/http] supports proxy http request", async () => { + const { promise, resolve } = Promise.withResolvers(); + const server = Deno.serve({ port: 0, onListen }, (req) => { + console.log("server received", req.url); + assertEquals(req.url, "http://example.com/"); + return new Response("ok"); + }); + + function onListen({ port }: { port: number }) { + http.request({ + host: "localhost", + port, + path: "http://example.com", + }, async (res) => { + assertEquals(res.statusCode, 200); + assertEquals(await text(res), "ok"); + resolve(); + server.shutdown(); + }).end(); + } + await promise; + await server.finished; +}); From b8a878cfc29499318d2458f8dbefe20e270731dc Mon Sep 17 00:00:00 2001 From: Divy Srivastava Date: Fri, 31 Jan 2025 18:29:37 +0530 Subject: [PATCH 04/12] fix(cli): Fix panic in `load_native_certs` (#27863) Fixes https://github.com/denoland/deno/issues/27528 Can't really trigger the panic myself hence no test. --- cli/lib/args.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cli/lib/args.rs b/cli/lib/args.rs index 22bebdf5d9..0a5f120e1f 100644 --- a/cli/lib/args.rs +++ b/cli/lib/args.rs @@ -60,6 +60,8 @@ pub enum RootCertStoreLoadError { FailedAddPemFile(String), #[error("Failed opening CA file: {0}")] CaFileOpenError(String), + #[error("Failed to load platform certificates: {0}")] + FailedNativeCerts(String), } /// Create and populate a root cert store based on the passed options and @@ -89,7 +91,9 @@ pub fn get_root_cert_store( root_cert_store.extend(webpki_roots::TLS_SERVER_ROOTS.to_vec()); } "system" => { - let roots = load_native_certs().expect("could not load platform certs"); + let roots = load_native_certs().map_err(|err| { + RootCertStoreLoadError::FailedNativeCerts(err.to_string()) + })?; for root in roots { if let Err(err) = root_cert_store .add(rustls::pki_types::CertificateDer::from(root.0.clone())) From 1cbaee9f52d9e204e1bb081f93a26c74d4ede7e0 Mon Sep 17 00:00:00 2001 From: Divy Srivastava Date: Fri, 31 Jan 2025 18:31:05 +0530 Subject: [PATCH 05/12] fix(ext/node): sqlite bind support bigint values (#27890) --- ext/node/ops/sqlite/statement.rs | 14 ++++++++++++++ tests/unit_node/sqlite_test.ts | 9 +++++++++ 2 files changed, 23 insertions(+) diff --git a/ext/node/ops/sqlite/statement.rs b/ext/node/ops/sqlite/statement.rs index 90dc91dc13..8f96d5131a 100644 --- a/ext/node/ops/sqlite/statement.rs +++ b/ext/node/ops/sqlite/statement.rs @@ -261,6 +261,20 @@ impl StatementSync { ffi::SQLITE_TRANSIENT(), ); } + } else if value.is_big_int() { + let value: v8::Local = value.try_into().unwrap(); + let (as_int, lossless) = value.i64_value(); + if !lossless { + return Err(SqliteError::FailedBind( + "BigInt value is too large to bind", + )); + } + + // SAFETY: `self.inner` is a valid pointer to a sqlite3_stmt + // as it lives as long as the StatementSync instance. + unsafe { + ffi::sqlite3_bind_int64(raw, i + 1, as_int); + } } else { return Err(SqliteError::FailedBind("Unsupported type")); } diff --git a/tests/unit_node/sqlite_test.ts b/tests/unit_node/sqlite_test.ts index eef0309e2e..04522083af 100644 --- a/tests/unit_node/sqlite_test.ts +++ b/tests/unit_node/sqlite_test.ts @@ -52,6 +52,15 @@ Deno.test( }, ); +Deno.test("[node/sqlite] StatementSync bind bigints", () => { + const db = new DatabaseSync(":memory:"); + db.exec("CREATE TABLE data(key INTEGER PRIMARY KEY);"); + + const stmt = db.prepare("INSERT INTO data (key) VALUES (?)"); + assertEquals(stmt.run(100n), { lastInsertRowid: 100, changes: 1 }); + db.close(); +}); + Deno.test("[node/sqlite] StatementSync read bigints are supported", () => { const db = new DatabaseSync(":memory:"); db.exec("CREATE TABLE data(key INTEGER PRIMARY KEY);"); From 7643bb71a6b20f6c917c75d05b9a3460019c1693 Mon Sep 17 00:00:00 2001 From: Yoshiya Hinosawa Date: Fri, 31 Jan 2025 22:52:32 +0900 Subject: [PATCH 06/12] chore: update std in test util (#27892) --- tests/specs/run/tls_connecttls/textproto.ts | 170 --- .../run/tls_connecttls/tls_connecttls.js | 4 +- tests/specs/run/tls_starttls/textproto.ts | 170 --- tests/specs/run/tls_starttls/tls_starttls.js | 5 +- tests/testdata/run/textproto.ts | 2 +- tests/unit/http_test.ts | 4 +- tests/unit/serve_test.ts | 4 +- tests/unit/test_util.ts | 1234 ++++++++++++++++- tests/unit/tls_test.ts | 3 +- tests/util/std | 2 +- 10 files changed, 1247 insertions(+), 351 deletions(-) delete mode 100644 tests/specs/run/tls_connecttls/textproto.ts delete mode 100644 tests/specs/run/tls_starttls/textproto.ts diff --git a/tests/specs/run/tls_connecttls/textproto.ts b/tests/specs/run/tls_connecttls/textproto.ts deleted file mode 100644 index 6b8ac92ecb..0000000000 --- a/tests/specs/run/tls_connecttls/textproto.ts +++ /dev/null @@ -1,170 +0,0 @@ -// Copyright 2018-2025 the Deno authors. MIT license. -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -/** **Deprecated**. Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - * - * A reader for dealing with low level text based protocols. - * - * Based on - * [net/textproto](https://github.com/golang/go/tree/master/src/net/textproto). - * - * @deprecated (will be removed after 0.159.0) Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - * @module - */ - -import type { BufReader, ReadLineResult } from "@std/io/buf-reader"; -import { concat } from "@std/bytes/concat"; - -// Constants created for DRY -const CHAR_SPACE: number = " ".charCodeAt(0); -const CHAR_TAB: number = "\t".charCodeAt(0); -const CHAR_COLON: number = ":".charCodeAt(0); - -const WHITESPACES: Array = [CHAR_SPACE, CHAR_TAB]; - -const decoder = new TextDecoder(); - -// FROM https://github.com/denoland/deno/blob/b34628a26ab0187a827aa4ebe256e23178e25d39/cli/js/web/headers.ts#L9 -const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g; - -function str(buf: Uint8Array | null | undefined): string { - return !buf ? "" : decoder.decode(buf); -} - -/** - * @deprecated (will be removed after 0.159.0) Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - */ -export class TextProtoReader { - constructor(readonly r: BufReader) {} - - /** readLine() reads a single line from the TextProtoReader, - * eliding the final \n or \r\n from the returned string. - */ - async readLine(): Promise { - const s = await this.readLineSlice(); - return s === null ? null : str(s); - } - - /** ReadMimeHeader reads a MIME-style header from r. - * The header is a sequence of possibly continued Key: Value lines - * ending in a blank line. - * The returned map m maps CanonicalMIMEHeaderKey(key) to a - * sequence of values in the same order encountered in the input. - * - * For example, consider this input: - * - * My-Key: Value 1 - * Long-Key: Even - * Longer Value - * My-Key: Value 2 - * - * Given that input, ReadMIMEHeader returns the map: - * - * map[string][]string{ - * "My-Key": {"Value 1", "Value 2"}, - * "Long-Key": {"Even Longer Value"}, - * } - */ - async readMimeHeader(): Promise { - const m = new Headers(); - let line: Uint8Array | undefined; - - // The first line cannot start with a leading space. - let buf = await this.r.peek(1); - if (buf === null) { - return null; - } else if (WHITESPACES.includes(buf[0])) { - line = (await this.readLineSlice()) as Uint8Array; - } - - buf = await this.r.peek(1); - if (buf === null) { - throw new Deno.errors.UnexpectedEof(); - } else if (WHITESPACES.includes(buf[0])) { - throw new Deno.errors.InvalidData( - `malformed MIME header initial line: ${str(line)}`, - ); - } - - while (true) { - const kv = await this.readLineSlice(); // readContinuedLineSlice - if (kv === null) throw new Deno.errors.UnexpectedEof(); - if (kv.byteLength === 0) return m; - - // Key ends at first colon - let i = kv.indexOf(CHAR_COLON); - if (i < 0) { - throw new Deno.errors.InvalidData( - `malformed MIME header line: ${str(kv)}`, - ); - } - - //let key = canonicalMIMEHeaderKey(kv.subarray(0, endKey)); - const key = str(kv.subarray(0, i)); - - // As per RFC 7230 field-name is a token, - // tokens consist of one or more chars. - // We could throw `Deno.errors.InvalidData` here, - // but better to be liberal in what we - // accept, so if we get an empty key, skip it. - if (key == "") { - continue; - } - - // Skip initial spaces in value. - i++; // skip colon - while ( - i < kv.byteLength && - (WHITESPACES.includes(kv[i])) - ) { - i++; - } - const value = str(kv.subarray(i)).replace( - invalidHeaderCharRegex, - encodeURI, - ); - - // In case of invalid header we swallow the error - // example: "Audio Mode" => invalid due to space in the key - try { - m.append(key, value); - } catch { - // Pass - } - } - } - - async readLineSlice(): Promise { - let line = new Uint8Array(0); - let r: ReadLineResult | null = null; - - do { - r = await this.r.readLine(); - // TODO(ry): - // This skipSpace() is definitely misplaced, but I don't know where it - // comes from nor how to fix it. - - //TODO(SmashingQuasar): Kept skipSpace to preserve behavior but it should be looked into to check if it makes sense when this is used. - - if (r !== null && this.skipSpace(r.line) !== 0) { - line = concat([line, r.line]); - } - } while (r !== null && r.more); - - return r === null ? null : line; - } - - skipSpace(l: Uint8Array): number { - let n = 0; - - for (const val of l) { - if (!WHITESPACES.includes(val)) { - n++; - } - } - - return n; - } -} diff --git a/tests/specs/run/tls_connecttls/tls_connecttls.js b/tests/specs/run/tls_connecttls/tls_connecttls.js index 686b13aea3..a417bd93b8 100644 --- a/tests/specs/run/tls_connecttls/tls_connecttls.js +++ b/tests/specs/run/tls_connecttls/tls_connecttls.js @@ -1,6 +1,6 @@ import { assert, assertEquals } from "@std/assert"; -import { BufReader, BufWriter } from "@std/io"; -import { TextProtoReader } from "./textproto.ts"; +import { BufReader, BufWriter } from "../../../unit/test_util.ts"; +import { TextProtoReader } from "../../../testdata/run/textproto.ts"; const encoder = new TextEncoder(); const decoder = new TextDecoder(); diff --git a/tests/specs/run/tls_starttls/textproto.ts b/tests/specs/run/tls_starttls/textproto.ts deleted file mode 100644 index 6b8ac92ecb..0000000000 --- a/tests/specs/run/tls_starttls/textproto.ts +++ /dev/null @@ -1,170 +0,0 @@ -// Copyright 2018-2025 the Deno authors. MIT license. -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -/** **Deprecated**. Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - * - * A reader for dealing with low level text based protocols. - * - * Based on - * [net/textproto](https://github.com/golang/go/tree/master/src/net/textproto). - * - * @deprecated (will be removed after 0.159.0) Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - * @module - */ - -import type { BufReader, ReadLineResult } from "@std/io/buf-reader"; -import { concat } from "@std/bytes/concat"; - -// Constants created for DRY -const CHAR_SPACE: number = " ".charCodeAt(0); -const CHAR_TAB: number = "\t".charCodeAt(0); -const CHAR_COLON: number = ":".charCodeAt(0); - -const WHITESPACES: Array = [CHAR_SPACE, CHAR_TAB]; - -const decoder = new TextDecoder(); - -// FROM https://github.com/denoland/deno/blob/b34628a26ab0187a827aa4ebe256e23178e25d39/cli/js/web/headers.ts#L9 -const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g; - -function str(buf: Uint8Array | null | undefined): string { - return !buf ? "" : decoder.decode(buf); -} - -/** - * @deprecated (will be removed after 0.159.0) Use `TextLineStream` from `std/steams` for line-by-line text reading instead. - */ -export class TextProtoReader { - constructor(readonly r: BufReader) {} - - /** readLine() reads a single line from the TextProtoReader, - * eliding the final \n or \r\n from the returned string. - */ - async readLine(): Promise { - const s = await this.readLineSlice(); - return s === null ? null : str(s); - } - - /** ReadMimeHeader reads a MIME-style header from r. - * The header is a sequence of possibly continued Key: Value lines - * ending in a blank line. - * The returned map m maps CanonicalMIMEHeaderKey(key) to a - * sequence of values in the same order encountered in the input. - * - * For example, consider this input: - * - * My-Key: Value 1 - * Long-Key: Even - * Longer Value - * My-Key: Value 2 - * - * Given that input, ReadMIMEHeader returns the map: - * - * map[string][]string{ - * "My-Key": {"Value 1", "Value 2"}, - * "Long-Key": {"Even Longer Value"}, - * } - */ - async readMimeHeader(): Promise { - const m = new Headers(); - let line: Uint8Array | undefined; - - // The first line cannot start with a leading space. - let buf = await this.r.peek(1); - if (buf === null) { - return null; - } else if (WHITESPACES.includes(buf[0])) { - line = (await this.readLineSlice()) as Uint8Array; - } - - buf = await this.r.peek(1); - if (buf === null) { - throw new Deno.errors.UnexpectedEof(); - } else if (WHITESPACES.includes(buf[0])) { - throw new Deno.errors.InvalidData( - `malformed MIME header initial line: ${str(line)}`, - ); - } - - while (true) { - const kv = await this.readLineSlice(); // readContinuedLineSlice - if (kv === null) throw new Deno.errors.UnexpectedEof(); - if (kv.byteLength === 0) return m; - - // Key ends at first colon - let i = kv.indexOf(CHAR_COLON); - if (i < 0) { - throw new Deno.errors.InvalidData( - `malformed MIME header line: ${str(kv)}`, - ); - } - - //let key = canonicalMIMEHeaderKey(kv.subarray(0, endKey)); - const key = str(kv.subarray(0, i)); - - // As per RFC 7230 field-name is a token, - // tokens consist of one or more chars. - // We could throw `Deno.errors.InvalidData` here, - // but better to be liberal in what we - // accept, so if we get an empty key, skip it. - if (key == "") { - continue; - } - - // Skip initial spaces in value. - i++; // skip colon - while ( - i < kv.byteLength && - (WHITESPACES.includes(kv[i])) - ) { - i++; - } - const value = str(kv.subarray(i)).replace( - invalidHeaderCharRegex, - encodeURI, - ); - - // In case of invalid header we swallow the error - // example: "Audio Mode" => invalid due to space in the key - try { - m.append(key, value); - } catch { - // Pass - } - } - } - - async readLineSlice(): Promise { - let line = new Uint8Array(0); - let r: ReadLineResult | null = null; - - do { - r = await this.r.readLine(); - // TODO(ry): - // This skipSpace() is definitely misplaced, but I don't know where it - // comes from nor how to fix it. - - //TODO(SmashingQuasar): Kept skipSpace to preserve behavior but it should be looked into to check if it makes sense when this is used. - - if (r !== null && this.skipSpace(r.line) !== 0) { - line = concat([line, r.line]); - } - } while (r !== null && r.more); - - return r === null ? null : line; - } - - skipSpace(l: Uint8Array): number { - let n = 0; - - for (const val of l) { - if (!WHITESPACES.includes(val)) { - n++; - } - } - - return n; - } -} diff --git a/tests/specs/run/tls_starttls/tls_starttls.js b/tests/specs/run/tls_starttls/tls_starttls.js index cd5718ff5a..5455096433 100644 --- a/tests/specs/run/tls_starttls/tls_starttls.js +++ b/tests/specs/run/tls_starttls/tls_starttls.js @@ -1,7 +1,6 @@ import { assert, assertEquals } from "@std/assert"; -import { BufReader } from "@std/io/buf-reader"; -import { BufWriter } from "@std/io/buf-writer"; -import { TextProtoReader } from "./textproto.ts"; +import { BufReader, BufWriter } from "../../../unit/test_util.ts"; +import { TextProtoReader } from "../../../testdata/run/textproto.ts"; const encoder = new TextEncoder(); const decoder = new TextDecoder(); diff --git a/tests/testdata/run/textproto.ts b/tests/testdata/run/textproto.ts index 6b8ac92ecb..1abe81e578 100644 --- a/tests/testdata/run/textproto.ts +++ b/tests/testdata/run/textproto.ts @@ -14,7 +14,7 @@ * @module */ -import type { BufReader, ReadLineResult } from "@std/io/buf-reader"; +import type { BufReader, ReadLineResult } from "../../unit/test_util.ts"; import { concat } from "@std/bytes/concat"; // Constants created for DRY diff --git a/tests/unit/http_test.ts b/tests/unit/http_test.ts index 809b36227b..05d72bd2ff 100644 --- a/tests/unit/http_test.ts +++ b/tests/unit/http_test.ts @@ -3,7 +3,7 @@ // deno-lint-ignore-file no-deprecated-deno-api -import { Buffer, BufReader, BufWriter, type Reader } from "@std/io"; +import { Buffer, type Reader } from "@std/io"; import { TextProtoReader } from "../testdata/run/textproto.ts"; import { assert, @@ -11,6 +11,8 @@ import { assertRejects, assertStrictEquals, assertThrows, + BufReader, + BufWriter, delay, fail, } from "./test_util.ts"; diff --git a/tests/unit/serve_test.ts b/tests/unit/serve_test.ts index 09616b0151..6373fbb3a7 100644 --- a/tests/unit/serve_test.ts +++ b/tests/unit/serve_test.ts @@ -3,13 +3,15 @@ // deno-lint-ignore-file no-console import { assertIsError, assertMatch, assertRejects } from "@std/assert"; -import { Buffer, BufReader, BufWriter, type Reader } from "@std/io"; +import { Buffer, type Reader } from "@std/io"; import { TextProtoReader } from "../testdata/run/textproto.ts"; import { assert, assertEquals, assertStringIncludes, assertThrows, + BufReader, + BufWriter, curlRequest, curlRequestWithStdErr, execCode, diff --git a/tests/unit/test_util.ts b/tests/unit/test_util.ts index 6e7865ea7a..9ddd4d9fb1 100644 --- a/tests/unit/test_util.ts +++ b/tests/unit/test_util.ts @@ -22,8 +22,9 @@ export { unreachable, } from "@std/assert"; export { delay } from "@std/async/delay"; -export { readLines } from "@std/io/read-lines"; export { parseArgs } from "@std/cli/parse-args"; +import { copy } from "@std/bytes/copy"; +import type { Reader, Writer, WriterSync } from "@std/io/types"; export function pathToAbsoluteFileUrl(path: string): URL { path = resolve(path); @@ -117,3 +118,1234 @@ export async function curlRequestWithStdErr(args: string[]) { ); return [decoder.decode(stdout), decoder.decode(stderr)]; } + +const DEFAULT_BUF_SIZE = 4096; +const MIN_BUF_SIZE = 16; +const MAX_CONSECUTIVE_EMPTY_READS = 100; +const CR = "\r".charCodeAt(0); +const LF = "\n".charCodeAt(0); + +/** + * Thrown when a write operation is attempted on a full buffer. + * + * @example Usage + * ```ts + * import { BufWriter, BufferFullError, Writer } from "@std/io"; + * import { assert, assertEquals } from "@std/assert"; + * + * const writer: Writer = { + * write(p: Uint8Array): Promise { + * throw new BufferFullError(p); + * } + * }; + * const bufWriter = new BufWriter(writer); + * try { + * await bufWriter.write(new Uint8Array([1, 2, 3])); + * } catch (err) { + * assert(err instanceof BufferFullError); + * assertEquals(err.partial, new Uint8Array([3])); + * } + * ``` + */ +export class BufferFullError extends Error { + /** + * The partially read bytes + * + * @example Usage + * ```ts + * import { BufferFullError } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const err = new BufferFullError(new Uint8Array(2)); + * assertEquals(err.partial, new Uint8Array(2)); + * ``` + */ + partial: Uint8Array; + + /** + * Construct a new instance. + * + * @param partial The bytes partially read + */ + constructor(partial: Uint8Array) { + super("Buffer full"); + this.name = this.constructor.name; + this.partial = partial; + } +} + +/** + * Thrown when a read from a stream fails to read the + * requested number of bytes. + * + * @example Usage + * ```ts + * import { PartialReadError } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const err = new PartialReadError(new Uint8Array(2)); + * assertEquals(err.name, "PartialReadError"); + * + * ``` + */ +export class PartialReadError extends Error { + /** + * The partially read bytes + * + * @example Usage + * ```ts + * import { PartialReadError } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const err = new PartialReadError(new Uint8Array(2)); + * assertEquals(err.partial, new Uint8Array(2)); + * ``` + */ + partial: Uint8Array; + + /** + * Construct a {@linkcode PartialReadError}. + * + * @param partial The bytes partially read + */ + constructor(partial: Uint8Array) { + super("Encountered UnexpectedEof, data only partially read"); + this.name = this.constructor.name; + this.partial = partial; + } +} + +/** + * Result type returned by of {@linkcode BufReader.readLine}. + */ +export interface ReadLineResult { + /** The line read */ + line: Uint8Array; + /** `true if the end of the line has not been reached, `false` otherwise. */ + more: boolean; +} + +/** + * Implements buffering for a {@linkcode Reader} object. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const encoder = new TextEncoder(); + * const decoder = new TextDecoder(); + * + * const reader = new BufReader(new Buffer(encoder.encode("hello world"))); + * const buf = new Uint8Array(11); + * await reader.read(buf); + * assertEquals(decoder.decode(buf), "hello world"); + * ``` + */ +export class BufReader implements Reader { + #buf!: Uint8Array; + #rd!: Reader; // Reader provided by caller. + #r = 0; // buf read position. + #w = 0; // buf write position. + #eof = false; + + /** + * Returns a new {@linkcode BufReader} if `r` is not already one. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assert } from "@std/assert/assert"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = BufReader.create(reader); + * assert(bufReader instanceof BufReader); + * ``` + * + * @param r The reader to read from. + * @param size The size of the buffer. + * @returns A new {@linkcode BufReader} if `r` is not already one. + */ + static create(r: Reader, size: number = DEFAULT_BUF_SIZE): BufReader { + return r instanceof BufReader ? r : new BufReader(r, size); + } + + /** + * Constructs a new {@linkcode BufReader} for the given reader and buffer size. + * + * @param rd The reader to read from. + * @param size The size of the buffer. + */ + constructor(rd: Reader, size: number = DEFAULT_BUF_SIZE) { + if (size < MIN_BUF_SIZE) { + size = MIN_BUF_SIZE; + } + this.#reset(new Uint8Array(size), rd); + } + + /** + * Returns the size of the underlying buffer in bytes. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * + * assertEquals(bufReader.size(), 4096); + * ``` + * + * @returns The size of the underlying buffer in bytes. + */ + size(): number { + return this.#buf.byteLength; + } + + /** + * Returns the number of bytes that can be read from the current buffer. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * await bufReader.read(new Uint8Array(5)); + * assertEquals(bufReader.buffered(), 6); + * ``` + * + * @returns Number of bytes that can be read from the buffer + */ + buffered(): number { + return this.#w - this.#r; + } + + // Reads a new chunk into the buffer. + #fill = async () => { + // Slide existing data to beginning. + if (this.#r > 0) { + this.#buf.copyWithin(0, this.#r, this.#w); + this.#w -= this.#r; + this.#r = 0; + } + + if (this.#w >= this.#buf.byteLength) { + throw new Error("Buffer full while filling"); + } + + // Read new data: try a limited number of times. + for (let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--) { + const rr = await this.#rd.read(this.#buf.subarray(this.#w)); + if (rr === null) { + this.#eof = true; + return; + } + this.#w += rr; + if (rr > 0) { + return; + } + } + + throw new Error( + `No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`, + ); + }; + + /** + * Discards any buffered data, resets all state, and switches + * the buffered reader to read from `r`. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * await bufReader.read(new Uint8Array(5)); + * bufReader.reset(reader); + * assertEquals(bufReader.buffered(), 6); + * ``` + * + * @param r The reader to read from. + */ + reset(r: Reader) { + this.#reset(this.#buf, r); + } + + #reset = (buf: Uint8Array, rd: Reader) => { + this.#buf = buf; + this.#rd = rd; + this.#eof = false; + // this.lastByte = -1; + // this.lastCharSize = -1; + }; + + /** + * Reads data into `p`. + * + * The bytes are taken from at most one `read()` on the underlying `Reader`, + * hence n may be less than `len(p)`. + * To read exactly `len(p)` bytes, use `io.ReadFull(b, p)`. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const buf = new Uint8Array(5); + * await bufReader.read(buf); + * assertEquals(new TextDecoder().decode(buf), "hello"); + * ``` + * + * @param p The buffer to read data into. + * @returns The number of bytes read into `p`. + */ + async read(p: Uint8Array): Promise { + let rr: number | null = p.byteLength; + if (p.byteLength === 0) return rr; + + if (this.#r === this.#w) { + if (p.byteLength >= this.#buf.byteLength) { + // Large read, empty buffer. + // Read directly into p to avoid copy. + const rr = await this.#rd.read(p); + // if (rr.nread > 0) { + // this.lastByte = p[rr.nread - 1]; + // this.lastCharSize = -1; + // } + return rr; + } + + // One read. + // Do not use this.fill, which will loop. + this.#r = 0; + this.#w = 0; + rr = await this.#rd.read(this.#buf); + if (rr === 0 || rr === null) return rr; + this.#w += rr; + } + + // copy as much as we can + const copied = copy(this.#buf.subarray(this.#r, this.#w), p, 0); + this.#r += copied; + // this.lastByte = this.buf[this.r - 1]; + // this.lastCharSize = -1; + return copied; + } + + /** + * Reads exactly `p.length` bytes into `p`. + * + * If successful, `p` is returned. + * + * If the end of the underlying stream has been reached, and there are no more + * bytes available in the buffer, `readFull()` returns `null` instead. + * + * An error is thrown if some bytes could be read, but not enough to fill `p` + * entirely before the underlying stream reported an error or EOF. Any error + * thrown will have a `partial` property that indicates the slice of the + * buffer that has been successfully filled with data. + * + * Ported from https://golang.org/pkg/io/#ReadFull + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const buf = new Uint8Array(5); + * await bufReader.readFull(buf); + * assertEquals(new TextDecoder().decode(buf), "hello"); + * ``` + * + * @param p The buffer to read data into. + * @returns The buffer `p` if the read is successful, `null` if the end of the + * underlying stream has been reached, and there are no more bytes available in the buffer. + */ + async readFull(p: Uint8Array): Promise { + let bytesRead = 0; + while (bytesRead < p.length) { + const rr = await this.read(p.subarray(bytesRead)); + if (rr === null) { + if (bytesRead === 0) { + return null; + } else { + throw new PartialReadError(p.subarray(0, bytesRead)); + } + } + bytesRead += rr; + } + return p; + } + + /** + * Returns the next byte ([0, 255]) or `null`. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const byte = await bufReader.readByte(); + * assertEquals(byte, 104); + * ``` + * + * @returns The next byte ([0, 255]) or `null`. + */ + async readByte(): Promise { + while (this.#r === this.#w) { + if (this.#eof) return null; + await this.#fill(); // buffer is empty. + } + const c = this.#buf[this.#r]!; + this.#r++; + // this.lastByte = c; + return c; + } + + /** + * Reads until the first occurrence of delim in the input, + * returning a string containing the data up to and including the delimiter. + * If ReadString encounters an error before finding a delimiter, + * it returns the data read before the error and the error itself + * (often `null`). + * ReadString returns err !== null if and only if the returned data does not end + * in delim. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const str = await bufReader.readString(" "); + * assertEquals(str, "hello "); + * + * const str2 = await bufReader.readString(" "); + * assertEquals(str2, "world"); + * ``` + * + * @param delim The delimiter to read until. + * @returns The string containing the data up to and including the delimiter. + */ + async readString(delim: string): Promise { + if (delim.length !== 1) { + throw new Error("Delimiter should be a single character"); + } + const buffer = await this.readSlice(delim.charCodeAt(0)); + if (buffer === null) return null; + return new TextDecoder().decode(buffer); + } + + /** + * A low-level line-reading primitive. Most callers should use + * `readString('\n')` instead. + * + * `readLine()` tries to return a single line, not including the end-of-line + * bytes. If the line was too long for the buffer then `more` is set and the + * beginning of the line is returned. The rest of the line will be returned + * from future calls. `more` will be false when returning the last fragment + * of the line. The returned buffer is only valid until the next call to + * `readLine()`. + * + * The text returned from this method does not include the line end ("\r\n" or + * "\n"). + * + * When the end of the underlying stream is reached, the final bytes in the + * stream are returned. No indication or error is given if the input ends + * without a final line end. When there are no more trailing bytes to read, + * `readLine()` returns `null`. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello\nworld")); + * const bufReader = new BufReader(reader); + * const line1 = await bufReader.readLine(); + * assertEquals(new TextDecoder().decode(line1!.line), "hello"); + * const line2 = await bufReader.readLine(); + * assertEquals(new TextDecoder().decode(line2!.line), "world"); + * ``` + * + * @returns The line read. + */ + async readLine(): Promise { + let line: Uint8Array | null = null; + + try { + line = await this.readSlice(LF); + } catch (err) { + // Don't throw if `readSlice()` failed with `BufferFullError`, instead we + // just return whatever is available and set the `more` flag. + if (!(err instanceof BufferFullError)) { + throw err; + } + + let partial = err.partial; + + // Handle the case where "\r\n" straddles the buffer. + if ( + !this.#eof && partial && + partial.byteLength > 0 && + partial[partial.byteLength - 1] === CR + ) { + // Put the '\r' back on buf and drop it from line. + // Let the next call to ReadLine check for "\r\n". + if (this.#r <= 0) { + throw new Error("Tried to rewind past start of buffer"); + } + this.#r--; + partial = partial.subarray(0, partial.byteLength - 1); + } + + if (partial) { + return { line: partial, more: !this.#eof }; + } + } + + if (line === null) { + return null; + } + + if (line.byteLength === 0) { + return { line, more: false }; + } + + if (line[line.byteLength - 1] === LF) { + let drop = 1; + if (line.byteLength > 1 && line[line.byteLength - 2] === CR) { + drop = 2; + } + line = line.subarray(0, line.byteLength - drop); + } + return { line, more: false }; + } + + /** + * Reads until the first occurrence of `delim` in the input, + * returning a slice pointing at the bytes in the buffer. The bytes stop + * being valid at the next read. + * + * If `readSlice()` encounters an error before finding a delimiter, or the + * buffer fills without finding a delimiter, it throws an error with a + * `partial` property that contains the entire buffer. + * + * If `readSlice()` encounters the end of the underlying stream and there are + * any bytes left in the buffer, the rest of the buffer is returned. In other + * words, EOF is always treated as a delimiter. Once the buffer is empty, + * it returns `null`. + * + * Because the data returned from `readSlice()` will be overwritten by the + * next I/O operation, most clients should use `readString()` instead. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const slice = await bufReader.readSlice(0x20); + * assertEquals(new TextDecoder().decode(slice!), "hello "); + * ``` + * + * @param delim The delimiter to read until. + * @returns A slice pointing at the bytes in the buffer. + */ + async readSlice(delim: number): Promise { + let s = 0; // search start index + let slice: Uint8Array | undefined; + + while (true) { + // Search buffer. + let i = this.#buf.subarray(this.#r + s, this.#w).indexOf(delim); + if (i >= 0) { + i += s; + slice = this.#buf.subarray(this.#r, this.#r + i + 1); + this.#r += i + 1; + break; + } + + // EOF? + if (this.#eof) { + if (this.#r === this.#w) { + return null; + } + slice = this.#buf.subarray(this.#r, this.#w); + this.#r = this.#w; + break; + } + + // Buffer full? + if (this.buffered() >= this.#buf.byteLength) { + this.#r = this.#w; + // #4521 The internal buffer should not be reused across reads because it causes corruption of data. + const oldbuf = this.#buf; + const newbuf = this.#buf.slice(0); + this.#buf = newbuf; + throw new BufferFullError(oldbuf); + } + + s = this.#w - this.#r; // do not rescan area we scanned before + + // Buffer is not full. + await this.#fill(); + } + + // Handle last byte, if any. + // const i = slice.byteLength - 1; + // if (i >= 0) { + // this.lastByte = slice[i]; + // this.lastCharSize = -1 + // } + + return slice; + } + + /** + * Returns the next `n` bytes without advancing the reader. The + * bytes stop being valid at the next read call. + * + * When the end of the underlying stream is reached, but there are unread + * bytes left in the buffer, those bytes are returned. If there are no bytes + * left in the buffer, it returns `null`. + * + * If an error is encountered before `n` bytes are available, `peek()` throws + * an error with the `partial` property set to a slice of the buffer that + * contains the bytes that were available before the error occurred. + * + * @example Usage + * ```ts + * import { BufReader, Buffer } from "@std/io"; + * import { assertEquals } from "@std/assert/equals"; + * + * const reader = new Buffer(new TextEncoder().encode("hello world")); + * const bufReader = new BufReader(reader); + * const peeked = await bufReader.peek(5); + * assertEquals(new TextDecoder().decode(peeked!), "hello"); + * ``` + * + * @param n The number of bytes to peek. + * @returns The next `n` bytes without advancing the reader. + */ + async peek(n: number): Promise { + if (n < 0) { + throw new Error("Peek count cannot be negative"); + } + + let avail = this.#w - this.#r; + while (avail < n && avail < this.#buf.byteLength && !this.#eof) { + await this.#fill(); + avail = this.#w - this.#r; + } + + if (avail === 0 && this.#eof) { + return null; + } else if (avail < n && this.#eof) { + return this.#buf.subarray(this.#r, this.#r + avail); + } else if (avail < n) { + throw new BufferFullError(this.#buf.subarray(this.#r, this.#w)); + } + + return this.#buf.subarray(this.#r, this.#r + n); + } +} + +/** + * AbstractBufBase is a base class which other classes can embed to + * implement the {@inkcode Reader} and {@linkcode Writer} interfaces. + * It provides basic implementations of those interfaces based on a buffer + * array. + * + * @example Usage + * ```ts no-assert + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { Reader } from "@std/io/types"; + * + * class MyBufReader extends AbstractBufBase { + * constructor(buf: Uint8Array) { + * super(buf); + * } + * } + * ``` + * + * @internal + */ +export abstract class AbstractBufBase { + /** + * The buffer + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.buf, buf); + * ``` + */ + buf: Uint8Array; + /** + * The used buffer bytes + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.usedBufferBytes, 0); + * ``` + */ + usedBufferBytes = 0; + /** + * The error + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.err, null); + * ``` + */ + err: Error | null = null; + + /** + * Construct a {@linkcode AbstractBufBase} instance + * + * @param buf The buffer to use. + */ + constructor(buf: Uint8Array) { + this.buf = buf; + } + + /** + * Size returns the size of the underlying buffer in bytes. + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.size(), 1024); + * ``` + * + * @return the size of the buffer in bytes. + */ + size(): number { + return this.buf.byteLength; + } + + /** + * Returns how many bytes are unused in the buffer. + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.available(), 1024); + * ``` + * + * @return the number of bytes that are unused in the buffer. + */ + available(): number { + return this.buf.byteLength - this.usedBufferBytes; + } + + /** + * buffered returns the number of bytes that have been written into the + * current buffer. + * + * @example Usage + * ```ts + * import { AbstractBufBase } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * class MyBuffer extends AbstractBufBase {} + * + * const buf = new Uint8Array(1024); + * const mb = new MyBuffer(buf); + * + * assertEquals(mb.buffered(), 0); + * ``` + * + * @return the number of bytes that have been written into the current buffer. + */ + buffered(): number { + return this.usedBufferBytes; + } +} + +/** + * `BufWriter` implements buffering for an {@linkcode Writer} object. + * If an error occurs writing to a Writer, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.Writer. + * + * @example Usage + * ```ts + * import { BufWriter } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer = { + * write(p: Uint8Array): Promise { + * return Promise.resolve(p.length); + * } + * }; + * + * const bufWriter = new BufWriter(writer); + * const data = new Uint8Array(1024); + * + * await bufWriter.write(data); + * await bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + */ +export class BufWriter extends AbstractBufBase implements Writer { + #writer: Writer; + + /** + * return new BufWriter unless writer is BufWriter + * + * @example Usage + * ```ts + * import { BufWriter } from "@std/io/buf-writer"; + * import { Writer } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: Writer = { + * write(p: Uint8Array): Promise { + * return Promise.resolve(p.length); + * } + * }; + * + * const bufWriter = BufWriter.create(writer); + * const data = new Uint8Array(1024); + * + * await bufWriter.write(data); + * + * assertEquals(bufWriter.buffered(), 1024); + * ``` + * + * @param writer The writer to wrap. + * @param size The size of the buffer. + * + * @return a new {@linkcode BufWriter} instance. + */ + static create(writer: Writer, size: number = DEFAULT_BUF_SIZE): BufWriter { + return writer instanceof BufWriter ? writer : new BufWriter(writer, size); + } + + /** + * Construct a new {@linkcode BufWriter} + * + * @param writer The writer to wrap. + * @param size The size of the buffer. + */ + constructor(writer: Writer, size: number = DEFAULT_BUF_SIZE) { + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + + /** + * Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + * + * @example Usage + * ```ts + * import { BufWriter } from "@std/io/buf-writer"; + * import { Writer } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: Writer = { + * write(p: Uint8Array): Promise { + * return Promise.resolve(p.length); + * } + * }; + * + * const bufWriter = new BufWriter(writer); + * const data = new Uint8Array(1024); + * + * await bufWriter.write(data); + * + * assertEquals(bufWriter.buffered(), 1024); + * + * bufWriter.reset(writer); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + * + * @param w The writer to write to. + */ + reset(w: Writer) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + + /** + * Flush writes any buffered data to the underlying io.Writer. + * + * @example Usage + * ```ts + * import { BufWriter } from "@std/io/buf-writer"; + * import { Writer } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: Writer = { + * write(p: Uint8Array): Promise { + * return Promise.resolve(p.length); + * } + * }; + * + * const bufWriter = new BufWriter(writer); + * const data = new Uint8Array(1024); + * + * await bufWriter.write(data); + * await bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + */ + async flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while (nwritten < p.length) { + nwritten += await this.#writer.write(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + + /** + * Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that are copied into the buffer will be flushed + * to the writer and the remaining bytes are then copied into the now empty buffer. + * + * @example Usage + * ```ts + * import { BufWriter } from "@std/io/buf-writer"; + * import { Writer } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: Writer = { + * write(p: Uint8Array): Promise { + * return Promise.resolve(p.length); + * } + * }; + * + * const bufWriter = new BufWriter(writer); + * const data = new Uint8Array(1024); + * + * await bufWriter.write(data); + * + * assertEquals(bufWriter.buffered(), 1024); + * ``` + * + * @param data The data to write to the buffer. + * @return the number of bytes written to the buffer. + */ + async write(data: Uint8Array): Promise { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + + let totalBytesWritten = 0; + let numBytesWritten = 0; + while (data.byteLength > this.available()) { + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = await this.#writer.write(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + await this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} + +/** + * BufWriterSync implements buffering for a deno.WriterSync object. + * If an error occurs writing to a WriterSync, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.WriterSync. + * + * @example Usage + * ```ts + * import { BufWriterSync } from "@std/io/buf-writer"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer = { + * writeSync(p: Uint8Array): number { + * return p.length; + * } + * }; + * + * const bufWriter = new BufWriterSync(writer); + * const data = new Uint8Array(1024); + * + * bufWriter.writeSync(data); + * bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + */ +export class BufWriterSync extends AbstractBufBase implements WriterSync { + #writer: WriterSync; + + /** + * return new BufWriterSync unless writer is BufWriterSync + * + * @example Usage + * ```ts + * import { BufWriterSync } from "@std/io/buf-writer"; + * import { WriterSync } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: WriterSync = { + * writeSync(p: Uint8Array): number { + * return p.length; + * } + * }; + * + * const bufWriter = BufWriterSync.create(writer); + * const data = new Uint8Array(1024); + * bufWriter.writeSync(data); + * bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + * + * @param writer The writer to wrap. + * @param size The size of the buffer. + * @returns a new {@linkcode BufWriterSync} instance. + */ + static create( + writer: WriterSync, + size: number = DEFAULT_BUF_SIZE, + ): BufWriterSync { + return writer instanceof BufWriterSync + ? writer + : new BufWriterSync(writer, size); + } + + /** + * Construct a new {@linkcode BufWriterSync} + * + * @param writer The writer to wrap. + * @param size The size of the buffer. + */ + constructor(writer: WriterSync, size: number = DEFAULT_BUF_SIZE) { + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + + /** + * Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + * + * @example Usage + * ```ts + * import { BufWriterSync } from "@std/io/buf-writer"; + * import { WriterSync } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: WriterSync = { + * writeSync(p: Uint8Array): number { + * return p.length; + * } + * }; + * + * const bufWriter = new BufWriterSync(writer); + * const data = new Uint8Array(1024); + * + * bufWriter.writeSync(data); + * bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + * + * @param w The writer to write to. + */ + reset(w: WriterSync) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + + /** + * Flush writes any buffered data to the underlying io.WriterSync. + * + * @example Usage + * ```ts + * import { BufWriterSync } from "@std/io/buf-writer"; + * import { WriterSync } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: WriterSync = { + * writeSync(p: Uint8Array): number { + * return p.length; + * } + * }; + * + * const bufWriter = new BufWriterSync(writer); + * const data = new Uint8Array(1024); + * + * bufWriter.writeSync(data); + * bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + */ + flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while (nwritten < p.length) { + nwritten += this.#writer.writeSync(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + + /** Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that can are copied into the buffer, the + * buffer is the flushed to the writer and the remaining bytes are copied into + * the now empty buffer. + * + * @example Usage + * ```ts + * import { BufWriterSync } from "@std/io/buf-writer"; + * import { WriterSync } from "@std/io/types"; + * import { assertEquals } from "@std/assert/equals"; + * + * const writer: WriterSync = { + * writeSync(p: Uint8Array): number { + * return p.length; + * } + * }; + * + * const bufWriter = new BufWriterSync(writer); + * const data = new Uint8Array(1024); + * + * bufWriter.writeSync(data); + * bufWriter.flush(); + * + * assertEquals(bufWriter.buffered(), 0); + * ``` + * + * @param data The data to write to the buffer. + * @return the number of bytes written to the buffer. + */ + writeSync(data: Uint8Array): number { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + + let totalBytesWritten = 0; + let numBytesWritten = 0; + while (data.byteLength > this.available()) { + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = this.#writer.writeSync(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} diff --git a/tests/unit/tls_test.ts b/tests/unit/tls_test.ts index 53db347a13..7a596c5430 100644 --- a/tests/unit/tls_test.ts +++ b/tests/unit/tls_test.ts @@ -6,8 +6,9 @@ import { assertRejects, assertStrictEquals, assertThrows, + BufReader, + BufWriter, } from "./test_util.ts"; -import { BufReader, BufWriter } from "@std/io"; import { readAll } from "@std/io/read-all"; import { writeAll } from "@std/io/write-all"; import { TextProtoReader } from "../testdata/run/textproto.ts"; diff --git a/tests/util/std b/tests/util/std index c5d7930d57..1f032bb7e1 160000 --- a/tests/util/std +++ b/tests/util/std @@ -1 +1 @@ -Subproject commit c5d7930d5700dbbbedea607f9cf3e50acdc33e2d +Subproject commit 1f032bb7e112ea572ce9df5d83675220d331079e From d5c105b30e2e0b05f17ccd2daf30c4edb42435a6 Mon Sep 17 00:00:00 2001 From: David Sherret Date: Fri, 31 Jan 2025 12:08:29 -0500 Subject: [PATCH 07/12] chore: fix some broken pty tests on windows (#27899) These have been failing locally for some time. --- tests/integration/run_tests.rs | 54 ++++++++++++++++++++++------------ 1 file changed, 36 insertions(+), 18 deletions(-) diff --git a/tests/integration/run_tests.rs b/tests/integration/run_tests.rs index 5485c6e4eb..b127ddfd27 100644 --- a/tests/integration/run_tests.rs +++ b/tests/integration/run_tests.rs @@ -250,7 +250,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all run access."); + console.expect("Granted all run access."); // "read" permissions console.expect(concat!( "┏ ⚠️ Deno requests read access to \"FOO\".\r\n", @@ -262,7 +262,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all read access."); + console.expect("Granted all read access."); // "write" permissions console.expect(concat!( "┏ ⚠️ Deno requests write access to \"FOO\".\r\n", @@ -274,7 +274,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all write access."); + console.expect("Granted all write access."); // "net" permissions console.expect(concat!( "┏ ⚠️ Deno requests net access to \"foo\".\r\n", @@ -286,7 +286,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all net access."); + console.expect("Granted all net access."); // "env" permissions console.expect(concat!( "┏ ⚠️ Deno requests env access to \"FOO\".\r\n", @@ -298,7 +298,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all env access."); + console.expect("Granted all env access."); // "sys" permissions console.expect(concat!( "┏ ⚠️ Deno requests sys access to \"loadavg\".\r\n", @@ -310,7 +310,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all sys access."); + console.expect("Granted all sys access."); // "ffi" permissions console.expect(concat!( "┏ ⚠️ Deno requests ffi access to \"FOO\".\r\n", @@ -322,7 +322,7 @@ fn permissions_prompt_allow_all() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all ffi access.") + console.expect("Granted all ffi access.") }, ); } @@ -343,7 +343,7 @@ fn permissions_prompt_allow_all_2() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all env access."); + console.expect("Granted all env access."); // "sys" permissions console.expect(concat!( @@ -356,7 +356,7 @@ fn permissions_prompt_allow_all_2() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all sys access."); + console.expect("Granted all sys access."); let text = console.read_until("Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions)"); // "read" permissions @@ -371,7 +371,7 @@ fn permissions_prompt_allow_all_2() { )); console.human_delay(); console.write_line_raw("A"); - console.expect("✅ Granted all read access."); + console.expect("Granted all read access."); }); } @@ -427,7 +427,7 @@ fn permissions_cache() { )); console.human_delay(); console.write_line_raw("y"); - console.expect("✅ Granted read access to \"foo\"."); + console.expect("Granted read access to \"foo\"."); console.expect("granted"); console.expect("prompt"); }); @@ -455,7 +455,7 @@ fn permissions_trace() { console.human_delay(); console.write_line_raw("y"); - console.expect("✅ Granted sys access to \"hostname\"."); + console.expect("Granted sys access to \"hostname\"."); }); } @@ -2762,20 +2762,38 @@ fn stdio_streams_are_locked_in_permission_prompt() { // The worker is blocked, so nothing else should get written here console.human_delay(); console.write_line_raw("i"); - // We ensure that nothing gets written here between the permission prompt and this text, despire the delay + // We ensure that nothing gets written here between the permission prompt and this text, despite the delay let newline = if cfg!(target_os = "linux") { "^J" } else { "\r\n" }; - console.expect_raw_next(format!("i{newline}\u{1b}[1A\u{1b}[0J┗ Unrecognized option. Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) > ")); - console.human_delay(); - console.write_line_raw("y"); - // We ensure that nothing gets written here between the permission prompt and this text, despire the delay - console.expect_raw_next(format!("y{newline}\x1b[6A\x1b[0J✅ Granted read access to \"")); + if cfg!(windows) { + // it's too difficult to inspect the raw text on windows because the console + // outputs a bunch of control characters, so we instead rely on the last assertion + // in this test that checks to ensure we didn't receive any malicious output during + // the permission prompts + console.expect("Unrecognized option. Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) >"); + console.human_delay(); + console.write_line_raw("y"); + console.expect("Granted read access to"); + } else { + console.expect_raw_next(format!("i{newline}\u{1b}[1A\u{1b}[0J┗ Unrecognized option. Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all read permissions) > ")); + console.human_delay(); + console.write_line_raw("y"); + // We ensure that nothing gets written here between the permission prompt and this text, despite the delay + console.expect_raw_next(format!("y{newline}\x1b[6A\x1b[0J✅ Granted read access to \"")); + } // Back to spamming! console.expect(malicious_output); + + // Ensure during the permission prompt showing we didn't receive any malicious output + let all_text = console.all_output(); + let start_prompt_index = all_text.find("Allow?").unwrap(); + let end_prompt_index = all_text.find("Granted read access to").unwrap(); + let prompt_text = &all_text[start_prompt_index..end_prompt_index]; + assert!(!prompt_text.contains(malicious_output), "Prompt text: {:?}", prompt_text); }); } From 1ef341c3973eed7f285f15e61c91757f748a45f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 31 Jan 2025 20:02:24 +0100 Subject: [PATCH 08/12] ci: update release template (#27901) --- tools/release/release_doc_template.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/release/release_doc_template.md b/tools/release/release_doc_template.md index b372185337..2a82b5b22b 100644 --- a/tools/release/release_doc_template.md +++ b/tools/release/release_doc_template.md @@ -122,7 +122,7 @@ verify on GitHub that everything looks correct. - ⛔ Verify that: - [ ] There are 24 assets on the [GitHub release draft](https://github.com/denoland/deno/releases/v$VERSION). - - [ ] There are 10 zip files for this version on + - [ ] There are 20 zip files for this version on [dl.deno.land](https://console.cloud.google.com/storage/browser/dl.deno.land/release/v$VERSION). - [ ] Publish the release on Github From 8d824182be8ec54ce76c84f18943dcfbb3734bdb Mon Sep 17 00:00:00 2001 From: Timothy <1695613+timothyis@users.noreply.github.com> Date: Fri, 31 Jan 2025 20:23:38 +0000 Subject: [PATCH 09/12] docs: Temporal plaintime docs link (#27879) --- cli/tsc/dts/lib.deno.unstable.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/tsc/dts/lib.deno.unstable.d.ts b/cli/tsc/dts/lib.deno.unstable.d.ts index bd32845a6a..4c47ad003c 100644 --- a/cli/tsc/dts/lib.deno.unstable.d.ts +++ b/cli/tsc/dts/lib.deno.unstable.d.ts @@ -2605,7 +2605,7 @@ declare namespace Temporal { * `Temporal.PlainDateTime` by combining it with a `Temporal.PlainDate` using the * `toPlainDateTime()` method. * - * See https://tc39.es/proposal-temporal/docs/time.html for more details. + * See https://tc39.es/proposal-temporal/docs/plaintime.html for more details. * * @category Temporal * @experimental From 897106454645b987f47cea0e62389f062ff33833 Mon Sep 17 00:00:00 2001 From: David Sherret Date: Fri, 31 Jan 2025 16:07:42 -0500 Subject: [PATCH 10/12] feat: TypeScript 5.7 (#27857) Co-authored-by: Kenta Moriuchi --- Cargo.lock | 1 + cli/build.rs | 44 +- cli/lib/version.rs | 2 +- cli/lsp/tsc.rs | 18 +- cli/npm/installer/resolution.rs | 2 +- cli/snapshot/shared.rs | 2 +- cli/tsc/00_typescript.js | 22152 ++++------------ cli/tsc/97_ts_host.js | 163 +- cli/tsc/dts/lib.decorators.d.ts | 28 +- cli/tsc/dts/lib.deno.ns.d.ts | 24 +- cli/tsc/dts/lib.deno.unstable.d.ts | 369 +- cli/tsc/dts/lib.dom.d.ts | 1336 +- cli/tsc/dts/lib.es2015.core.d.ts | 18 +- cli/tsc/dts/lib.es2015.iterable.d.ts | 117 +- cli/tsc/dts/lib.es2015.symbol.wellknown.d.ts | 20 +- cli/tsc/dts/lib.es2016.array.include.d.ts | 18 +- cli/tsc/dts/lib.es2016.intl.d.ts | 2 +- cli/tsc/dts/lib.es2017.arraybuffer.d.ts | 21 + cli/tsc/dts/lib.es2017.d.ts | 5 +- cli/tsc/dts/lib.es2017.sharedmemory.d.ts | 28 +- cli/tsc/dts/lib.es2017.typedarrays.d.ts | 18 +- cli/tsc/dts/lib.es2020.bigint.d.ts | 104 +- cli/tsc/dts/lib.es2020.intl.d.ts | 72 +- cli/tsc/dts/lib.es2020.sharedmemory.d.ts | 24 +- cli/tsc/dts/lib.es2020.string.d.ts | 2 + cli/tsc/dts/lib.es2021.intl.d.ts | 34 +- cli/tsc/dts/lib.es2021.weakref.d.ts | 2 + cli/tsc/dts/lib.es2022.array.d.ts | 22 +- cli/tsc/dts/lib.es2022.d.ts | 3 +- cli/tsc/dts/lib.es2022.error.d.ts | 2 + cli/tsc/dts/lib.es2022.intl.d.ts | 18 +- cli/tsc/dts/lib.es2023.array.d.ts | 198 +- cli/tsc/dts/lib.es2024.arraybuffer.d.ts | 65 + cli/tsc/dts/lib.es2024.collection.d.ts | 29 + cli/tsc/dts/lib.es2024.d.ts | 26 + cli/tsc/dts/lib.es2024.full.d.ts | 24 + ...ext.object.d.ts => lib.es2024.object.d.ts} | 0 ...t.promise.d.ts => lib.es2024.promise.d.ts} | 0 ...ext.regexp.d.ts => lib.es2024.regexp.d.ts} | 0 ...mory.d.ts => lib.es2024.sharedmemory.d.ts} | 29 + ...ext.string.d.ts => lib.es2024.string.d.ts} | 0 cli/tsc/dts/lib.es5.d.ts | 504 +- cli/tsc/dts/lib.esnext.array.d.ts | 2 +- cli/tsc/dts/lib.esnext.collection.d.ts | 12 +- cli/tsc/dts/lib.esnext.d.ts | 6 +- cli/tsc/dts/lib.webworker.d.ts | 344 +- cli/tsc/dts/typescript.d.ts | 3594 +-- ext/net/lib.deno_net.d.ts | 12 +- ext/url/lib.deno_url.d.ts | 22 +- tests/integration/cache_tests.rs | 6 +- .../registry/npm/@babel/parser/registry.json | 1 - .../registry/npm/@isaacs/cliui/registry.json | 3 +- .../registry.json | 3 +- .../registry/npm/@npmcli/agent/registry.json | 3 +- tests/registry/npm/@npmcli/fs/registry.json | 3 +- .../npm/@opentelemetry/api/registry.json | 3 +- .../npm/@pkgjs/parseargs/registry.json | 3 +- .../npm/@types/lz-string/registry.json | 3 +- .../npm/@types/node/node-18.16.19.tgz | Bin 677084 -> 0 bytes .../registry/npm/@types/node/node-18.8.2.tgz | Bin 649087 -> 0 bytes .../registry/npm/@types/node/node-22.12.0.tgz | Bin 0 -> 422084 bytes .../registry/npm/@types/node/node-22.5.4.tgz | Bin 404125 -> 0 bytes tests/registry/npm/@types/node/registry.json | 122 +- .../npm/@types/prop-types/registry.json | 3 +- tests/registry/npm/@types/react/registry.json | 3 +- .../npm/@vue/compiler-core/registry.json | 3 +- .../npm/@vue/compiler-dom/registry.json | 3 +- .../npm/@vue/compiler-sfc/registry.json | 3 +- .../npm/@vue/compiler-ssr/registry.json | 3 +- .../@vue/reactivity-transform/registry.json | 3 +- .../npm/@vue/reactivity/registry.json | 3 +- .../npm/@vue/runtime-core/registry.json | 3 +- .../npm/@vue/runtime-dom/registry.json | 3 +- .../npm/@vue/server-renderer/registry.json | 3 +- tests/registry/npm/@vue/shared/registry.json | 3 +- tests/registry/npm/abbrev/registry.json | 3 +- tests/registry/npm/agent-base/registry.json | 3 +- .../npm/aggregate-error/registry.json | 3 +- tests/registry/npm/ajv-formats/registry.json | 3 +- tests/registry/npm/ajv/registry.json | 3 +- tests/registry/npm/ansi-regex/registry.json | 3 +- tests/registry/npm/ansi-styles/registry.json | 3 +- tests/registry/npm/asn1/registry.json | 1 - .../npm/assertion-error/registry.json | 3 +- .../registry/npm/balanced-match/registry.json | 3 +- tests/registry/npm/bcrypt-pbkdf/registry.json | 1 - .../npm/brace-expansion/registry.json | 3 +- tests/registry/npm/bufferutil/registry.json | 3 +- tests/registry/npm/buildcheck/registry.json | 3 +- tests/registry/npm/cacache/registry.json | 3 +- tests/registry/npm/camelcase/registry.json | 3 +- tests/registry/npm/chai/registry.json | 1 - tests/registry/npm/chalk/registry.json | 3 +- tests/registry/npm/check-error/registry.json | 3 +- tests/registry/npm/chownr/registry.json | 3 +- tests/registry/npm/clean-stack/registry.json | 3 +- tests/registry/npm/cliui/registry.json | 1 - .../registry/npm/color-convert/registry.json | 1 - tests/registry/npm/color-name/registry.json | 3 +- tests/registry/npm/cowsay/registry.json | 1 - tests/registry/npm/cpu-features/registry.json | 3 +- tests/registry/npm/cross-spawn/registry.json | 3 +- tests/registry/npm/crypto-js/registry.json | 1 - tests/registry/npm/csstype/registry.json | 1 - tests/registry/npm/debug/registry.json | 3 +- tests/registry/npm/decamelize/registry.json | 3 +- tests/registry/npm/deep-eql/registry.json | 1 - .../npm/define-properties/registry.json | 3 +- .../registry/npm/eastasianwidth/registry.json | 3 +- tests/registry/npm/emoji-regex/registry.json | 3 +- tests/registry/npm/encoding/registry.json | 3 +- tests/registry/npm/env-paths/registry.json | 3 +- tests/registry/npm/err-code/registry.json | 3 +- .../registry/npm/estree-walker/registry.json | 1 - .../npm/exponential-backoff/registry.json | 3 +- .../npm/fast-deep-equal/registry.json | 3 +- tests/registry/npm/find-up/registry.json | 3 +- .../npm/foreground-child/registry.json | 3 +- tests/registry/npm/fs-extra/registry.json | 1 - tests/registry/npm/fs-minipass/registry.json | 3 +- tests/registry/npm/fsevents/registry.json | 3 +- .../registry/npm/function-bind/registry.json | 1 - .../npm/get-caller-file/registry.json | 3 +- .../registry/npm/get-func-name/registry.json | 3 +- .../registry/npm/get-intrinsic/registry.json | 3 +- tests/registry/npm/get-stdin/registry.json | 1 - tests/registry/npm/glob/registry.json | 3 +- tests/registry/npm/globals/registry.json | 3 +- tests/registry/npm/graceful-fs/registry.json | 1 - tests/registry/npm/has-flag/registry.json | 3 +- .../npm/has-package-exports/registry.json | 3 +- .../has-property-descriptors/registry.json | 3 +- tests/registry/npm/has-symbols/registry.json | 3 +- tests/registry/npm/has/registry.json | 1 - .../npm/http-cache-semantics/registry.json | 3 +- .../npm/http-proxy-agent/registry.json | 3 +- .../npm/https-proxy-agent/registry.json | 3 +- tests/registry/npm/iconv-lite/registry.json | 3 +- .../registry/npm/indent-string/registry.json | 3 +- tests/registry/npm/ip-address/registry.json | 3 +- .../npm/is-fullwidth-code-point/registry.json | 3 +- tests/registry/npm/is-lambda/registry.json | 3 +- tests/registry/npm/isexe/registry.json | 1 - tests/registry/npm/jackspeak/registry.json | 3 +- tests/registry/npm/js-tokens/registry.json | 3 +- tests/registry/npm/jsbn/registry.json | 3 +- .../npm/json-schema-traverse/registry.json | 3 +- tests/registry/npm/jsonfile/registry.json | 1 - tests/registry/npm/locate-path/registry.json | 3 +- tests/registry/npm/loose-envify/registry.json | 3 +- tests/registry/npm/loupe/registry.json | 3 +- tests/registry/npm/lru-cache/registry.json | 3 +- tests/registry/npm/lz-string/registry.json | 1 - tests/registry/npm/magic-string/registry.json | 1 - .../npm/make-fetch-happen/registry.json | 3 +- tests/registry/npm/minimatch/registry.json | 3 +- .../npm/minipass-collect/registry.json | 1 - .../registry/npm/minipass-fetch/registry.json | 3 +- .../registry/npm/minipass-flush/registry.json | 1 - .../npm/minipass-pipeline/registry.json | 3 +- .../registry/npm/minipass-sized/registry.json | 3 +- tests/registry/npm/minipass/registry.json | 3 +- tests/registry/npm/minizlib/registry.json | 3 +- tests/registry/npm/mkdirp/registry.json | 1 - tests/registry/npm/ms/registry.json | 1 - tests/registry/npm/nan/registry.json | 3 +- tests/registry/npm/nanoid/registry.json | 3 +- tests/registry/npm/negotiator/registry.json | 3 +- tests/registry/npm/node-gyp/registry.json | 1 - tests/registry/npm/nopt/registry.json | 3 +- .../npm/npm-check-updates/registry.json | 3 +- tests/registry/npm/object-keys/registry.json | 1 - tests/registry/npm/p-limit/registry.json | 3 +- tests/registry/npm/p-locate/registry.json | 3 +- tests/registry/npm/p-map/registry.json | 3 +- tests/registry/npm/p-try/registry.json | 3 +- .../npm/package-json-from-dist/registry.json | 3 +- tests/registry/npm/path-exists/registry.json | 3 +- tests/registry/npm/path-key/registry.json | 3 +- tests/registry/npm/path-scurry/registry.json | 3 +- tests/registry/npm/pathval/registry.json | 3 +- tests/registry/npm/picocolors/registry.json | 1 - .../npm/playwright-core/registry.json | 3 +- tests/registry/npm/playwright/registry.json | 3 +- tests/registry/npm/postcss/registry.json | 1 - .../npm/preact-render-to-string/registry.json | 1 - tests/registry/npm/preact/registry.json | 3 +- .../registry/npm/pretty-format/registry.json | 1 - tests/registry/npm/proc-log/registry.json | 3 +- .../registry/npm/promise-retry/registry.json | 3 +- tests/registry/npm/punycode/registry.json | 1 - tests/registry/npm/react-dom/registry.json | 3 +- tests/registry/npm/react/registry.json | 1 - .../npm/require-directory/registry.json | 1 - .../npm/require-from-string/registry.json | 3 +- .../npm/require-main-filename/registry.json | 3 +- tests/registry/npm/retry/registry.json | 1 - tests/registry/npm/safer-buffer/registry.json | 3 +- tests/registry/npm/scheduler/registry.json | 3 +- tests/registry/npm/semver/registry.json | 3 +- tests/registry/npm/set-blocking/registry.json | 3 +- .../npm/shebang-command/registry.json | 3 +- .../registry/npm/shebang-regex/registry.json | 3 +- tests/registry/npm/signal-exit/registry.json | 3 +- tests/registry/npm/smart-buffer/registry.json | 1 - .../npm/socks-proxy-agent/registry.json | 3 +- tests/registry/npm/socks/registry.json | 1 - .../registry/npm/source-map-js/registry.json | 3 +- tests/registry/npm/source-map/registry.json | 1 - .../npm/sourcemap-codec/registry.json | 3 +- tests/registry/npm/sprintf-js/registry.json | 3 +- tests/registry/npm/ssh2/registry.json | 1 - tests/registry/npm/ssri/registry.json | 3 +- tests/registry/npm/string-width/registry.json | 3 +- tests/registry/npm/strip-ansi/registry.json | 3 +- .../npm/strip-final-newline/registry.json | 3 +- .../registry/npm/supports-color/registry.json | 3 +- tests/registry/npm/supports-esm/registry.json | 3 +- tests/registry/npm/tar/registry.json | 3 +- tests/registry/npm/trim_registry_files.js | 5 + tests/registry/npm/tweetnacl/registry.json | 3 +- tests/registry/npm/type-detect/registry.json | 3 +- tests/registry/npm/type-fest/registry.json | 3 +- tests/registry/npm/undici-types/registry.json | 39 +- .../npm/undici-types/undici-types-6.19.8.tgz | Bin 21139 -> 0 bytes .../npm/undici-types/undici-types-6.20.0.tgz | Bin 0 -> 20933 bytes .../npm/unique-filename/registry.json | 3 +- tests/registry/npm/unique-slug/registry.json | 3 +- tests/registry/npm/universalify/registry.json | 3 +- tests/registry/npm/uri-js/registry.json | 3 +- .../registry/npm/utf-8-validate/registry.json | 3 +- tests/registry/npm/v8flags/registry.json | 1 - tests/registry/npm/vue/registry.json | 1 - tests/registry/npm/which-module/registry.json | 3 +- tests/registry/npm/which/registry.json | 3 +- tests/registry/npm/wrap-ansi/registry.json | 3 +- tests/registry/npm/ws/registry.json | 3 +- tests/registry/npm/y18n/registry.json | 3 +- tests/registry/npm/yallist/registry.json | 3 +- tests/registry/npm/yargs-parser/registry.json | 1 - tests/registry/npm/yargs/registry.json | 1 - .../check_node_builtin_modules/mod.ts.out | 14 +- tests/specs/npm/compare_globals/main.out | 4 +- .../bare_node_builtins/bare_node_builtins.out | 4 +- .../publish/node_specifier/node_specifier.out | 4 +- tests/unit/body_test.ts | 2 +- tests/unit/fetch_test.ts | 2 +- tests/unit/structured_clone_test.ts | 5 +- tests/unit/url_search_params_test.ts | 6 +- tests/unit/version_test.ts | 2 +- tests/unit_node/_fs/_fs_read_test.ts | 5 +- tests/unit_node/_fs/_fs_write_test.ts | 2 +- tests/unit_node/zlib_test.ts | 2 +- tests/util/server/Cargo.toml | 1 + tests/util/server/src/servers/npm_registry.rs | 5 +- 255 files changed, 7956 insertions(+), 22274 deletions(-) create mode 100644 cli/tsc/dts/lib.es2017.arraybuffer.d.ts create mode 100644 cli/tsc/dts/lib.es2024.arraybuffer.d.ts create mode 100644 cli/tsc/dts/lib.es2024.collection.d.ts create mode 100644 cli/tsc/dts/lib.es2024.d.ts create mode 100644 cli/tsc/dts/lib.es2024.full.d.ts rename cli/tsc/dts/{lib.esnext.object.d.ts => lib.es2024.object.d.ts} (100%) rename cli/tsc/dts/{lib.esnext.promise.d.ts => lib.es2024.promise.d.ts} (100%) rename cli/tsc/dts/{lib.esnext.regexp.d.ts => lib.es2024.regexp.d.ts} (100%) rename cli/tsc/dts/{lib.es2022.sharedmemory.d.ts => lib.es2024.sharedmemory.d.ts} (67%) rename cli/tsc/dts/{lib.esnext.string.d.ts => lib.es2024.string.d.ts} (100%) delete mode 100644 tests/registry/npm/@types/node/node-18.16.19.tgz delete mode 100644 tests/registry/npm/@types/node/node-18.8.2.tgz create mode 100644 tests/registry/npm/@types/node/node-22.12.0.tgz delete mode 100644 tests/registry/npm/@types/node/node-22.5.4.tgz delete mode 100644 tests/registry/npm/undici-types/undici-types-6.19.8.tgz create mode 100644 tests/registry/npm/undici-types/undici-types-6.20.0.tgz diff --git a/Cargo.lock b/Cargo.lock index 49a668dee7..cf0e5efc05 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8027,6 +8027,7 @@ dependencies = [ "once_cell", "os_pipe", "parking_lot", + "percent-encoding", "pretty_assertions", "prost", "prost-build", diff --git a/cli/build.rs b/cli/build.rs index c8e156a265..2e7227aba2 100644 --- a/cli/build.rs +++ b/cli/build.rs @@ -133,7 +133,10 @@ mod ts { // Deno built-in type libraries "decorators", "decorators.legacy", - "es5", + "dom.asynciterable", + "dom", + "dom.extras", + "dom.iterable", "es2015.collection", "es2015.core", "es2015", @@ -145,10 +148,13 @@ mod ts { "es2015.symbol", "es2015.symbol.wellknown", "es2016.array.include", - "es2016.intl", "es2016", + "es2016.full", + "es2016.intl", + "es2017.arraybuffer", "es2017", "es2017.date", + "es2017.full", "es2017.intl", "es2017.object", "es2017.sharedmemory", @@ -157,11 +163,13 @@ mod ts { "es2018.asyncgenerator", "es2018.asynciterable", "es2018", + "es2018.full", "es2018.intl", "es2018.promise", "es2018.regexp", "es2019.array", "es2019", + "es2019.full", "es2019.intl", "es2019.object", "es2019.string", @@ -169,6 +177,7 @@ mod ts { "es2020.bigint", "es2020", "es2020.date", + "es2020.full", "es2020.intl", "es2020.number", "es2020.promise", @@ -176,33 +185,48 @@ mod ts { "es2020.string", "es2020.symbol.wellknown", "es2021", + "es2021.full", "es2021.intl", "es2021.promise", "es2021.string", "es2021.weakref", - "es2022", "es2022.array", + "es2022", "es2022.error", + "es2022.full", "es2022.intl", "es2022.object", "es2022.regexp", - "es2022.sharedmemory", "es2022.string", - "es2023", "es2023.array", "es2023.collection", + "es2023", + "es2023.full", "es2023.intl", - "esnext", + "es2024.arraybuffer", + "es2024.collection", + "es2024", + "es2024.full", + "es2024.object", + "es2024.promise", + "es2024.regexp", + "es2024.sharedmemory", + "es2024.string", + "es5", + "es6", "esnext.array", "esnext.collection", + "esnext", "esnext.decorators", "esnext.disposable", + "esnext.full", "esnext.intl", "esnext.iterator", - "esnext.object", - "esnext.promise", - "esnext.regexp", - "esnext.string", + "scripthost", + "webworker.asynciterable", + "webworker", + "webworker.importscripts", + "webworker.iterable", ]; let path_dts = cwd.join("tsc/dts"); diff --git a/cli/lib/version.rs b/cli/lib/version.rs index 88a25dffeb..3fb2324726 100644 --- a/cli/lib/version.rs +++ b/cli/lib/version.rs @@ -14,7 +14,7 @@ pub fn otel_runtime_config() -> OtelRuntimeConfig { } const GIT_COMMIT_HASH: &str = env!("GIT_COMMIT_HASH"); -const TYPESCRIPT: &str = "5.6.2"; +const TYPESCRIPT: &str = "5.7.3"; const DENO_VERSION: &str = env!("DENO_VERSION"); // TODO(bartlomieju): ideally we could remove this const. const IS_CANARY: bool = option_env!("DENO_CANARY").is_some(); diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs index e523e0b31f..a134878aab 100644 --- a/cli/lsp/tsc.rs +++ b/cli/lsp/tsc.rs @@ -6015,11 +6015,25 @@ mod tests { // get some notification when the size of the assets grows let mut total_size = 0; - for asset in assets { + for asset in &assets { total_size += asset.text().len(); } assert!(total_size > 0); - assert!(total_size < 2_000_000); // currently as of TS 4.6, it's 0.7MB + #[allow(clippy::print_stderr)] + // currently as of TS 5.7, it's 3MB + if total_size > 3_500_000 { + let mut sizes = Vec::new(); + for asset in &assets { + sizes.push((asset.specifier(), asset.text().len())); + } + sizes.sort_by_cached_key(|(_, size)| *size); + sizes.reverse(); + for (specifier, size) in &sizes { + eprintln!("{}: {}", specifier, size); + } + eprintln!("Total size: {}", total_size); + panic!("Assets were quite large."); + } } #[tokio::test] diff --git a/cli/npm/installer/resolution.rs b/cli/npm/installer/resolution.rs index 06bbcd4f76..267ca2f432 100644 --- a/cli/npm/installer/resolution.rs +++ b/cli/npm/installer/resolution.rs @@ -189,7 +189,7 @@ fn get_add_pkg_reqs_options(package_reqs: &[PackageReq]) -> AddPkgReqsOptions { // WARNING: When bumping this version, check if anything needs to be // updated in the `setNodeOnlyGlobalNames` call in 99_main_compiler.js types_node_version_req: Some( - VersionReq::parse_from_npm("22.0.0 - 22.5.4").unwrap(), + VersionReq::parse_from_npm("22.9.0 - 22.12.0").unwrap(), ), } } diff --git a/cli/snapshot/shared.rs b/cli/snapshot/shared.rs index eec982776a..61da61f408 100644 --- a/cli/snapshot/shared.rs +++ b/cli/snapshot/shared.rs @@ -1,3 +1,3 @@ // Copyright 2018-2025 the Deno authors. MIT license. -pub static TS_VERSION: &str = "5.6.2"; +pub static TS_VERSION: &str = "5.7.3"; diff --git a/cli/tsc/00_typescript.js b/cli/tsc/00_typescript.js index b7626fe082..c266ad5270 100644 --- a/cli/tsc/00_typescript.js +++ b/cli/tsc/00_typescript.js @@ -93,7 +93,7 @@ __export(typescript_exports, { IndexKind: () => IndexKind, InferenceFlags: () => InferenceFlags, InferencePriority: () => InferencePriority, - InlayHintKind: () => InlayHintKind2, + InlayHintKind: () => InlayHintKind, InlayHints: () => ts_InlayHints_exports, InternalEmitFlags: () => InternalEmitFlags, InternalNodeBuilderFlags: () => InternalNodeBuilderFlags, @@ -144,6 +144,7 @@ __export(typescript_exports, { PollingWatchKind: () => PollingWatchKind, PragmaKindFlags: () => PragmaKindFlags, PredicateSemantics: () => PredicateSemantics, + PreparePasteEdits: () => ts_preparePasteEdits_exports, PrivateIdentifierKind: () => PrivateIdentifierKind, ProcessLevel: () => ProcessLevel, ProgramUpdateLevel: () => ProgramUpdateLevel, @@ -236,10 +237,8 @@ __export(typescript_exports, { breakIntoWordSpans: () => breakIntoWordSpans, buildLinkParts: () => buildLinkParts, buildOpts: () => buildOpts, - buildOverload: () => buildOverload, bundlerModuleNameResolver: () => bundlerModuleNameResolver, canBeConvertedToAsync: () => canBeConvertedToAsync, - canEmitTsBuildInfo: () => canEmitTsBuildInfo, canHaveDecorators: () => canHaveDecorators, canHaveExportModifier: () => canHaveExportModifier, canHaveFlowNode: () => canHaveFlowNode, @@ -259,6 +258,7 @@ __export(typescript_exports, { canWatchAffectingLocation: () => canWatchAffectingLocation, canWatchAtTypes: () => canWatchAtTypes, canWatchDirectoryOrFile: () => canWatchDirectoryOrFile, + canWatchDirectoryOrFilePath: () => canWatchDirectoryOrFilePath, cartesianProduct: () => cartesianProduct, cast: () => cast, chainBundle: () => chainBundle, @@ -424,7 +424,6 @@ __export(typescript_exports, { createNodeConverters: () => createNodeConverters, createNodeFactory: () => createNodeFactory, createOptionNameMap: () => createOptionNameMap, - createOverload: () => createOverload, createPackageJsonImportFilter: () => createPackageJsonImportFilter, createPackageJsonInfo: () => createPackageJsonInfo, createParenthesizerRules: () => createParenthesizerRules, @@ -530,6 +529,7 @@ __export(typescript_exports, { escapeTemplateSubstitution: () => escapeTemplateSubstitution, evaluatorResult: () => evaluatorResult, every: () => every, + exclusivelyPrefixedNodeCoreModules: () => exclusivelyPrefixedNodeCoreModules, executeCommandLine: () => executeCommandLine, expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression, explainFiles: () => explainFiles, @@ -542,7 +542,6 @@ __export(typescript_exports, { extensionsNotSupportingExtensionlessResolution: () => extensionsNotSupportingExtensionlessResolution, externalHelpersModuleNameText: () => externalHelpersModuleNameText, factory: () => factory, - fileContainsPackageImport: () => fileContainsPackageImport, fileExtensionIs: () => fileExtensionIs, fileExtensionIsOneOf: () => fileExtensionIsOneOf, fileIncludeReasonToDiagnostics: () => fileIncludeReasonToDiagnostics, @@ -592,8 +591,10 @@ __export(typescript_exports, { forEach: () => forEach, forEachAncestor: () => forEachAncestor, forEachAncestorDirectory: () => forEachAncestorDirectory, + forEachAncestorDirectoryStoppingAtGlobalCache: () => forEachAncestorDirectoryStoppingAtGlobalCache, forEachChild: () => forEachChild, forEachChildRecursively: () => forEachChildRecursively, + forEachDynamicImportOrRequireCall: () => forEachDynamicImportOrRequireCall, forEachEmittedFile: () => forEachEmittedFile, forEachEnclosingBlockScopeContainer: () => forEachEnclosingBlockScopeContainer, forEachEntry: () => forEachEntry, @@ -634,6 +635,7 @@ __export(typescript_exports, { getAllKeys: () => getAllKeys, getAllProjectOutputs: () => getAllProjectOutputs, getAllSuperTypeNodes: () => getAllSuperTypeNodes, + getAllowImportingTsExtensions: () => getAllowImportingTsExtensions, getAllowJSCompilerOption: () => getAllowJSCompilerOption, getAllowSyntheticDefaultImports: () => getAllowSyntheticDefaultImports, getAncestor: () => getAncestor, @@ -942,6 +944,7 @@ __export(typescript_exports, { getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter, getPossibleGenericSignatures: () => getPossibleGenericSignatures, getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension, + getPossibleOriginalInputPathWithoutChangingExt: () => getPossibleOriginalInputPathWithoutChangingExt, getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo, getPreEmitDiagnostics: () => getPreEmitDiagnostics, getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition, @@ -1205,7 +1208,7 @@ __export(typescript_exports, { isBooleanLiteral: () => isBooleanLiteral, isBreakOrContinueStatement: () => isBreakOrContinueStatement, isBreakStatement: () => isBreakStatement, - isBuild: () => isBuild, + isBuildCommand: () => isBuildCommand, isBuildInfoFile: () => isBuildInfoFile, isBuilderProgram: () => isBuilderProgram, isBundle: () => isBundle, @@ -1392,7 +1395,7 @@ __export(typescript_exports, { isImportSpecifier: () => isImportSpecifier, isImportTypeAssertionContainer: () => isImportTypeAssertionContainer, isImportTypeNode: () => isImportTypeNode, - isImportableFile: () => isImportableFile, + isImportable: () => isImportable, isInComment: () => isInComment, isInCompoundLikeAssignment: () => isInCompoundLikeAssignment, isInExpressionContext: () => isInExpressionContext, @@ -1491,6 +1494,7 @@ __export(typescript_exports, { isJsxAttributeLike: () => isJsxAttributeLike, isJsxAttributeName: () => isJsxAttributeName, isJsxAttributes: () => isJsxAttributes, + isJsxCallLike: () => isJsxCallLike, isJsxChild: () => isJsxChild, isJsxClosingElement: () => isJsxClosingElement, isJsxClosingFragment: () => isJsxClosingFragment, @@ -1573,6 +1577,7 @@ __export(typescript_exports, { isNamespaceReexportDeclaration: () => isNamespaceReexportDeclaration, isNewExpression: () => isNewExpression, isNewExpressionTarget: () => isNewExpressionTarget, + isNewScopeNode: () => isNewScopeNode, isNoSubstitutionTemplateLiteral: () => isNoSubstitutionTemplateLiteral, isNodeArray: () => isNodeArray, isNodeArrayMultiLine: () => isNodeArrayMultiLine, @@ -1621,6 +1626,7 @@ __export(typescript_exports, { isParseTreeNode: () => isParseTreeNode, isPartOfParameterDeclaration: () => isPartOfParameterDeclaration, isPartOfTypeNode: () => isPartOfTypeNode, + isPartOfTypeOnlyImportOrExportDeclaration: () => isPartOfTypeOnlyImportOrExportDeclaration, isPartOfTypeQuery: () => isPartOfTypeQuery, isPartiallyEmittedExpression: () => isPartiallyEmittedExpression, isPatternMatch: () => isPatternMatch, @@ -1689,6 +1695,7 @@ __export(typescript_exports, { isSimpleInlineableExpression: () => isSimpleInlineableExpression, isSimpleParameterList: () => isSimpleParameterList, isSingleOrDoubleQuote: () => isSingleOrDoubleQuote, + isSolutionConfig: () => isSolutionConfig, isSourceElement: () => isSourceElement, isSourceFile: () => isSourceFile, isSourceFileFromLibrary: () => isSourceFileFromLibrary, @@ -1797,7 +1804,6 @@ __export(typescript_exports, { isVariableDeclarationInitializedToRequire: () => isVariableDeclarationInitializedToRequire, isVariableDeclarationList: () => isVariableDeclarationList, isVariableLike: () => isVariableLike, - isVariableLikeOrAccessor: () => isVariableLikeOrAccessor, isVariableStatement: () => isVariableStatement, isVoidExpression: () => isVoidExpression, isWatchSet: () => isWatchSet, @@ -1834,6 +1840,7 @@ __export(typescript_exports, { matchPatternOrExact: () => matchPatternOrExact, matchedText: () => matchedText, matchesExclude: () => matchesExclude, + matchesExcludeWorker: () => matchesExcludeWorker, maxBy: () => maxBy, maybeBind: () => maybeBind, maybeSetLocalizedDiagnosticMessages: () => maybeSetLocalizedDiagnosticMessages, @@ -1873,6 +1880,7 @@ __export(typescript_exports, { noTransformers: () => noTransformers, noTruncationMaximumTruncationLength: () => noTruncationMaximumTruncationLength, nodeCanBeDecorated: () => nodeCanBeDecorated, + nodeCoreModules: () => nodeCoreModules, nodeHasName: () => nodeHasName, nodeIsDecorated: () => nodeIsDecorated, nodeIsMissing: () => nodeIsMissing, @@ -2017,6 +2025,7 @@ __export(typescript_exports, { returnTrue: () => returnTrue, returnUndefined: () => returnUndefined, returnsPromise: () => returnsPromise, + rewriteModuleSpecifier: () => rewriteModuleSpecifier, sameFlatMap: () => sameFlatMap, sameMap: () => sameMap, sameMapping: () => sameMapping, @@ -2024,7 +2033,7 @@ __export(typescript_exports, { scanner: () => scanner, semanticDiagnosticsOptionDeclarations: () => semanticDiagnosticsOptionDeclarations, serializeCompilerOptions: () => serializeCompilerOptions, - server: () => ts_server_exports4, + server: () => ts_server_exports, servicesVersion: () => servicesVersion, setCommentRange: () => setCommentRange, setConfigFileInOptions: () => setConfigFileInOptions, @@ -2062,6 +2071,7 @@ __export(typescript_exports, { setValueDeclaration: () => setValueDeclaration, shouldAllowImportingTsExtension: () => shouldAllowImportingTsExtension, shouldPreserveConstEnums: () => shouldPreserveConstEnums, + shouldRewriteModuleSpecifier: () => shouldRewriteModuleSpecifier, shouldUseUriStyleNodeCoreModules: () => shouldUseUriStyleNodeCoreModules, showModuleSpecifier: () => showModuleSpecifier, signatureHasRestParameter: () => signatureHasRestParameter, @@ -2119,6 +2129,7 @@ __export(typescript_exports, { tagNamesAreEquivalent: () => tagNamesAreEquivalent, takeWhile: () => takeWhile, targetOptionDeclaration: () => targetOptionDeclaration, + targetToLibMap: () => targetToLibMap, testFormatSettings: () => testFormatSettings, textChangeRangeIsUnchanged: () => textChangeRangeIsUnchanged, textChangeRangeNewSpan: () => textChangeRangeNewSpan, @@ -2212,6 +2223,7 @@ __export(typescript_exports, { tryRemoveExtension: () => tryRemoveExtension, tryRemovePrefix: () => tryRemovePrefix, tryRemoveSuffix: () => tryRemoveSuffix, + tscBuildOption: () => tscBuildOption, typeAcquisitionDeclarations: () => typeAcquisitionDeclarations, typeAliasNamePart: () => typeAliasNamePart, typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo, @@ -2223,6 +2235,7 @@ __export(typescript_exports, { unescapeLeadingUnderscores: () => unescapeLeadingUnderscores, unmangleScopedPackageName: () => unmangleScopedPackageName, unorderedRemoveItem: () => unorderedRemoveItem, + unprefixedNodeCoreModules: () => unprefixedNodeCoreModules, unreachableCodeIsError: () => unreachableCodeIsError, unsetNodeChildren: () => unsetNodeChildren, unusedLabelIsError: () => unusedLabelIsError, @@ -2263,8 +2276,8 @@ __export(typescript_exports, { module.exports = __toCommonJS(typescript_exports); // src/compiler/corePublic.ts -var versionMajorMinor = "5.6"; -var version = "5.6.2"; +var versionMajorMinor = "5.7"; +var version = "5.7.3"; var Comparison = /* @__PURE__ */ ((Comparison3) => { Comparison3[Comparison3["LessThan"] = -1] = "LessThan"; Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo"; @@ -2732,7 +2745,10 @@ function deduplicateSorted(array, comparer) { for (let i = 1; i < array.length; i++) { const next = array[i]; switch (comparer(next, last2)) { + // equality comparison case true: + // relational comparison + // falls through case 0 /* EqualTo */: continue; case -1 /* LessThan */: @@ -3617,7 +3633,7 @@ function findBestPatternMatch(values, getPattern, candidate) { for (let i = 0; i < values.length; i++) { const v = values[i]; const pattern = getPattern(v); - if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) { + if (pattern.prefix.length > longestMatchPrefixLength && isPatternMatch(pattern, candidate)) { longestMatchPrefixLength = pattern.prefix.length; matchedValue = v; } @@ -3746,13 +3762,13 @@ function isNodeLikeSystem() { } // src/compiler/debug.ts -var LogLevel = /* @__PURE__ */ ((LogLevel3) => { - LogLevel3[LogLevel3["Off"] = 0] = "Off"; - LogLevel3[LogLevel3["Error"] = 1] = "Error"; - LogLevel3[LogLevel3["Warning"] = 2] = "Warning"; - LogLevel3[LogLevel3["Info"] = 3] = "Info"; - LogLevel3[LogLevel3["Verbose"] = 4] = "Verbose"; - return LogLevel3; +var LogLevel = /* @__PURE__ */ ((LogLevel2) => { + LogLevel2[LogLevel2["Off"] = 0] = "Off"; + LogLevel2[LogLevel2["Error"] = 1] = "Error"; + LogLevel2[LogLevel2["Warning"] = 2] = "Warning"; + LogLevel2[LogLevel2["Info"] = 3] = "Info"; + LogLevel2[LogLevel2["Verbose"] = 4] = "Verbose"; + return LogLevel2; })(LogLevel || {}); var Debug; ((Debug2) => { @@ -5853,10 +5869,11 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => { SyntaxKind5[SyntaxKind5["JSDocImportTag"] = 351] = "JSDocImportTag"; SyntaxKind5[SyntaxKind5["SyntaxList"] = 352] = "SyntaxList"; SyntaxKind5[SyntaxKind5["NotEmittedStatement"] = 353] = "NotEmittedStatement"; - SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 354] = "PartiallyEmittedExpression"; - SyntaxKind5[SyntaxKind5["CommaListExpression"] = 355] = "CommaListExpression"; - SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 356] = "SyntheticReferenceExpression"; - SyntaxKind5[SyntaxKind5["Count"] = 357] = "Count"; + SyntaxKind5[SyntaxKind5["NotEmittedTypeElement"] = 354] = "NotEmittedTypeElement"; + SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 355] = "PartiallyEmittedExpression"; + SyntaxKind5[SyntaxKind5["CommaListExpression"] = 356] = "CommaListExpression"; + SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression"; + SyntaxKind5[SyntaxKind5["Count"] = 358] = "Count"; SyntaxKind5[SyntaxKind5["FirstAssignment"] = 64 /* EqualsToken */] = "FirstAssignment"; SyntaxKind5[SyntaxKind5["LastAssignment"] = 79 /* CaretEqualsToken */] = "LastAssignment"; SyntaxKind5[SyntaxKind5["FirstCompoundAssignment"] = 65 /* PlusEqualsToken */] = "FirstCompoundAssignment"; @@ -6660,14 +6677,14 @@ function diagnosticCategoryName(d, lowerCase = true) { const name = DiagnosticCategory[d.category]; return lowerCase ? name.toLowerCase() : name; } -var ModuleResolutionKind = /* @__PURE__ */ ((ModuleResolutionKind3) => { - ModuleResolutionKind3[ModuleResolutionKind3["Classic"] = 1] = "Classic"; - ModuleResolutionKind3[ModuleResolutionKind3["NodeJs"] = 2] = "NodeJs"; - ModuleResolutionKind3[ModuleResolutionKind3["Node10"] = 2] = "Node10"; - ModuleResolutionKind3[ModuleResolutionKind3["Node16"] = 3] = "Node16"; - ModuleResolutionKind3[ModuleResolutionKind3["NodeNext"] = 99] = "NodeNext"; - ModuleResolutionKind3[ModuleResolutionKind3["Bundler"] = 100] = "Bundler"; - return ModuleResolutionKind3; +var ModuleResolutionKind = /* @__PURE__ */ ((ModuleResolutionKind2) => { + ModuleResolutionKind2[ModuleResolutionKind2["Classic"] = 1] = "Classic"; + ModuleResolutionKind2[ModuleResolutionKind2["NodeJs"] = 2] = "NodeJs"; + ModuleResolutionKind2[ModuleResolutionKind2["Node10"] = 2] = "Node10"; + ModuleResolutionKind2[ModuleResolutionKind2["Node16"] = 3] = "Node16"; + ModuleResolutionKind2[ModuleResolutionKind2["NodeNext"] = 99] = "NodeNext"; + ModuleResolutionKind2[ModuleResolutionKind2["Bundler"] = 100] = "Bundler"; + return ModuleResolutionKind2; })(ModuleResolutionKind || {}); var ModuleDetectionKind = /* @__PURE__ */ ((ModuleDetectionKind2) => { ModuleDetectionKind2[ModuleDetectionKind2["Legacy"] = 1] = "Legacy"; @@ -6675,52 +6692,52 @@ var ModuleDetectionKind = /* @__PURE__ */ ((ModuleDetectionKind2) => { ModuleDetectionKind2[ModuleDetectionKind2["Force"] = 3] = "Force"; return ModuleDetectionKind2; })(ModuleDetectionKind || {}); -var WatchFileKind = /* @__PURE__ */ ((WatchFileKind3) => { - WatchFileKind3[WatchFileKind3["FixedPollingInterval"] = 0] = "FixedPollingInterval"; - WatchFileKind3[WatchFileKind3["PriorityPollingInterval"] = 1] = "PriorityPollingInterval"; - WatchFileKind3[WatchFileKind3["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; - WatchFileKind3[WatchFileKind3["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; - WatchFileKind3[WatchFileKind3["UseFsEvents"] = 4] = "UseFsEvents"; - WatchFileKind3[WatchFileKind3["UseFsEventsOnParentDirectory"] = 5] = "UseFsEventsOnParentDirectory"; - return WatchFileKind3; +var WatchFileKind = /* @__PURE__ */ ((WatchFileKind2) => { + WatchFileKind2[WatchFileKind2["FixedPollingInterval"] = 0] = "FixedPollingInterval"; + WatchFileKind2[WatchFileKind2["PriorityPollingInterval"] = 1] = "PriorityPollingInterval"; + WatchFileKind2[WatchFileKind2["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + WatchFileKind2[WatchFileKind2["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; + WatchFileKind2[WatchFileKind2["UseFsEvents"] = 4] = "UseFsEvents"; + WatchFileKind2[WatchFileKind2["UseFsEventsOnParentDirectory"] = 5] = "UseFsEventsOnParentDirectory"; + return WatchFileKind2; })(WatchFileKind || {}); -var WatchDirectoryKind = /* @__PURE__ */ ((WatchDirectoryKind3) => { - WatchDirectoryKind3[WatchDirectoryKind3["UseFsEvents"] = 0] = "UseFsEvents"; - WatchDirectoryKind3[WatchDirectoryKind3["FixedPollingInterval"] = 1] = "FixedPollingInterval"; - WatchDirectoryKind3[WatchDirectoryKind3["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; - WatchDirectoryKind3[WatchDirectoryKind3["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; - return WatchDirectoryKind3; +var WatchDirectoryKind = /* @__PURE__ */ ((WatchDirectoryKind2) => { + WatchDirectoryKind2[WatchDirectoryKind2["UseFsEvents"] = 0] = "UseFsEvents"; + WatchDirectoryKind2[WatchDirectoryKind2["FixedPollingInterval"] = 1] = "FixedPollingInterval"; + WatchDirectoryKind2[WatchDirectoryKind2["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + WatchDirectoryKind2[WatchDirectoryKind2["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; + return WatchDirectoryKind2; })(WatchDirectoryKind || {}); -var PollingWatchKind = /* @__PURE__ */ ((PollingWatchKind3) => { - PollingWatchKind3[PollingWatchKind3["FixedInterval"] = 0] = "FixedInterval"; - PollingWatchKind3[PollingWatchKind3["PriorityInterval"] = 1] = "PriorityInterval"; - PollingWatchKind3[PollingWatchKind3["DynamicPriority"] = 2] = "DynamicPriority"; - PollingWatchKind3[PollingWatchKind3["FixedChunkSize"] = 3] = "FixedChunkSize"; - return PollingWatchKind3; +var PollingWatchKind = /* @__PURE__ */ ((PollingWatchKind2) => { + PollingWatchKind2[PollingWatchKind2["FixedInterval"] = 0] = "FixedInterval"; + PollingWatchKind2[PollingWatchKind2["PriorityInterval"] = 1] = "PriorityInterval"; + PollingWatchKind2[PollingWatchKind2["DynamicPriority"] = 2] = "DynamicPriority"; + PollingWatchKind2[PollingWatchKind2["FixedChunkSize"] = 3] = "FixedChunkSize"; + return PollingWatchKind2; })(PollingWatchKind || {}); -var ModuleKind = /* @__PURE__ */ ((ModuleKind3) => { - ModuleKind3[ModuleKind3["None"] = 0] = "None"; - ModuleKind3[ModuleKind3["CommonJS"] = 1] = "CommonJS"; - ModuleKind3[ModuleKind3["AMD"] = 2] = "AMD"; - ModuleKind3[ModuleKind3["UMD"] = 3] = "UMD"; - ModuleKind3[ModuleKind3["System"] = 4] = "System"; - ModuleKind3[ModuleKind3["ES2015"] = 5] = "ES2015"; - ModuleKind3[ModuleKind3["ES2020"] = 6] = "ES2020"; - ModuleKind3[ModuleKind3["ES2022"] = 7] = "ES2022"; - ModuleKind3[ModuleKind3["ESNext"] = 99] = "ESNext"; - ModuleKind3[ModuleKind3["Node16"] = 100] = "Node16"; - ModuleKind3[ModuleKind3["NodeNext"] = 199] = "NodeNext"; - ModuleKind3[ModuleKind3["Preserve"] = 200] = "Preserve"; - return ModuleKind3; +var ModuleKind = /* @__PURE__ */ ((ModuleKind2) => { + ModuleKind2[ModuleKind2["None"] = 0] = "None"; + ModuleKind2[ModuleKind2["CommonJS"] = 1] = "CommonJS"; + ModuleKind2[ModuleKind2["AMD"] = 2] = "AMD"; + ModuleKind2[ModuleKind2["UMD"] = 3] = "UMD"; + ModuleKind2[ModuleKind2["System"] = 4] = "System"; + ModuleKind2[ModuleKind2["ES2015"] = 5] = "ES2015"; + ModuleKind2[ModuleKind2["ES2020"] = 6] = "ES2020"; + ModuleKind2[ModuleKind2["ES2022"] = 7] = "ES2022"; + ModuleKind2[ModuleKind2["ESNext"] = 99] = "ESNext"; + ModuleKind2[ModuleKind2["Node16"] = 100] = "Node16"; + ModuleKind2[ModuleKind2["NodeNext"] = 199] = "NodeNext"; + ModuleKind2[ModuleKind2["Preserve"] = 200] = "Preserve"; + return ModuleKind2; })(ModuleKind || {}); -var JsxEmit = /* @__PURE__ */ ((JsxEmit3) => { - JsxEmit3[JsxEmit3["None"] = 0] = "None"; - JsxEmit3[JsxEmit3["Preserve"] = 1] = "Preserve"; - JsxEmit3[JsxEmit3["React"] = 2] = "React"; - JsxEmit3[JsxEmit3["ReactNative"] = 3] = "ReactNative"; - JsxEmit3[JsxEmit3["ReactJSX"] = 4] = "ReactJSX"; - JsxEmit3[JsxEmit3["ReactJSXDev"] = 5] = "ReactJSXDev"; - return JsxEmit3; +var JsxEmit = /* @__PURE__ */ ((JsxEmit2) => { + JsxEmit2[JsxEmit2["None"] = 0] = "None"; + JsxEmit2[JsxEmit2["Preserve"] = 1] = "Preserve"; + JsxEmit2[JsxEmit2["React"] = 2] = "React"; + JsxEmit2[JsxEmit2["ReactNative"] = 3] = "ReactNative"; + JsxEmit2[JsxEmit2["ReactJSX"] = 4] = "ReactJSX"; + JsxEmit2[JsxEmit2["ReactJSXDev"] = 5] = "ReactJSXDev"; + return JsxEmit2; })(JsxEmit || {}); var ImportsNotUsedAsValues = /* @__PURE__ */ ((ImportsNotUsedAsValues2) => { ImportsNotUsedAsValues2[ImportsNotUsedAsValues2["Remove"] = 0] = "Remove"; @@ -6728,38 +6745,39 @@ var ImportsNotUsedAsValues = /* @__PURE__ */ ((ImportsNotUsedAsValues2) => { ImportsNotUsedAsValues2[ImportsNotUsedAsValues2["Error"] = 2] = "Error"; return ImportsNotUsedAsValues2; })(ImportsNotUsedAsValues || {}); -var NewLineKind = /* @__PURE__ */ ((NewLineKind3) => { - NewLineKind3[NewLineKind3["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed"; - NewLineKind3[NewLineKind3["LineFeed"] = 1] = "LineFeed"; - return NewLineKind3; +var NewLineKind = /* @__PURE__ */ ((NewLineKind2) => { + NewLineKind2[NewLineKind2["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed"; + NewLineKind2[NewLineKind2["LineFeed"] = 1] = "LineFeed"; + return NewLineKind2; })(NewLineKind || {}); -var ScriptKind = /* @__PURE__ */ ((ScriptKind7) => { - ScriptKind7[ScriptKind7["Unknown"] = 0] = "Unknown"; - ScriptKind7[ScriptKind7["JS"] = 1] = "JS"; - ScriptKind7[ScriptKind7["JSX"] = 2] = "JSX"; - ScriptKind7[ScriptKind7["TS"] = 3] = "TS"; - ScriptKind7[ScriptKind7["TSX"] = 4] = "TSX"; - ScriptKind7[ScriptKind7["External"] = 5] = "External"; - ScriptKind7[ScriptKind7["JSON"] = 6] = "JSON"; - ScriptKind7[ScriptKind7["Deferred"] = 7] = "Deferred"; - return ScriptKind7; +var ScriptKind = /* @__PURE__ */ ((ScriptKind6) => { + ScriptKind6[ScriptKind6["Unknown"] = 0] = "Unknown"; + ScriptKind6[ScriptKind6["JS"] = 1] = "JS"; + ScriptKind6[ScriptKind6["JSX"] = 2] = "JSX"; + ScriptKind6[ScriptKind6["TS"] = 3] = "TS"; + ScriptKind6[ScriptKind6["TSX"] = 4] = "TSX"; + ScriptKind6[ScriptKind6["External"] = 5] = "External"; + ScriptKind6[ScriptKind6["JSON"] = 6] = "JSON"; + ScriptKind6[ScriptKind6["Deferred"] = 7] = "Deferred"; + return ScriptKind6; })(ScriptKind || {}); -var ScriptTarget = /* @__PURE__ */ ((ScriptTarget12) => { - ScriptTarget12[ScriptTarget12["ES3"] = 0] = "ES3"; - ScriptTarget12[ScriptTarget12["ES5"] = 1] = "ES5"; - ScriptTarget12[ScriptTarget12["ES2015"] = 2] = "ES2015"; - ScriptTarget12[ScriptTarget12["ES2016"] = 3] = "ES2016"; - ScriptTarget12[ScriptTarget12["ES2017"] = 4] = "ES2017"; - ScriptTarget12[ScriptTarget12["ES2018"] = 5] = "ES2018"; - ScriptTarget12[ScriptTarget12["ES2019"] = 6] = "ES2019"; - ScriptTarget12[ScriptTarget12["ES2020"] = 7] = "ES2020"; - ScriptTarget12[ScriptTarget12["ES2021"] = 8] = "ES2021"; - ScriptTarget12[ScriptTarget12["ES2022"] = 9] = "ES2022"; - ScriptTarget12[ScriptTarget12["ES2023"] = 10] = "ES2023"; - ScriptTarget12[ScriptTarget12["ESNext"] = 99] = "ESNext"; - ScriptTarget12[ScriptTarget12["JSON"] = 100] = "JSON"; - ScriptTarget12[ScriptTarget12["Latest"] = 99 /* ESNext */] = "Latest"; - return ScriptTarget12; +var ScriptTarget = /* @__PURE__ */ ((ScriptTarget11) => { + ScriptTarget11[ScriptTarget11["ES3"] = 0] = "ES3"; + ScriptTarget11[ScriptTarget11["ES5"] = 1] = "ES5"; + ScriptTarget11[ScriptTarget11["ES2015"] = 2] = "ES2015"; + ScriptTarget11[ScriptTarget11["ES2016"] = 3] = "ES2016"; + ScriptTarget11[ScriptTarget11["ES2017"] = 4] = "ES2017"; + ScriptTarget11[ScriptTarget11["ES2018"] = 5] = "ES2018"; + ScriptTarget11[ScriptTarget11["ES2019"] = 6] = "ES2019"; + ScriptTarget11[ScriptTarget11["ES2020"] = 7] = "ES2020"; + ScriptTarget11[ScriptTarget11["ES2021"] = 8] = "ES2021"; + ScriptTarget11[ScriptTarget11["ES2022"] = 9] = "ES2022"; + ScriptTarget11[ScriptTarget11["ES2023"] = 10] = "ES2023"; + ScriptTarget11[ScriptTarget11["ES2024"] = 11] = "ES2024"; + ScriptTarget11[ScriptTarget11["ESNext"] = 99] = "ESNext"; + ScriptTarget11[ScriptTarget11["JSON"] = 100] = "JSON"; + ScriptTarget11[ScriptTarget11["Latest"] = 99 /* ESNext */] = "Latest"; + return ScriptTarget11; })(ScriptTarget || {}); var LanguageVariant = /* @__PURE__ */ ((LanguageVariant4) => { LanguageVariant4[LanguageVariant4["Standard"] = 0] = "Standard"; @@ -7032,43 +7050,42 @@ var InternalEmitFlags = /* @__PURE__ */ ((InternalEmitFlags3) => { InternalEmitFlags3[InternalEmitFlags3["TransformPrivateStaticElements"] = 32] = "TransformPrivateStaticElements"; return InternalEmitFlags3; })(InternalEmitFlags || {}); -var LanguageFeatureMinimumTarget = /* @__PURE__ */ ((LanguageFeatureMinimumTarget2) => { - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Classes"] = 2 /* ES2015 */] = "Classes"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ForOf"] = 2 /* ES2015 */] = "ForOf"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Generators"] = 2 /* ES2015 */] = "Generators"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Iteration"] = 2 /* ES2015 */] = "Iteration"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["SpreadElements"] = 2 /* ES2015 */] = "SpreadElements"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RestElements"] = 2 /* ES2015 */] = "RestElements"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["TaggedTemplates"] = 2 /* ES2015 */] = "TaggedTemplates"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["DestructuringAssignment"] = 2 /* ES2015 */] = "DestructuringAssignment"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BindingPatterns"] = 2 /* ES2015 */] = "BindingPatterns"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ArrowFunctions"] = 2 /* ES2015 */] = "ArrowFunctions"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BlockScopedVariables"] = 2 /* ES2015 */] = "BlockScopedVariables"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ObjectAssign"] = 2 /* ES2015 */] = "ObjectAssign"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RegularExpressionFlagsUnicode"] = 2 /* ES2015 */] = "RegularExpressionFlagsUnicode"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RegularExpressionFlagsSticky"] = 2 /* ES2015 */] = "RegularExpressionFlagsSticky"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["Exponentiation"] = 3 /* ES2016 */] = "Exponentiation"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncFunctions"] = 4 /* ES2017 */] = "AsyncFunctions"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ForAwaitOf"] = 5 /* ES2018 */] = "ForAwaitOf"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncGenerators"] = 5 /* ES2018 */] = "AsyncGenerators"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["AsyncIteration"] = 5 /* ES2018 */] = "AsyncIteration"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ObjectSpreadRest"] = 5 /* ES2018 */] = "ObjectSpreadRest"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RegularExpressionFlagsDotAll"] = 5 /* ES2018 */] = "RegularExpressionFlagsDotAll"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BindinglessCatch"] = 6 /* ES2019 */] = "BindinglessCatch"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["BigInt"] = 7 /* ES2020 */] = "BigInt"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["NullishCoalesce"] = 7 /* ES2020 */] = "NullishCoalesce"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["OptionalChaining"] = 7 /* ES2020 */] = "OptionalChaining"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["LogicalAssignment"] = 8 /* ES2021 */] = "LogicalAssignment"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["TopLevelAwait"] = 9 /* ES2022 */] = "TopLevelAwait"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ClassFields"] = 9 /* ES2022 */] = "ClassFields"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["PrivateNamesAndClassStaticBlocks"] = 9 /* ES2022 */] = "PrivateNamesAndClassStaticBlocks"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RegularExpressionFlagsHasIndices"] = 9 /* ES2022 */] = "RegularExpressionFlagsHasIndices"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ShebangComments"] = 99 /* ESNext */] = "ShebangComments"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["UsingAndAwaitUsing"] = 99 /* ESNext */] = "UsingAndAwaitUsing"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["ClassAndClassElementDecorators"] = 99 /* ESNext */] = "ClassAndClassElementDecorators"; - LanguageFeatureMinimumTarget2[LanguageFeatureMinimumTarget2["RegularExpressionFlagsUnicodeSets"] = 99 /* ESNext */] = "RegularExpressionFlagsUnicodeSets"; - return LanguageFeatureMinimumTarget2; -})(LanguageFeatureMinimumTarget || {}); +var LanguageFeatureMinimumTarget = { + Classes: 2 /* ES2015 */, + ForOf: 2 /* ES2015 */, + Generators: 2 /* ES2015 */, + Iteration: 2 /* ES2015 */, + SpreadElements: 2 /* ES2015 */, + RestElements: 2 /* ES2015 */, + TaggedTemplates: 2 /* ES2015 */, + DestructuringAssignment: 2 /* ES2015 */, + BindingPatterns: 2 /* ES2015 */, + ArrowFunctions: 2 /* ES2015 */, + BlockScopedVariables: 2 /* ES2015 */, + ObjectAssign: 2 /* ES2015 */, + RegularExpressionFlagsUnicode: 2 /* ES2015 */, + RegularExpressionFlagsSticky: 2 /* ES2015 */, + Exponentiation: 3 /* ES2016 */, + AsyncFunctions: 4 /* ES2017 */, + ForAwaitOf: 5 /* ES2018 */, + AsyncGenerators: 5 /* ES2018 */, + AsyncIteration: 5 /* ES2018 */, + ObjectSpreadRest: 5 /* ES2018 */, + RegularExpressionFlagsDotAll: 5 /* ES2018 */, + BindinglessCatch: 6 /* ES2019 */, + BigInt: 7 /* ES2020 */, + NullishCoalesce: 7 /* ES2020 */, + OptionalChaining: 7 /* ES2020 */, + LogicalAssignment: 8 /* ES2021 */, + TopLevelAwait: 9 /* ES2022 */, + ClassFields: 9 /* ES2022 */, + PrivateNamesAndClassStaticBlocks: 9 /* ES2022 */, + RegularExpressionFlagsHasIndices: 9 /* ES2022 */, + ShebangComments: 10 /* ES2023 */, + RegularExpressionFlagsUnicodeSets: 11 /* ES2024 */, + UsingAndAwaitUsing: 99 /* ESNext */, + ClassAndClassElementDecorators: 99 /* ESNext */ +}; var ExternalEmitHelpers = /* @__PURE__ */ ((ExternalEmitHelpers2) => { ExternalEmitHelpers2[ExternalEmitHelpers2["Extends"] = 1] = "Extends"; ExternalEmitHelpers2[ExternalEmitHelpers2["Assign"] = 2] = "Assign"; @@ -7096,6 +7113,7 @@ var ExternalEmitHelpers = /* @__PURE__ */ ((ExternalEmitHelpers2) => { ExternalEmitHelpers2[ExternalEmitHelpers2["SetFunctionName"] = 4194304] = "SetFunctionName"; ExternalEmitHelpers2[ExternalEmitHelpers2["PropKey"] = 8388608] = "PropKey"; ExternalEmitHelpers2[ExternalEmitHelpers2["AddDisposableResourceAndDisposeResources"] = 16777216] = "AddDisposableResourceAndDisposeResources"; + ExternalEmitHelpers2[ExternalEmitHelpers2["RewriteRelativeImportExtension"] = 33554432] = "RewriteRelativeImportExtension"; ExternalEmitHelpers2[ExternalEmitHelpers2["FirstEmitHelper"] = 1 /* Extends */] = "FirstEmitHelper"; ExternalEmitHelpers2[ExternalEmitHelpers2["LastEmitHelper"] = 16777216 /* AddDisposableResourceAndDisposeResources */] = "LastEmitHelper"; ExternalEmitHelpers2[ExternalEmitHelpers2["ForOfIncludes"] = 256 /* Values */] = "ForOfIncludes"; @@ -7257,12 +7275,12 @@ var commentPragmas = { kind: 4 /* MultiLine */ } }; -var JSDocParsingMode = /* @__PURE__ */ ((JSDocParsingMode6) => { - JSDocParsingMode6[JSDocParsingMode6["ParseAll"] = 0] = "ParseAll"; - JSDocParsingMode6[JSDocParsingMode6["ParseNone"] = 1] = "ParseNone"; - JSDocParsingMode6[JSDocParsingMode6["ParseForTypeErrors"] = 2] = "ParseForTypeErrors"; - JSDocParsingMode6[JSDocParsingMode6["ParseForTypeInfo"] = 3] = "ParseForTypeInfo"; - return JSDocParsingMode6; +var JSDocParsingMode = /* @__PURE__ */ ((JSDocParsingMode4) => { + JSDocParsingMode4[JSDocParsingMode4["ParseAll"] = 0] = "ParseAll"; + JSDocParsingMode4[JSDocParsingMode4["ParseNone"] = 1] = "ParseNone"; + JSDocParsingMode4[JSDocParsingMode4["ParseForTypeErrors"] = 2] = "ParseForTypeErrors"; + JSDocParsingMode4[JSDocParsingMode4["ParseForTypeInfo"] = 3] = "ParseForTypeInfo"; + return JSDocParsingMode4; })(JSDocParsingMode || {}); // src/compiler/sys.ts @@ -7996,6 +8014,7 @@ function createSystemWatchFunctions({ return generateWatchFileOptions(4 /* UseFsEvents */, 2 /* DynamicPriority */, options); case "UseFsEventsOnParentDirectory": useNonPollingWatchers2 = true; + // fall through default: return useNonPollingWatchers2 ? ( // Use notifications from FS to watch with falling back to fs.watchFile @@ -8244,6 +8263,7 @@ var sys = (() => { let profilePath = "./profile.cpuprofile"; const isMacOs = process.platform === "darwin"; const isLinuxOrMacOs = process.platform === "linux" || isMacOs; + const statSyncOptions = { throwIfNoEntry: false }; const platform = _os.platform(); const useCaseSensitiveFileNames2 = isFileSystemCaseSensitive(); const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync; @@ -8325,12 +8345,9 @@ var sys = (() => { return process.memoryUsage().heapUsed; }, getFileSize(path) { - try { - const stat = statSync(path); - if (stat == null ? void 0 : stat.isFile()) { - return stat.size; - } - } catch { + const stat = statSync(path); + if (stat == null ? void 0 : stat.isFile()) { + return stat.size; } return 0; }, @@ -8373,7 +8390,11 @@ var sys = (() => { }; return nodeSystem; function statSync(path) { - return _fs.statSync(path, { throwIfNoEntry: false }); + try { + return _fs.statSync(path, statSyncOptions); + } catch { + return void 0; + } } function enableCPUProfiler(path, cb) { if (activeSession) { @@ -8427,11 +8448,8 @@ var sys = (() => { activeSession.post("Profiler.stop", (err, { profile }) => { var _a; if (!err) { - try { - if ((_a = statSync(profilePath)) == null ? void 0 : _a.isDirectory()) { - profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`); - } - } catch { + if ((_a = statSync(profilePath)) == null ? void 0 : _a.isDirectory()) { + profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`); } try { _fs.mkdirSync(_path.dirname(profilePath), { recursive: true }); @@ -8550,12 +8568,8 @@ var sys = (() => { let stat; if (typeof dirent === "string" || dirent.isSymbolicLink()) { const name = combinePaths(path, entry); - try { - stat = statSync(name); - if (!stat) { - continue; - } - } catch { + stat = statSync(name); + if (!stat) { continue; } } else { @@ -8578,25 +8592,17 @@ var sys = (() => { return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath); } function fileSystemEntryExists(path, entryKind) { - const originalStackTraceLimit = Error.stackTraceLimit; - Error.stackTraceLimit = 0; - try { - const stat = statSync(path); - if (!stat) { - return false; - } - switch (entryKind) { - case 0 /* File */: - return stat.isFile(); - case 1 /* Directory */: - return stat.isDirectory(); - default: - return false; - } - } catch { + const stat = statSync(path); + if (!stat) { return false; - } finally { - Error.stackTraceLimit = originalStackTraceLimit; + } + switch (entryKind) { + case 0 /* File */: + return stat.isFile(); + case 1 /* Directory */: + return stat.isDirectory(); + default: + return false; } } function fileExists(path) { @@ -8620,15 +8626,7 @@ var sys = (() => { } function getModifiedTime3(path) { var _a; - const originalStackTraceLimit = Error.stackTraceLimit; - Error.stackTraceLimit = 0; - try { - return (_a = statSync(path)) == null ? void 0 : _a.mtime; - } catch { - return void 0; - } finally { - Error.stackTraceLimit = originalStackTraceLimit; - } + return (_a = statSync(path)) == null ? void 0 : _a.mtime; } function setModifiedTime(path, time) { try { @@ -9544,6 +9542,10 @@ var Diagnostics = { /*reportsDeprecated*/ true ), + Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: diag(1541, 1 /* Error */, "Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribut_1541", "Type-only import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."), + Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: diag(1542, 1 /* Error */, "Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute_1542", "Type import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."), + Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0: diag(1543, 1 /* Error */, "Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_mod_1543", `Importing a JSON file into an ECMAScript module requires a 'type: "json"' import attribute when 'module' is set to '{0}'.`), + Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0: diag(1544, 1 /* Error */, "Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0_1544", "Named imports from a JSON file into an ECMAScript module are not allowed when 'module' is set to '{0}'."), The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), Call_signature_return_types_0_and_1_are_incompatible: diag( @@ -10115,6 +10117,12 @@ var Diagnostics = { This_expression_is_always_nullish: diag(2871, 1 /* Error */, "This_expression_is_always_nullish_2871", "This expression is always nullish."), This_kind_of_expression_is_always_truthy: diag(2872, 1 /* Error */, "This_kind_of_expression_is_always_truthy_2872", "This kind of expression is always truthy."), This_kind_of_expression_is_always_falsy: diag(2873, 1 /* Error */, "This_kind_of_expression_is_always_falsy_2873", "This kind of expression is always falsy."), + This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found: diag(2874, 1 /* Error */, "This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found_2874", "This JSX tag requires '{0}' to be in scope, but it could not be found."), + This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed: diag(2875, 1 /* Error */, "This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_fo_2875", "This JSX tag requires the module path '{0}' to exist, but none could be found. Make sure you have types for the appropriate package installed."), + This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0: diag(2876, 1 /* Error */, "This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolv_2876", 'This relative import path is unsafe to rewrite because it looks like a file name, but actually resolves to "{0}".'), + This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path: diag(2877, 1 /* Error */, "This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_duri_2877", "This import uses a '{0}' extension to resolve to an input TypeScript file, but will not be rewritten during emit because it is not a relative path."), + This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files: diag(2878, 1 /* Error */, "This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_b_2878", "This import path is unsafe to rewrite because it resolves to another project, and the relative path between the projects' output files is not the same as the relative path between its input files."), + Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found: diag(2879, 1 /* Error */, "Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found_2879", "Using JSX fragments requires fragment factory '{0}' to be in scope, but it could not be found."), Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), @@ -10290,7 +10298,6 @@ var Diagnostics = { Option_0_1_has_been_removed_Please_remove_it_from_your_configuration: diag(5108, 1 /* Error */, "Option_0_1_has_been_removed_Please_remove_it_from_your_configuration_5108", "Option '{0}={1}' has been removed. Please remove it from your configuration."), Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1: diag(5109, 1 /* Error */, "Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1_5109", "Option 'moduleResolution' must be set to '{0}' (or left unspecified) when option 'module' is set to '{1}'."), Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1: diag(5110, 1 /* Error */, "Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1_5110", "Option 'module' must be set to '{0}' when option 'moduleResolution' is set to '{1}'."), - Option_tsBuildInfoFile_cannot_be_specified_without_specifying_option_incremental_or_composite_or_if_not_running_tsc_b: diag(5111, 1 /* Error */, "Option_tsBuildInfoFile_cannot_be_specified_without_specifying_option_incremental_or_composite_or_if__5111", "Option 'tsBuildInfoFile' cannot be specified without specifying option 'incremental' or 'composite' or if not running 'tsc -b'."), Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6e3, 3 /* Message */, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), Concatenate_and_emit_output_to_single_file: diag(6001, 3 /* Message */, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), Generates_corresponding_d_ts_file: diag(6002, 3 /* Message */, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), @@ -10672,6 +10679,7 @@ var Diagnostics = { Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0: diag(6418, 3 /* Message */, "Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0_6418", "Searching all ancestor node_modules directories for fallback extensions: {0}."), Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors: diag(6419, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors_6419", "Project '{0}' is out of date because buildinfo file '{1}' indicates that program needs to report errors."), Project_0_is_out_of_date_because_1: diag(6420, 3 /* Message */, "Project_0_is_out_of_date_because_1_6420", "Project '{0}' is out of date because {1}."), + Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files: diag(6421, 3 /* Message */, "Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_i_6421", "Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files."), The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* Message */, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), The_expected_type_comes_from_this_index_signature: diag(6501, 3 /* Message */, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, 3 /* Message */, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), @@ -10851,7 +10859,7 @@ var Diagnostics = { _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, 1 /* Error */, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."), _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, 1 /* Error */, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, 1 /* Error */, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), - Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation: diag(7025, 1 /* Error */, "Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_retu_7025", "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation."), + Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation: diag(7025, 1 /* Error */, "Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation_7025", "Generator implicitly has yield type '{0}'. Consider supplying a return type annotation."), JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, 1 /* Error */, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."), Unreachable_code_detected: diag( 7027, @@ -10942,7 +10950,7 @@ var Diagnostics = { Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."), Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9007, 1 /* Error */, "Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9007", "Function must have an explicit return type annotation with --isolatedDeclarations."), Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9008, 1 /* Error */, "Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9008", "Method must have an explicit return type annotation with --isolatedDeclarations."), - At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9009, 1 /* Error */, "At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9009", "At least one accessor must have an explicit return type annotation with --isolatedDeclarations."), + At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9009, 1 /* Error */, "At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9009", "At least one accessor must have an explicit type annotation with --isolatedDeclarations."), Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9010, 1 /* Error */, "Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9010", "Variable must have an explicit type annotation with --isolatedDeclarations."), Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9011, 1 /* Error */, "Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9011", "Parameter must have an explicit type annotation with --isolatedDeclarations."), Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9012, 1 /* Error */, "Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9012", "Property must have an explicit type annotation with --isolatedDeclarations."), @@ -10957,7 +10965,7 @@ var Diagnostics = { Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations: diag(9021, 1 /* Error */, "Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations_9021", "Extends clause can't contain an expression with --isolatedDeclarations."), Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations: diag(9022, 1 /* Error */, "Inference_from_class_expressions_is_not_supported_with_isolatedDeclarations_9022", "Inference from class expressions is not supported with --isolatedDeclarations."), Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function: diag(9023, 1 /* Error */, "Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations__9023", "Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function."), - Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_su_9025", "Declaration emit for this parameter requires implicitly adding undefined to it's type. This is not supported with --isolatedDeclarations."), + Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations: diag(9025, 1 /* Error */, "Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_sup_9025", "Declaration emit for this parameter requires implicitly adding undefined to its type. This is not supported with --isolatedDeclarations."), Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations: diag(9026, 1 /* Error */, "Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_support_9026", "Declaration emit for this file requires preserving this import for augmentations. This is not supported with --isolatedDeclarations."), Add_a_type_annotation_to_the_variable_0: diag(9027, 1 /* Error */, "Add_a_type_annotation_to_the_variable_0_9027", "Add a type annotation to the variable {0}."), Add_a_type_annotation_to_the_parameter_0: diag(9028, 1 /* Error */, "Add_a_type_annotation_to_the_parameter_0_9028", "Add a type annotation to the parameter {0}."), @@ -11251,6 +11259,8 @@ var Diagnostics = { Add_all_optional_parameters: diag(95193, 3 /* Message */, "Add_all_optional_parameters_95193", "Add all optional parameters"), Wrap_in_parentheses: diag(95194, 3 /* Message */, "Wrap_in_parentheses_95194", "Wrap in parentheses"), Wrap_all_invalid_decorator_expressions_in_parentheses: diag(95195, 3 /* Message */, "Wrap_all_invalid_decorator_expressions_in_parentheses_95195", "Wrap all invalid decorator expressions in parentheses"), + Add_resolution_mode_import_attribute: diag(95196, 3 /* Message */, "Add_resolution_mode_import_attribute_95196", "Add 'resolution-mode' import attribute"), + Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it: diag(95197, 3 /* Message */, "Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it_95197", "Add 'resolution-mode' import attribute to all type-only imports that need it"), No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), @@ -11305,15 +11315,20 @@ __export(deno_exports, { parseNpmPackageReference: () => parseNpmPackageReference, setIsNodeSourceFileCallback: () => setIsNodeSourceFileCallback, setNodeOnlyGlobalNames: () => setNodeOnlyGlobalNames, + setTypesNodeIgnorableNames: () => setTypesNodeIgnorableNames, tryParseNpmPackageReference: () => tryParseNpmPackageReference }); var isNodeSourceFile = () => false; var nodeOnlyGlobalNames = /* @__PURE__ */ new Set(); +var typesNodeIgnorableNames = /* @__PURE__ */ new Set(); function setIsNodeSourceFileCallback(callback) { isNodeSourceFile = callback; } function setNodeOnlyGlobalNames(names) { - nodeOnlyGlobalNames = new Set(names); + nodeOnlyGlobalNames = names; +} +function setTypesNodeIgnorableNames(names) { + typesNodeIgnorableNames = names; } function createDenoForkContext({ mergeSymbol, @@ -11337,12 +11352,31 @@ function createDenoForkContext({ function mergeGlobalSymbolTable(node, source, unidirectional = false) { const sourceFile = getSourceFileOfNode(node); const isNodeFile = hasNodeSourceFile(sourceFile); + const isTypesNodeSourceFile = isNodeFile && isTypesNodePkgPath(sourceFile.path); source.forEach((sourceSymbol, id) => { const target = isNodeFile ? getGlobalsForName(id) : globals; const targetSymbol = target.get(id); + if (isTypesNodeSourceFile && targetSymbol !== void 0 && typesNodeIgnorableNames.has(id) && !symbolHasAnyTypesNodePkgDecl(targetSymbol)) { + return; + } target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : sourceSymbol); }); } + function symbolHasAnyTypesNodePkgDecl(symbol) { + if (symbol.declarations) { + for (const decl of symbol.declarations) { + const sourceFile = getSourceFileOfNode(decl); + const isNodeFile = hasNodeSourceFile(sourceFile); + if (isNodeFile && isTypesNodePkgPath(sourceFile.path)) { + return true; + } + } + } + return false; + } + function isTypesNodePkgPath(path) { + return path.endsWith(".d.ts") && path.includes("/@types/node/"); + } function createNodeGlobalsSymbolTable() { return new Proxy(globals, { get(target, prop, receiver) { @@ -11610,11 +11644,11 @@ var charCodeToRegExpFlag = /* @__PURE__ */ new Map([ [121 /* y */, 128 /* Sticky */] ]); var regExpFlagToFirstAvailableLanguageVersion = /* @__PURE__ */ new Map([ - [1 /* HasIndices */, 9 /* RegularExpressionFlagsHasIndices */], - [16 /* DotAll */, 5 /* RegularExpressionFlagsDotAll */], - [32 /* Unicode */, 2 /* RegularExpressionFlagsUnicode */], - [64 /* UnicodeSets */, 99 /* RegularExpressionFlagsUnicodeSets */], - [128 /* Sticky */, 2 /* RegularExpressionFlagsSticky */] + [1 /* HasIndices */, LanguageFeatureMinimumTarget.RegularExpressionFlagsHasIndices], + [16 /* DotAll */, LanguageFeatureMinimumTarget.RegularExpressionFlagsDotAll], + [32 /* Unicode */, LanguageFeatureMinimumTarget.RegularExpressionFlagsUnicode], + [64 /* UnicodeSets */, LanguageFeatureMinimumTarget.RegularExpressionFlagsUnicodeSets], + [128 /* Sticky */, LanguageFeatureMinimumTarget.RegularExpressionFlagsSticky] ]); var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; @@ -11683,6 +11717,7 @@ function computeLineStarts(text) { if (text.charCodeAt(pos) === 10 /* lineFeed */) { pos++; } + // falls through case 10 /* lineFeed */: result.push(lineStart); lineStart = pos; @@ -11785,6 +11820,8 @@ function couldStartTrivia(text, pos) { case 12 /* formFeed */: case 32 /* space */: case 47 /* slash */: + // starts of normal trivia + // falls through case 60 /* lessThan */: case 124 /* bar */: case 61 /* equals */: @@ -11808,6 +11845,7 @@ function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) { if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) { pos++; } + // falls through case 10 /* lineFeed */: pos++; if (stopAfterLineBreak) { @@ -11954,6 +11992,7 @@ function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) { if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) { pos++; } + // falls through case 10 /* lineFeed */: pos++; if (trailing) { @@ -12519,12 +12558,16 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan if (pos >= end || !isDigit(charCodeUnchecked(pos))) { return "\0"; } + // '\01', '\011' + // falls through case 49 /* _1 */: case 50 /* _2 */: case 51 /* _3 */: if (pos < end && isOctalDigit(charCodeUnchecked(pos))) { pos++; } + // '\17', '\177' + // falls through case 52 /* _4 */: case 53 /* _5 */: case 54 /* _6 */: @@ -12622,10 +12665,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan } tokenFlags |= 4096 /* HexEscape */; return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16)); + // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence), + // the line terminator is interpreted to be "the empty code unit sequence". case 13 /* carriageReturn */: if (pos < end && charCodeUnchecked(pos) === 10 /* lineFeed */) { pos++; } + // falls through case 10 /* lineFeed */: case 8232 /* lineSeparator */: case 8233 /* paragraphSeparator */: @@ -13056,6 +13102,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan tokenFlags |= 256 /* OctalSpecifier */; return token = checkBigIntSuffix(); } + // falls through case 49 /* _1 */: case 50 /* _2 */: case 51 /* _3 */: @@ -13575,6 +13622,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan break; } } + // falls through case 42 /* asterisk */: case 43 /* plus */: case 63 /* question */: @@ -13605,6 +13653,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan if (isInGroup) { return; } + // falls through case 93 /* closeBracket */: case 125 /* closeBrace */: if (anyUnicodeModeOrNonAnnexB || ch === 41 /* closeParen */) { @@ -13667,6 +13716,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan error2(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2); break; } + // falls through default: Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape( /*atomEscape*/ @@ -13804,6 +13854,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan let start2 = pos; let operand; switch (text.slice(pos, pos + 2)) { + // TODO: don't use slice case "--": case "&&": error2(Diagnostics.Expected_a_class_set_operand); @@ -13909,6 +13960,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan } start2 = pos; switch (text.slice(pos, pos + 2)) { + // TODO: don't use slice case "--": case "&&": error2(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2); @@ -14006,6 +14058,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan } } pos--; + // falls through default: return scanClassSetCharacter(); } @@ -14152,6 +14205,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan return true; case 80 /* P */: isCharacterComplement = true; + // falls through case 112 /* p */: pos++; if (charCodeChecked(pos) === 123 /* openBrace */) { @@ -14459,6 +14513,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan if (charCodeUnchecked(pos) === 10 /* lineFeed */) { pos++; } + // falls through case 10 /* lineFeed */: tokenFlags |= 1 /* PrecedingLineBreak */; return token = 4 /* NewLineTrivia */; @@ -14663,28 +14718,35 @@ function isExternalModuleNameRelative(moduleName) { function sortAndDeduplicateDiagnostics(diagnostics) { return sortAndDeduplicate(diagnostics, compareDiagnostics, diagnosticsEqualityComparer); } +var targetToLibMap = /* @__PURE__ */ new Map([ + [99 /* ESNext */, "lib.esnext.full.d.ts"], + [11 /* ES2024 */, "lib.es2024.full.d.ts"], + [10 /* ES2023 */, "lib.es2023.full.d.ts"], + [9 /* ES2022 */, "lib.es2022.full.d.ts"], + [8 /* ES2021 */, "lib.es2021.full.d.ts"], + [7 /* ES2020 */, "lib.es2020.full.d.ts"], + [6 /* ES2019 */, "lib.es2019.full.d.ts"], + [5 /* ES2018 */, "lib.es2018.full.d.ts"], + [4 /* ES2017 */, "lib.es2017.full.d.ts"], + [3 /* ES2016 */, "lib.es2016.full.d.ts"], + [2 /* ES2015 */, "lib.es6.d.ts"] + // We don't use lib.es2015.full.d.ts due to breaking change. +]); function getDefaultLibFileName(options) { - switch (getEmitScriptTarget(options)) { + const target = getEmitScriptTarget(options); + switch (target) { case 99 /* ESNext */: - return "lib.esnext.full.d.ts"; + case 11 /* ES2024 */: case 10 /* ES2023 */: - return "lib.es2023.full.d.ts"; case 9 /* ES2022 */: - return "lib.es2022.full.d.ts"; case 8 /* ES2021 */: - return "lib.es2021.full.d.ts"; case 7 /* ES2020 */: - return "lib.es2020.full.d.ts"; case 6 /* ES2019 */: - return "lib.es2019.full.d.ts"; case 5 /* ES2018 */: - return "lib.es2018.full.d.ts"; case 4 /* ES2017 */: - return "lib.es2017.full.d.ts"; case 3 /* ES2016 */: - return "lib.es2016.full.d.ts"; case 2 /* ES2015 */: - return "lib.es6.d.ts"; + return targetToLibMap.get(target); default: return "lib.d.ts"; } @@ -15477,6 +15539,9 @@ function isTypeOnlyExportDeclaration(node) { function isTypeOnlyImportOrExportDeclaration(node) { return isTypeOnlyImportDeclaration(node) || isTypeOnlyExportDeclaration(node); } +function isPartOfTypeOnlyImportOrExportDeclaration(node) { + return findAncestor(node, isTypeOnlyImportOrExportDeclaration) !== void 0; +} function isStringTextContainingNode(node) { return node.kind === 11 /* StringLiteral */ || isTemplateLiteralKind(node.kind); } @@ -15625,7 +15690,7 @@ function isModifierLike(node) { } function isTypeElement(node) { const kind = node.kind; - return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */; + return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */ || kind === 354 /* NotEmittedTypeElement */; } function isClassOrTypeElement(node) { return isTypeElement(node) || isClassElement(node); @@ -15687,7 +15752,9 @@ function isObjectBindingOrAssignmentElement(node) { switch (node.kind) { case 208 /* BindingElement */: case 303 /* PropertyAssignment */: + // AssignmentProperty case 304 /* ShorthandPropertyAssignment */: + // AssignmentProperty case 305 /* SpreadAssignment */: return true; } @@ -15705,11 +15772,17 @@ function isArrayBindingOrAssignmentElement(node) { switch (node.kind) { case 208 /* BindingElement */: case 232 /* OmittedExpression */: + // Elision case 230 /* SpreadElement */: + // AssignmentRestElement case 209 /* ArrayLiteralExpression */: + // ArrayAssignmentPattern case 210 /* ObjectLiteralExpression */: + // ObjectAssignmentPattern case 80 /* Identifier */: + // DestructuringAssignmentTarget case 211 /* PropertyAccessExpression */: + // DestructuringAssignmentTarget case 212 /* ElementAccessExpression */: return true; } @@ -15732,13 +15805,16 @@ function isCallLikeOrFunctionLikeExpression(node) { } function isCallLikeExpression(node) { switch (node.kind) { - case 286 /* JsxOpeningElement */: - case 285 /* JsxSelfClosingElement */: case 213 /* CallExpression */: case 214 /* NewExpression */: case 215 /* TaggedTemplateExpression */: case 170 /* Decorator */: + case 286 /* JsxOpeningElement */: + case 285 /* JsxSelfClosingElement */: + case 289 /* JsxOpeningFragment */: return true; + case 226 /* BinaryExpression */: + return node.operatorToken.kind === 104 /* InstanceOfKeyword */; default: return false; } @@ -15770,6 +15846,7 @@ function isLeftHandSideExpressionKind(kind) { case 218 /* FunctionExpression */: case 80 /* Identifier */: case 81 /* PrivateIdentifier */: + // technically this is only an Expression if it's in a `#field in expr` BinaryExpression case 14 /* RegularExpressionLiteral */: case 9 /* NumericLiteral */: case 10 /* BigIntLiteral */: @@ -15785,6 +15862,7 @@ function isLeftHandSideExpressionKind(kind) { case 233 /* ExpressionWithTypeArguments */: case 236 /* MetaProperty */: case 102 /* ImportKeyword */: + // technically this is only an Expression if it's in a CallExpression case 282 /* MissingDeclaration */: return true; default: @@ -15841,8 +15919,8 @@ function isExpressionKind(kind) { case 230 /* SpreadElement */: case 234 /* AsExpression */: case 232 /* OmittedExpression */: - case 355 /* CommaListExpression */: - case 354 /* PartiallyEmittedExpression */: + case 356 /* CommaListExpression */: + case 355 /* PartiallyEmittedExpression */: case 238 /* SatisfiesExpression */: return true; default: @@ -16079,6 +16157,10 @@ function isJsxOpeningLikeElement(node) { const kind = node.kind; return kind === 286 /* JsxOpeningElement */ || kind === 285 /* JsxSelfClosingElement */; } +function isJsxCallLike(node) { + const kind = node.kind; + return kind === 286 /* JsxOpeningElement */ || kind === 285 /* JsxSelfClosingElement */ || kind === 289 /* JsxOpeningFragment */; +} function isCaseOrDefaultClause(node) { const kind = node.kind; return kind === 296 /* CaseClause */ || kind === 297 /* DefaultClause */; @@ -16719,11 +16801,45 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( AsyncIterator: new Map(Object.entries({ es2015: emptyArray })), + ArrayBuffer: new Map(Object.entries({ + es2024: [ + "maxByteLength", + "resizable", + "resize", + "detached", + "transfer", + "transferToFixedLength" + ] + })), Atomics: new Map(Object.entries({ - es2017: emptyArray + es2017: [ + "add", + "and", + "compareExchange", + "exchange", + "isLockFree", + "load", + "or", + "store", + "sub", + "wait", + "notify", + "xor" + ], + es2024: [ + "waitAsync" + ] })), SharedArrayBuffer: new Map(Object.entries({ - es2017: emptyArray + es2017: [ + "byteLength", + "slice" + ], + es2024: [ + "growable", + "maxByteLength", + "grow" + ] })), AsyncIterable: new Map(Object.entries({ es2018: emptyArray @@ -16745,6 +16861,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( ], es2018: [ "dotAll" + ], + es2024: [ + "unicodeSets" ] })), Reflect: new Map(Object.entries({ @@ -16791,6 +16910,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( ], es2022: [ "hasOwn" + ], + es2024: [ + "groupBy" ] })), NumberConstructor: new Map(Object.entries({ @@ -16831,11 +16953,25 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( "values" ] })), + MapConstructor: new Map(Object.entries({ + es2024: [ + "groupBy" + ] + })), Set: new Map(Object.entries({ es2015: [ "entries", "keys", "values" + ], + esnext: [ + "union", + "intersection", + "difference", + "symmetricDifference", + "isSubsetOf", + "isSupersetOf", + "isDisjointFrom" ] })), PromiseConstructor: new Map(Object.entries({ @@ -16850,6 +16986,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( ], es2021: [ "any" + ], + es2024: [ + "withResolvers" ] })), Symbol: new Map(Object.entries({ @@ -16916,7 +17055,7 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( es2022: [ "at" ], - esnext: [ + es2024: [ "isWellFormed", "toWellFormed" ] @@ -16961,6 +17100,11 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize( SymbolConstructor: new Map(Object.entries({ es2020: [ "matchAll" + ], + esnext: [ + "metadata", + "dispose", + "asyncDispose" ] })), DataView: new Map(Object.entries({ @@ -17581,6 +17725,8 @@ function getErrorSpanForNode(sourceFile, node) { } return getSpanOfTokenAtPosition(sourceFile, pos2); } + // This list is a work in progress. Add missing node kinds to improve their error + // spans. case 260 /* VariableDeclaration */: case 208 /* BindingElement */: case 263 /* ClassDeclaration */: @@ -17752,6 +17898,8 @@ function isPartOfTypeNode(node) { return isPartOfTypeExpressionWithTypeArguments(node); case 168 /* TypeParameter */: return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */; + // Identifiers and qualified names may be type nodes, depending on their context. Climb + // above them to find the lowest container case 80 /* Identifier */: if (node.parent.kind === 166 /* QualifiedName */ && node.parent.right === node) { node = node.parent; @@ -17759,6 +17907,7 @@ function isPartOfTypeNode(node) { node = node.parent; } Debug.assert(node.kind === 80 /* Identifier */ || node.kind === 166 /* QualifiedName */ || node.kind === 211 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."); + // falls through case 166 /* QualifiedName */: case 211 /* PropertyAccessExpression */: case 110 /* ThisKeyword */: { @@ -17900,9 +18049,6 @@ function isVariableLike(node) { } return false; } -function isVariableLikeOrAccessor(node) { - return isVariableLike(node) || isAccessor(node); -} function isVariableDeclarationInVariableStatement(node) { return node.parent.kind === 261 /* VariableDeclarationList */ && node.parent.parent.kind === 243 /* VariableStatement */; } @@ -18027,6 +18173,7 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope if (!includeArrowFunctions) { continue; } + // falls through case 262 /* FunctionDeclaration */: case 218 /* FunctionExpression */: case 267 /* ModuleDeclaration */: @@ -18049,6 +18196,8 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope } function isThisContainerOrFunctionBlock(node) { switch (node.kind) { + // Arrow functions use the same scope, but may do so in a "delayed" manner + // For example, `const getThis = () => this` may be before a super() call in a derived constructor case 219 /* ArrowFunction */: case 262 /* FunctionDeclaration */: case 218 /* FunctionExpression */: @@ -18115,6 +18264,7 @@ function getSuperContainer(node, stopOnFunctions) { if (!stopOnFunctions) { continue; } + // falls through case 172 /* PropertyDeclaration */: case 171 /* PropertySignature */: case 174 /* MethodDeclaration */: @@ -18168,6 +18318,7 @@ function getEntityNameFromTypeNode(node) { return node.typeName; case 233 /* ExpressionWithTypeArguments */: return isEntityNameExpression(node.expression) ? node.expression : void 0; + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. case 80 /* Identifier */: case 166 /* QualifiedName */: return node; @@ -18183,6 +18334,8 @@ function getInvokedExpression(node) { return node.tagName; case 226 /* BinaryExpression */: return node.right; + case 289 /* JsxOpeningFragment */: + return node; default: return node.expression; } @@ -18332,6 +18485,7 @@ function isExpressionNode(node) { if (node.parent.kind === 186 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node)) { return true; } + // falls through case 9 /* NumericLiteral */: case 10 /* BigIntLiteral */: case 11 /* StringLiteral */: @@ -18786,12 +18940,17 @@ function tryGetImportFromModuleSpecifier(node) { false ) ? node.parent : void 0; case 201 /* LiteralType */: - Debug.assert(isStringLiteral(node)); + if (!isStringLiteral(node)) { + break; + } return tryCast(node.parent.parent, isImportTypeNode); default: return void 0; } } +function shouldRewriteModuleSpecifier(specifier, compilerOptions) { + return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier) && hasTSFileExtension(specifier); +} function getExternalModuleName(node) { switch (node.kind) { case 272 /* ImportDeclaration */: @@ -18836,17 +18995,15 @@ function forEachImportClauseDeclaration(node, action) { } } function hasQuestionToken(node) { - if (node) { - switch (node.kind) { - case 169 /* Parameter */: - case 174 /* MethodDeclaration */: - case 173 /* MethodSignature */: - case 304 /* ShorthandPropertyAssignment */: - case 303 /* PropertyAssignment */: - case 172 /* PropertyDeclaration */: - case 171 /* PropertySignature */: - return node.questionToken !== void 0; - } + switch (node.kind) { + case 169 /* Parameter */: + case 174 /* MethodDeclaration */: + case 173 /* MethodSignature */: + case 304 /* ShorthandPropertyAssignment */: + case 303 /* PropertyAssignment */: + case 172 /* PropertyDeclaration */: + case 171 /* PropertySignature */: + return node.questionToken !== void 0; } return false; } @@ -19246,6 +19403,7 @@ function getDeclarationFromName(name) { case 15 /* NoSubstitutionTemplateLiteral */: case 9 /* NumericLiteral */: if (isComputedPropertyName(parent2)) return parent2.parent; + // falls through case 80 /* Identifier */: if (isDeclaration(parent2)) { return parent2.name === name ? parent2 : void 0; @@ -19416,6 +19574,7 @@ function getFunctionFlags(node) { if (node.asteriskToken) { flags |= 1 /* Generator */; } + // falls through case 219 /* ArrowFunction */: if (hasSyntacticModifier(node, 1024 /* Async */)) { flags |= 2 /* Async */; @@ -19686,7 +19845,7 @@ var OperatorPrecedence = /* @__PURE__ */ ((OperatorPrecedence2) => { })(OperatorPrecedence || {}); function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { switch (nodeKind) { - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return 0 /* Comma */; case 230 /* SpreadElement */: return 1 /* Spread */; @@ -19718,6 +19877,7 @@ function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { default: return getBinaryOperatorPrecedence(operatorKind); } + // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? case 216 /* TypeAssertionExpression */: case 235 /* NonNullExpression */: case 224 /* PrefixUnaryExpression */: @@ -19900,7 +20060,7 @@ function hasInvalidEscape(template) { } var doubleQuoteEscapedCharsRegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g; var singleQuoteEscapedCharsRegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g; -var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u001f\u2028\u2029\u0085]/g; +var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g; var escapedCharsMap = new Map(Object.entries({ " ": "\\t", "\v": "\\v", @@ -20220,6 +20380,12 @@ function getDeclarationEmitExtensionForPath(path) { function getPossibleOriginalInputExtensionForExtension(path) { return fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] : fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] : fileExtensionIsOneOf(path, [`.d.json.ts`]) ? [".json" /* Json */] : [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */]; } +function getPossibleOriginalInputPathWithoutChangingExt(filePath, ignoreCase, outputDir, getCommonSourceDirectory2) { + return outputDir ? resolvePath( + getCommonSourceDirectory2(), + getRelativePathFromDirectory(outputDir, filePath, ignoreCase) + ) : filePath; +} function getPathsBasePath(options, host) { var _a; if (!options.paths) return void 0; @@ -21093,6 +21259,12 @@ function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sour ); return getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos)); } +function rangeContainsRange(r1, r2) { + return startEndContainsRange(r1.pos, r1.end, r2); +} +function startEndContainsRange(start, end, range) { + return start <= range.pos && end >= range.end; +} function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) { while (pos-- > stopPos) { if (!isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) { @@ -21177,6 +21349,9 @@ function accessKind(node) { return node === parent2.objectAssignmentInitializer ? 0 /* Read */ : accessKind(parent2.parent); case 209 /* ArrayLiteralExpression */: return accessKind(parent2); + case 249 /* ForInStatement */: + case 250 /* ForOfStatement */: + return node === parent2.initializer ? 1 /* Write */ : 0 /* Read */; default: return 0 /* Read */; } @@ -21269,11 +21444,11 @@ function getLastChild(node) { }); return lastChild; } -function addToSeen(seen, key, value = true) { +function addToSeen(seen, key) { if (seen.has(key)) { return false; } - seen.set(key, value); + seen.add(key); return true; } function isObjectTypeDeclaration(node) { @@ -21349,11 +21524,12 @@ function getLeftmostExpression(node, stopAtCallExpressions) { if (stopAtCallExpressions) { return node; } + // falls through case 234 /* AsExpression */: case 212 /* ElementAccessExpression */: case 211 /* PropertyAccessExpression */: case 235 /* NonNullExpression */: - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: case 238 /* SatisfiesExpression */: node = node.expression; continue; @@ -21753,7 +21929,13 @@ function importSyntaxAffectsModuleResolution(options) { function createComputedCompilerOptions(options) { return options; } -var computedOptions = createComputedCompilerOptions({ +var _computedOptions = createComputedCompilerOptions({ + allowImportingTsExtensions: { + dependencies: ["rewriteRelativeImportExtensions"], + computeValue: (compilerOptions) => { + return !!(compilerOptions.allowImportingTsExtensions || compilerOptions.rewriteRelativeImportExtensions); + } + }, target: { dependencies: ["module"], computeValue: (compilerOptions) => { @@ -21764,7 +21946,7 @@ var computedOptions = createComputedCompilerOptions({ module: { dependencies: ["target"], computeValue: (compilerOptions) => { - return typeof compilerOptions.module === "number" ? compilerOptions.module : computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */; + return typeof compilerOptions.module === "number" ? compilerOptions.module : _computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */; } }, moduleResolution: { @@ -21772,7 +21954,7 @@ var computedOptions = createComputedCompilerOptions({ computeValue: (compilerOptions) => { let moduleResolution = compilerOptions.moduleResolution; if (moduleResolution === void 0) { - switch (computedOptions.module.computeValue(compilerOptions)) { + switch (_computedOptions.module.computeValue(compilerOptions)) { case 1 /* CommonJS */: moduleResolution = 2 /* Node10 */; break; @@ -21796,7 +21978,7 @@ var computedOptions = createComputedCompilerOptions({ moduleDetection: { dependencies: ["module", "target"], computeValue: (compilerOptions) => { - return compilerOptions.moduleDetection || (computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */); + return compilerOptions.moduleDetection || (_computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || _computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */); } }, isolatedModules: { @@ -21811,7 +21993,7 @@ var computedOptions = createComputedCompilerOptions({ if (compilerOptions.esModuleInterop !== void 0) { return compilerOptions.esModuleInterop; } - switch (computedOptions.module.computeValue(compilerOptions)) { + switch (_computedOptions.module.computeValue(compilerOptions)) { case 100 /* Node16 */: case 199 /* NodeNext */: case 200 /* Preserve */: @@ -21826,13 +22008,13 @@ var computedOptions = createComputedCompilerOptions({ if (compilerOptions.allowSyntheticDefaultImports !== void 0) { return compilerOptions.allowSyntheticDefaultImports; } - return computedOptions.esModuleInterop.computeValue(compilerOptions) || computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */; + return _computedOptions.esModuleInterop.computeValue(compilerOptions) || _computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || _computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */; } }, resolvePackageJsonExports: { dependencies: ["moduleResolution"], computeValue: (compilerOptions) => { - const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions); + const moduleResolution = _computedOptions.moduleResolution.computeValue(compilerOptions); if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) { return false; } @@ -21851,7 +22033,7 @@ var computedOptions = createComputedCompilerOptions({ resolvePackageJsonImports: { dependencies: ["moduleResolution", "resolvePackageJsonExports"], computeValue: (compilerOptions) => { - const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions); + const moduleResolution = _computedOptions.moduleResolution.computeValue(compilerOptions); if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) { return false; } @@ -21873,7 +22055,7 @@ var computedOptions = createComputedCompilerOptions({ if (compilerOptions.resolveJsonModule !== void 0) { return compilerOptions.resolveJsonModule; } - return computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */; + return _computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */; } }, declaration: { @@ -21885,7 +22067,7 @@ var computedOptions = createComputedCompilerOptions({ preserveConstEnums: { dependencies: ["isolatedModules", "verbatimModuleSyntax"], computeValue: (compilerOptions) => { - return !!(compilerOptions.preserveConstEnums || computedOptions.isolatedModules.computeValue(compilerOptions)); + return !!(compilerOptions.preserveConstEnums || _computedOptions.isolatedModules.computeValue(compilerOptions)); } }, incremental: { @@ -21897,7 +22079,7 @@ var computedOptions = createComputedCompilerOptions({ declarationMap: { dependencies: ["declaration", "composite"], computeValue: (compilerOptions) => { - return !!(compilerOptions.declarationMap && computedOptions.declaration.computeValue(compilerOptions)); + return !!(compilerOptions.declarationMap && _computedOptions.declaration.computeValue(compilerOptions)); } }, allowJs: { @@ -21909,7 +22091,7 @@ var computedOptions = createComputedCompilerOptions({ useDefineForClassFields: { dependencies: ["target", "module"], computeValue: (compilerOptions) => { - return compilerOptions.useDefineForClassFields === void 0 ? computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields; + return compilerOptions.useDefineForClassFields === void 0 ? _computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields; } }, noImplicitAny: { @@ -21967,22 +22149,24 @@ var computedOptions = createComputedCompilerOptions({ } } }); -var getEmitScriptTarget = computedOptions.target.computeValue; -var getEmitModuleKind = computedOptions.module.computeValue; -var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue; -var getEmitModuleDetectionKind = computedOptions.moduleDetection.computeValue; -var getIsolatedModules = computedOptions.isolatedModules.computeValue; -var getESModuleInterop = computedOptions.esModuleInterop.computeValue; -var getAllowSyntheticDefaultImports = computedOptions.allowSyntheticDefaultImports.computeValue; -var getResolvePackageJsonExports = computedOptions.resolvePackageJsonExports.computeValue; -var getResolvePackageJsonImports = computedOptions.resolvePackageJsonImports.computeValue; -var getResolveJsonModule = computedOptions.resolveJsonModule.computeValue; -var getEmitDeclarations = computedOptions.declaration.computeValue; -var shouldPreserveConstEnums = computedOptions.preserveConstEnums.computeValue; -var isIncrementalCompilation = computedOptions.incremental.computeValue; -var getAreDeclarationMapsEnabled = computedOptions.declarationMap.computeValue; -var getAllowJSCompilerOption = computedOptions.allowJs.computeValue; -var getUseDefineForClassFields = computedOptions.useDefineForClassFields.computeValue; +var computedOptions = _computedOptions; +var getAllowImportingTsExtensions = _computedOptions.allowImportingTsExtensions.computeValue; +var getEmitScriptTarget = _computedOptions.target.computeValue; +var getEmitModuleKind = _computedOptions.module.computeValue; +var getEmitModuleResolutionKind = _computedOptions.moduleResolution.computeValue; +var getEmitModuleDetectionKind = _computedOptions.moduleDetection.computeValue; +var getIsolatedModules = _computedOptions.isolatedModules.computeValue; +var getESModuleInterop = _computedOptions.esModuleInterop.computeValue; +var getAllowSyntheticDefaultImports = _computedOptions.allowSyntheticDefaultImports.computeValue; +var getResolvePackageJsonExports = _computedOptions.resolvePackageJsonExports.computeValue; +var getResolvePackageJsonImports = _computedOptions.resolvePackageJsonImports.computeValue; +var getResolveJsonModule = _computedOptions.resolveJsonModule.computeValue; +var getEmitDeclarations = _computedOptions.declaration.computeValue; +var shouldPreserveConstEnums = _computedOptions.preserveConstEnums.computeValue; +var isIncrementalCompilation = _computedOptions.incremental.computeValue; +var getAreDeclarationMapsEnabled = _computedOptions.declarationMap.computeValue; +var getAllowJSCompilerOption = _computedOptions.allowJs.computeValue; +var getUseDefineForClassFields = _computedOptions.useDefineForClassFields.computeValue; function emitModuleKindIsNonNodeESM(moduleKind) { return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */; } @@ -22527,8 +22711,33 @@ function tryParsePattern(pattern) { suffix: pattern.substr(indexOfStar + 1) }; } +var parsedPatternsCache = /* @__PURE__ */ new WeakMap(); function tryParsePatterns(paths) { - return mapDefined(getOwnKeys(paths), (path) => tryParsePattern(path)); + let result = parsedPatternsCache.get(paths); + if (result !== void 0) { + return result; + } + let matchableStringSet; + let patterns; + const pathList = getOwnKeys(paths); + for (const path of pathList) { + const patternOrStr = tryParsePattern(path); + if (patternOrStr === void 0) { + continue; + } else if (typeof patternOrStr === "string") { + (matchableStringSet ?? (matchableStringSet = /* @__PURE__ */ new Set())).add(patternOrStr); + } else { + (patterns ?? (patterns = [])).push(patternOrStr); + } + } + parsedPatternsCache.set( + paths, + result = { + matchableStringSet, + patterns + } + ); + return result; } function positionIsSynthesized(pos) { return !(pos >= 0); @@ -22556,15 +22765,13 @@ var emptyFileSystemEntries = { files: emptyArray, directories: emptyArray }; -function matchPatternOrExact(patternOrStrings, candidate) { - const patterns = []; - for (const patternOrString of patternOrStrings) { - if (patternOrString === candidate) { - return candidate; - } - if (!isString(patternOrString)) { - patterns.push(patternOrString); - } +function matchPatternOrExact(parsedPatterns, candidate) { + const { matchableStringSet, patterns } = parsedPatterns; + if (matchableStringSet == null ? void 0 : matchableStringSet.has(candidate)) { + return candidate; + } + if (patterns === void 0 || patterns.length === 0) { + return void 0; } return findBestPatternMatch(patterns, (_) => _, candidate); } @@ -22641,6 +22848,7 @@ function isJsonEqual(a, b) { function parsePseudoBigInt(stringValue) { let log2Base; switch (stringValue.charCodeAt(1)) { + // "x" in "0x123" case 98 /* b */: case 66 /* B */: log2Base = 1; @@ -22888,7 +23096,7 @@ function getContainingNodeArray(node) { return parent2.types; case 189 /* TupleType */: case 209 /* ArrayLiteralExpression */: - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: case 275 /* NamedImports */: case 279 /* NamedExports */: return parent2.elements; @@ -23429,6 +23637,7 @@ function createNameResolver({ switch (location.kind) { case 307 /* SourceFile */: if (!isExternalOrCommonJsModule(location)) break; + // falls through case 267 /* ModuleDeclaration */: const moduleExports = ((_a = getSymbolOfDeclaration(location)) == null ? void 0 : _a.exports) || emptySymbols; if (location.kind === 307 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 33554432 /* Ambient */ && !isGlobalScopeAugmentation(location)) { @@ -23512,6 +23721,14 @@ function createNameResolver({ } } break; + // It is not legal to reference a class's own type parameters from a computed property name that + // belongs to the class. For example: + // + // function foo() { return '' } + // class C { // <-- Class's own type parameter T + // [foo()]() { } // <-- Reference to T from class's own computed property + // } + // case 167 /* ComputedPropertyName */: grandparent = location.parent.parent; if (isClassLike(grandparent) || grandparent.kind === 264 /* InterfaceDeclaration */) { @@ -23527,6 +23744,7 @@ function createNameResolver({ if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) { break; } + // falls through case 174 /* MethodDeclaration */: case 176 /* Constructor */: case 177 /* GetAccessor */: @@ -23774,6 +23992,9 @@ function hasInferredType(node) { case 260 /* VariableDeclaration */: case 277 /* ExportAssignment */: case 303 /* PropertyAssignment */: + case 304 /* ShorthandPropertyAssignment */: + case 341 /* JSDocParameterTag */: + case 348 /* JSDocPropertyTag */: return true; default: assertType(node); @@ -23784,6 +24005,118 @@ function isSideEffectImport(node) { const ancestor = findAncestor(node, isImportDeclaration); return !!ancestor && !ancestor.importClause; } +var unprefixedNodeCoreModulesList = [ + "assert", + "assert/strict", + "async_hooks", + "buffer", + "child_process", + "cluster", + "console", + "constants", + "crypto", + "dgram", + "diagnostics_channel", + "dns", + "dns/promises", + "domain", + "events", + "fs", + "fs/promises", + "http", + "http2", + "https", + "inspector", + "inspector/promises", + "module", + "net", + "os", + "path", + "path/posix", + "path/win32", + "perf_hooks", + "process", + "punycode", + "querystring", + "readline", + "readline/promises", + "repl", + "stream", + "stream/consumers", + "stream/promises", + "stream/web", + "string_decoder", + "sys", + "test/mock_loader", + "timers", + "timers/promises", + "tls", + "trace_events", + "tty", + "url", + "util", + "util/types", + "v8", + "vm", + "wasi", + "worker_threads", + "zlib" +]; +var unprefixedNodeCoreModules = new Set(unprefixedNodeCoreModulesList); +var exclusivelyPrefixedNodeCoreModules = /* @__PURE__ */ new Set([ + "node:sea", + "node:sqlite", + "node:test", + "node:test/reporters" +]); +var nodeCoreModules = /* @__PURE__ */ new Set([ + ...unprefixedNodeCoreModulesList, + ...unprefixedNodeCoreModulesList.map((name) => `node:${name}`), + ...exclusivelyPrefixedNodeCoreModules +]); +function forEachDynamicImportOrRequireCall(file, includeTypeSpaceImports, requireStringLiteralLikeArgument, cb) { + const isJavaScriptFile = isInJSFile(file); + const r = /import|require/g; + while (r.exec(file.text) !== null) { + const node = getNodeAtPosition( + file, + r.lastIndex, + /*includeJSDoc*/ + includeTypeSpaceImports + ); + if (isJavaScriptFile && isRequireCall(node, requireStringLiteralLikeArgument)) { + cb(node, node.arguments[0]); + } else if (isImportCall(node) && node.arguments.length >= 1 && (!requireStringLiteralLikeArgument || isStringLiteralLike(node.arguments[0]))) { + cb(node, node.arguments[0]); + } else if (includeTypeSpaceImports && isLiteralImportTypeNode(node)) { + cb(node, node.argument.literal); + } else if (includeTypeSpaceImports && isJSDocImportTag(node)) { + const moduleNameExpr = getExternalModuleName(node); + if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text) { + cb(node, moduleNameExpr); + } + } + } +} +function getNodeAtPosition(sourceFile, position, includeJSDoc) { + const isJavaScriptFile = isInJSFile(sourceFile); + let current = sourceFile; + const getContainingChild = (child) => { + if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) { + return child; + } + }; + while (true) { + const child = isJavaScriptFile && includeJSDoc && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild); + if (!child) { + return current; + } + current = child; + } +} +function isNewScopeNode(node) { + return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node); +} // src/compiler/factory/baseNodeFactory.ts function createBaseNodeFactory() { @@ -24107,6 +24440,7 @@ function createParenthesizerRules(factory2) { function parenthesizeConstituentTypeOfUnionType(type) { switch (type.kind) { case 192 /* UnionType */: + // Not strictly necessary, but a union containing a union should have been flattened case 193 /* IntersectionType */: return factory2.createParenthesizedType(type); } @@ -24888,6 +25222,7 @@ function createNodeFactory(flags, baseFactory2) { createSyntheticExpression, createSyntaxList: createSyntaxList3, createNotEmittedStatement, + createNotEmittedTypeElement, createPartiallyEmittedExpression, updatePartiallyEmittedExpression, createCommaListExpression, @@ -27914,7 +28249,7 @@ function createNodeFactory(flags, baseFactory2) { return node; } function createPartiallyEmittedExpression(expression, original) { - const node = createBaseNode(354 /* PartiallyEmittedExpression */); + const node = createBaseNode(355 /* PartiallyEmittedExpression */); node.expression = expression; node.original = original; node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */; @@ -27924,6 +28259,9 @@ function createNodeFactory(flags, baseFactory2) { function updatePartiallyEmittedExpression(node, expression) { return node.expression !== expression ? update(createPartiallyEmittedExpression(expression, node.original), node) : node; } + function createNotEmittedTypeElement() { + return createBaseNode(354 /* NotEmittedTypeElement */); + } function flattenCommaElements(node) { if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) { if (isCommaListExpression(node)) { @@ -27936,7 +28274,7 @@ function createNodeFactory(flags, baseFactory2) { return node; } function createCommaListExpression(elements) { - const node = createBaseNode(355 /* CommaListExpression */); + const node = createBaseNode(356 /* CommaListExpression */); node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements)); node.transformFlags |= propagateChildrenFlags(node.elements); return node; @@ -27945,7 +28283,7 @@ function createNodeFactory(flags, baseFactory2) { return node.elements !== elements ? update(createCommaListExpression(elements), node) : node; } function createSyntheticReferenceExpression(expression, thisArg) { - const node = createBaseNode(356 /* SyntheticReferenceExpression */); + const node = createBaseNode(357 /* SyntheticReferenceExpression */); node.expression = expression; node.thisArg = thisArg; node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg); @@ -28192,7 +28530,7 @@ function createNodeFactory(flags, baseFactory2) { return updateNonNullExpression(outerExpression, expression); case 233 /* ExpressionWithTypeArguments */: return updateExpressionWithTypeArguments(outerExpression, expression, outerExpression.typeArguments); - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return updatePartiallyEmittedExpression(outerExpression, expression); } } @@ -28737,7 +29075,7 @@ function getTransformFlagsSubtreeExclusions(kind) { case 216 /* TypeAssertionExpression */: case 238 /* SatisfiesExpression */: case 234 /* AsExpression */: - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: case 217 /* ParenthesizedExpression */: case 108 /* SuperKeyword */: return -2147483648 /* OuterExpressionExcludes */; @@ -29110,7 +29448,9 @@ function createEmitHelperFactory(context) { createClassPrivateFieldInHelper, // 'using' helpers createAddDisposableResourceHelper, - createDisposeResourcesHelper + createDisposeResourcesHelper, + // --rewriteRelativeImportExtensions helpers + createRewriteRelativeImportExtensionsHelper }; function getUnscopedHelperName(name) { return setEmitFlags(factory2.createIdentifier(name), 8192 /* HelperName */ | 4 /* AdviseOnEmitNode */); @@ -29599,6 +29939,15 @@ function createEmitHelperFactory(context) { [envBinding] ); } + function createRewriteRelativeImportExtensionsHelper(expression) { + context.requestEmitHelper(rewriteRelativeImportExtensionsHelper); + return factory2.createCallExpression( + getUnscopedHelperName("__rewriteRelativeImportExtension"), + /*typeArguments*/ + void 0, + context.getCompilerOptions().jsx === 1 /* Preserve */ ? [expression, factory2.createTrue()] : [expression] + ); + } } function compareEmitHelpers(x, y) { if (x === y) return 0 /* EqualTo */; @@ -29979,13 +30328,23 @@ var importStarHelper = { dependencies: [createBindingHelper, setModuleDefaultHelper], priority: 2, text: ` - var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; - };` + var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; + })();` }; var importDefaultHelper = { name: "typescript:commonjsimportdefault", @@ -30104,6 +30463,20 @@ var disposeResourcesHelper = { return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; });` }; +var rewriteRelativeImportExtensionsHelper = { + name: "typescript:rewriteRelativeImportExtensions", + importName: "__rewriteRelativeImportExtension", + scoped: false, + text: ` + var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) { + if (typeof path === "string" && /^\\.\\.?\\//.test(path)) { + return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) { + return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js"); + }); + } + return path; + };` +}; var asyncSuperHelper = { name: "typescript:async-super", scoped: true, @@ -30446,10 +30819,10 @@ function isSyntheticExpression(node) { return node.kind === 237 /* SyntheticExpression */; } function isPartiallyEmittedExpression(node) { - return node.kind === 354 /* PartiallyEmittedExpression */; + return node.kind === 355 /* PartiallyEmittedExpression */; } function isCommaListExpression(node) { - return node.kind === 355 /* CommaListExpression */; + return node.kind === 356 /* CommaListExpression */; } function isTemplateSpan(node) { return node.kind === 239 /* TemplateSpan */; @@ -30605,7 +30978,7 @@ function isNotEmittedStatement(node) { return node.kind === 353 /* NotEmittedStatement */; } function isSyntheticReference(node) { - return node.kind === 356 /* SyntheticReferenceExpression */; + return node.kind === 357 /* SyntheticReferenceExpression */; } function isExternalModuleReference(node) { return node.kind === 283 /* ExternalModuleReference */; @@ -31228,7 +31601,7 @@ function isOuterExpression(node, kinds = 31 /* All */) { return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0; case 235 /* NonNullExpression */: return (kinds & 4 /* NonNullAssertions */) !== 0; - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0; } return false; @@ -31266,23 +31639,21 @@ function hasRecordedExternalHelpers(sourceFile) { } function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) { if (compilerOptions.importHelpers && isEffectiveExternalModule(sourceFile, compilerOptions)) { - let namedBindings; const moduleKind = getEmitModuleKind(compilerOptions); - if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || getImpliedNodeFormatForEmitWorker(sourceFile, compilerOptions) === 99 /* ESNext */) { - const helpers = getEmitHelpers(sourceFile); + const impliedModuleKind = getImpliedNodeFormatForEmitWorker(sourceFile, compilerOptions); + const helpers = getImportedHelpers(sourceFile); + if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || impliedModuleKind === 99 /* ESNext */ || impliedModuleKind === void 0 && moduleKind === 200 /* Preserve */) { if (helpers) { const helperNames = []; for (const helper of helpers) { - if (!helper.scoped) { - const importName = helper.importName; - if (importName) { - pushIfUnique(helperNames, importName); - } + const importName = helper.importName; + if (importName) { + pushIfUnique(helperNames, importName); } } if (some(helperNames)) { helperNames.sort(compareStringsCaseSensitive); - namedBindings = nodeFactory.createNamedImports( + const namedBindings = nodeFactory.createNamedImports( map(helperNames, (name) => isFileLevelUniqueName(sourceFile, name) ? nodeFactory.createImportSpecifier( /*isTypeOnly*/ false, @@ -31299,57 +31670,54 @@ function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFacto const parseNode = getOriginalNode(sourceFile, isSourceFile); const emitNode = getOrCreateEmitNode(parseNode); emitNode.externalHelpers = true; + const externalHelpersImportDeclaration = nodeFactory.createImportDeclaration( + /*modifiers*/ + void 0, + nodeFactory.createImportClause( + /*isTypeOnly*/ + false, + /*name*/ + void 0, + namedBindings + ), + nodeFactory.createStringLiteral(externalHelpersModuleNameText), + /*attributes*/ + void 0 + ); + addInternalEmitFlags(externalHelpersImportDeclaration, 2 /* NeverApplyImportHelper */); + return externalHelpersImportDeclaration; } } } else { - const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault); + const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, helpers, hasExportStarsToExportValues, hasImportStar || hasImportDefault); if (externalHelpersModuleName) { - namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName); - } - } - if (namedBindings) { - const externalHelpersImportDeclaration = nodeFactory.createImportDeclaration( - /*modifiers*/ - void 0, - nodeFactory.createImportClause( + const externalHelpersImportDeclaration = nodeFactory.createImportEqualsDeclaration( + /*modifiers*/ + void 0, /*isTypeOnly*/ false, - /*name*/ - void 0, - namedBindings - ), - nodeFactory.createStringLiteral(externalHelpersModuleNameText), - /*attributes*/ - void 0 - ); - addInternalEmitFlags(externalHelpersImportDeclaration, 2 /* NeverApplyImportHelper */); - return externalHelpersImportDeclaration; + externalHelpersModuleName, + nodeFactory.createExternalModuleReference(nodeFactory.createStringLiteral(externalHelpersModuleNameText)) + ); + addInternalEmitFlags(externalHelpersImportDeclaration, 2 /* NeverApplyImportHelper */); + return externalHelpersImportDeclaration; + } } } } -function getOrCreateExternalHelpersModuleNameIfNeeded(factory2, node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) { - if (compilerOptions.importHelpers && isEffectiveExternalModule(node, compilerOptions)) { - const externalHelpersModuleName = getExternalHelpersModuleName(node); - if (externalHelpersModuleName) { - return externalHelpersModuleName; - } - let create = (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && getEmitModuleFormatOfFileWorker(node, compilerOptions) < 4 /* System */; - if (!create) { - const helpers = getEmitHelpers(node); - if (helpers) { - for (const helper of helpers) { - if (!helper.scoped) { - create = true; - break; - } - } - } - } - if (create) { - const parseNode = getOriginalNode(node, isSourceFile); - const emitNode = getOrCreateEmitNode(parseNode); - return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory2.createUniqueName(externalHelpersModuleNameText)); - } +function getImportedHelpers(sourceFile) { + return filter(getEmitHelpers(sourceFile), (helper) => !helper.scoped); +} +function getOrCreateExternalHelpersModuleNameIfNeeded(factory2, node, compilerOptions, helpers, hasExportStarsToExportValues, hasImportStarOrImportDefault) { + const externalHelpersModuleName = getExternalHelpersModuleName(node); + if (externalHelpersModuleName) { + return externalHelpersModuleName; + } + const create = some(helpers) || (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && getEmitModuleFormatOfFileWorker(node, compilerOptions) < 4 /* System */; + if (create) { + const parseNode = getOriginalNode(node, isSourceFile); + const emitNode = getOrCreateEmitNode(parseNode); + return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory2.createUniqueName(externalHelpersModuleNameText)); } } function getLocalNameForExternalImport(factory2, node, sourceFile) { @@ -31672,10 +32040,13 @@ var BinaryExpressionState; switch (currentState) { case enter: if (machine.onLeft) return left; + // falls through case left: if (machine.onOperator) return operator; + // falls through case operator: if (machine.onRight) return right; + // falls through case right: return exit; case exit: @@ -32303,7 +32674,7 @@ var forEachChildTable = { [282 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) { return visitNodes(cbNode, cbNodes, node.modifiers); }, - [355 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) { + [356 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) { return visitNodes(cbNode, cbNodes, node.elements); }, [284 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) { @@ -32399,7 +32770,7 @@ var forEachChildTable = { [331 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag, [337 /* JSDocOverrideTag */]: forEachChildInJSDocTag, [351 /* JSDocImportTag */]: forEachChildInJSDocImportTag, - [354 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression + [355 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression }; function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) { return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type); @@ -32769,6 +33140,7 @@ var Parser; expression2 = parseLiteralNode(); break; } + // falls through default: expression2 = parseObjectLiteralExpression(); break; @@ -33610,10 +33982,12 @@ var Parser; case 90 /* DefaultKeyword */: return nextTokenCanFollowDefaultKeyword(); case 126 /* StaticKeyword */: + nextToken(); + return canFollowModifier(); case 139 /* GetKeyword */: case 153 /* SetKeyword */: nextToken(); - return canFollowModifier(); + return canFollowGetOrSetKeyword(); default: return nextTokenIsOnSameLineAndCanFollowModifier(); } @@ -33631,6 +34005,9 @@ var Parser; function canFollowModifier() { return token() === 23 /* OpenBracketToken */ || token() === 19 /* OpenBraceToken */ || token() === 42 /* AsteriskToken */ || token() === 26 /* DotDotDotToken */ || isLiteralPropertyName(); } + function canFollowGetOrSetKeyword() { + return token() === 23 /* OpenBracketToken */ || isLiteralPropertyName(); + } function nextTokenCanFollowDefaultKeyword() { nextToken(); return token() === 86 /* ClassKeyword */ || token() === 100 /* FunctionKeyword */ || token() === 120 /* InterfaceKeyword */ || token() === 60 /* AtToken */ || token() === 128 /* AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine) || token() === 134 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine); @@ -33690,6 +34067,7 @@ var Parser; case 25 /* DotToken */: return true; } + // falls through case 11 /* ArgumentExpressions */: return token() === 26 /* DotDotDotToken */ || isStartOfExpression(); case 16 /* Parameters */: @@ -33723,6 +34101,7 @@ var Parser; return true; case 26 /* Count */: return Debug.fail("ParsingContext.Count used as a context"); + // Not a real context, only a marker. default: Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'."); } @@ -34039,6 +34418,7 @@ var Parser; case 3 /* SwitchClauseStatements */: return parseErrorAtCurrentToken(Diagnostics.Statement_expected); case 18 /* RestProperties */: + // fallthrough case 4 /* TypeMembers */: return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected); case 5 /* ClassMembers */: @@ -34086,6 +34466,7 @@ var Parser; return parseErrorAtCurrentToken(Diagnostics.Identifier_expected); case 26 /* Count */: return Debug.fail("ParsingContext.Count used as a context"); + // Not a real context, only a marker. default: Debug.assertNever(context); } @@ -35010,10 +35391,12 @@ var Parser; return tryParse(parseKeywordAndNoDot) || parseTypeReference(); case 67 /* AsteriskEqualsToken */: scanner2.reScanAsteriskEqualsToken(); + // falls through case 42 /* AsteriskToken */: return parseJSDocAllType(); case 61 /* QuestionQuestionToken */: scanner2.reScanQuestionToken(); + // falls through case 58 /* QuestionToken */: return parseJSDocUnknownOrNullableType(); case 100 /* FunctionKeyword */: @@ -35891,6 +36274,7 @@ var Parser; if (isAwaitExpression2()) { return parseAwaitExpression(); } + // falls through default: return parseUpdateExpression(); } @@ -35910,6 +36294,8 @@ var Parser; if (languageVariant !== 1 /* JSX */) { return false; } + // We are in JSX context and the token is part of JSXElement. + // falls through default: return true; } @@ -36483,10 +36869,16 @@ var Parser; } function canFollowTypeArgumentsInExpression() { switch (token()) { + // These tokens can follow a type argument list in a call expression. case 21 /* OpenParenToken */: + // foo( case 15 /* NoSubstitutionTemplateLiteral */: + // foo `...` case 16 /* TemplateHead */: return true; + // A type argument list followed by `<` never makes sense, and a type argument list followed + // by `>` is ambiguous with a (re-scanned) `>>` operator, so we disqualify both. Also, in + // this context, `+` and `-` are unary operators, not binary operators. case 30 /* LessThanToken */: case 32 /* GreaterThanToken */: case 40 /* PlusToken */: @@ -36504,6 +36896,7 @@ var Parser; false ); } + // falls through case 9 /* NumericLiteral */: case 10 /* BigIntLiteral */: case 11 /* StringLiteral */: @@ -37007,6 +37400,27 @@ var Parser; return isUsingDeclaration(); case 135 /* AwaitKeyword */: return isAwaitUsingDeclaration(); + // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers; + // however, an identifier cannot be followed by another identifier on the same line. This is what we + // count on to parse out the respective declarations. For instance, we exploit this to say that + // + // namespace n + // + // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees + // + // namespace + // n + // + // as the identifier 'namespace' on one line followed by the identifier 'n' on another. + // We need to look one token ahead to see if it permissible to try parsing a declaration. + // + // *Note*: 'interface' is actually a strict mode reserved word. So while + // + // "use strict" + // interface + // I {} + // + // could be legal, it would add complexity for very little gain. case 120 /* InterfaceKeyword */: case 156 /* TypeKeyword */: return nextTokenIsIdentifierOnSameLine(); @@ -37079,6 +37493,9 @@ var Parser; case 111 /* ThrowKeyword */: case 113 /* TryKeyword */: case 89 /* DebuggerKeyword */: + // 'catch' and 'finally' do not actually indicate that the code is part of a statement, + // however, we say they are here so that we may gracefully parse them and error later. + // falls through case 85 /* CatchKeyword */: case 98 /* FinallyKeyword */: return true; @@ -37217,6 +37634,8 @@ var Parser; case 111 /* ThrowKeyword */: return parseThrowStatement(); case 113 /* TryKeyword */: + // Include 'catch' and 'finally' for error recovery. + // falls through case 85 /* CatchKeyword */: case 98 /* FinallyKeyword */: return parseTryStatement(); @@ -37635,10 +38054,15 @@ var Parser; } switch (token()) { case 21 /* OpenParenToken */: + // Method declaration case 30 /* LessThanToken */: + // Generic Method declaration case 54 /* ExclamationToken */: + // Non-null assertion on property name case 59 /* ColonToken */: + // Type Annotation for declaration case 64 /* EqualsToken */: + // Initializer for declaration case 58 /* QuestionToken */: return true; default: @@ -38545,6 +38969,7 @@ var Parser; linkEnd = scanner2.getTokenEnd(); break; } + // fallthrough if it's not a {@link sequence default: state = 2 /* SavingComments */; pushComment(scanner2.getTokenText()); @@ -38803,6 +39228,8 @@ var Parser; indent3 += 1; break; } + // record the * as a comment + // falls through default: if (state !== 3 /* SavingBackticks */) { state = 2 /* SavingComments */; @@ -39774,9 +40201,10 @@ function getDeclarationFileExtension(fileName) { return standardExtension; } if (fileExtensionIs(fileName, ".ts" /* Ts */)) { - const index = getBaseFileName(fileName).lastIndexOf(".d."); + const baseName = getBaseFileName(fileName); + const index = baseName.lastIndexOf(".d."); if (index >= 0) { - return fileName.substring(index); + return baseName.substring(index); } } return void 0; @@ -39883,6 +40311,7 @@ function processPragmasIntoFields(context, reportDiagnostic) { case "jsximportsource": case "jsxruntime": return; + // Accessed directly default: Debug.fail("Unhandled pragma kind"); } @@ -40020,6 +40449,7 @@ var libEntries = [ ["es2021", "lib.es2021.d.ts"], ["es2022", "lib.es2022.d.ts"], ["es2023", "lib.es2023.d.ts"], + ["es2024", "lib.es2024.d.ts"], ["esnext", "lib.esnext.d.ts"], // Host only ["dom", "lib.dom.d.ts"], @@ -40043,6 +40473,7 @@ var libEntries = [ ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"], ["es2016.array.include", "lib.es2016.array.include.d.ts"], ["es2016.intl", "lib.es2016.intl.d.ts"], + ["es2017.arraybuffer", "lib.es2017.arraybuffer.d.ts"], ["es2017.date", "lib.es2017.date.d.ts"], ["es2017.object", "lib.es2017.object.d.ts"], ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"], @@ -40075,12 +40506,18 @@ var libEntries = [ ["es2022.error", "lib.es2022.error.d.ts"], ["es2022.intl", "lib.es2022.intl.d.ts"], ["es2022.object", "lib.es2022.object.d.ts"], - ["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"], ["es2022.string", "lib.es2022.string.d.ts"], ["es2022.regexp", "lib.es2022.regexp.d.ts"], ["es2023.array", "lib.es2023.array.d.ts"], ["es2023.collection", "lib.es2023.collection.d.ts"], ["es2023.intl", "lib.es2023.intl.d.ts"], + ["es2024.arraybuffer", "lib.es2024.arraybuffer.d.ts"], + ["es2024.collection", "lib.es2024.collection.d.ts"], + ["es2024.object", "lib.es2024.object.d.ts"], + ["es2024.promise", "lib.es2024.promise.d.ts"], + ["es2024.regexp", "lib.es2024.regexp.d.ts"], + ["es2024.sharedmemory", "lib.es2024.sharedmemory.d.ts"], + ["es2024.string", "lib.es2024.string.d.ts"], ["esnext.array", "lib.es2023.array.d.ts"], ["esnext.collection", "lib.esnext.collection.d.ts"], ["esnext.symbol", "lib.es2019.symbol.d.ts"], @@ -40089,13 +40526,13 @@ var libEntries = [ ["esnext.disposable", "lib.esnext.disposable.d.ts"], ["esnext.bigint", "lib.es2020.bigint.d.ts"], ["esnext.string", "lib.es2022.string.d.ts"], - ["esnext.promise", "lib.esnext.promise.d.ts"], + ["esnext.promise", "lib.es2024.promise.d.ts"], ["esnext.weakref", "lib.es2021.weakref.d.ts"], ["esnext.decorators", "lib.esnext.decorators.d.ts"], - ["esnext.object", "lib.esnext.object.d.ts"], + ["esnext.object", "lib.es2024.object.d.ts"], ["esnext.array", "lib.esnext.array.d.ts"], - ["esnext.regexp", "lib.esnext.regexp.d.ts"], - ["esnext.string", "lib.esnext.string.d.ts"], + ["esnext.regexp", "lib.es2024.regexp.d.ts"], + ["esnext.string", "lib.es2024.string.d.ts"], ["esnext.iterator", "lib.esnext.iterator.d.ts"], ["decorators", "lib.decorators.d.ts"], ["decorators.legacy", "lib.decorators.legacy.d.ts"] @@ -40394,6 +40831,7 @@ var targetOptionDeclaration = { es2021: 8 /* ES2021 */, es2022: 9 /* ES2022 */, es2023: 10 /* ES2023 */, + es2024: 11 /* ES2024 */, esnext: 99 /* ESNext */ })), affectsSourceFile: true, @@ -40472,15 +40910,6 @@ var commandOptionsWithoutBuild = [ paramType: Diagnostics.FILE_OR_DIRECTORY, description: Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json }, - { - name: "build", - type: "boolean", - shortName: "b", - showInSimplifiedHelpView: true, - category: Diagnostics.Command_line_Options, - description: Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date, - defaultValueDescription: false - }, { name: "showConfig", type: "boolean", @@ -41005,6 +41434,15 @@ var commandOptionsWithoutBuild = [ defaultValueDescription: false, transpileOptionValue: void 0 }, + { + name: "rewriteRelativeImportExtensions", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsBuildInfo: true, + category: Diagnostics.Modules, + description: Diagnostics.Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files, + defaultValueDescription: false + }, { name: "resolvePackageJsonExports", type: "boolean", @@ -41465,7 +41903,17 @@ var commandLineOptionOfCustomType = optionDeclarations.filter(isCommandLineOptio function isCommandLineOptionOfCustomType(option) { return !isString(option.type); } +var tscBuildOption = { + name: "build", + type: "boolean", + shortName: "b", + showInSimplifiedHelpView: true, + category: Diagnostics.Command_line_Options, + description: Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date, + defaultValueDescription: false +}; var optionsForBuild = [ + tscBuildOption, { name: "verbose", shortName: "v", @@ -41604,8 +42052,14 @@ function getOptionName(option) { } function createUnknownOptionError(unknownOption, diagnostics, unknownOptionErrorText, node, sourceFile) { var _a; - if ((_a = diagnostics.alternateMode) == null ? void 0 : _a.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) { - return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.alternateMode.diagnostic, unknownOption); + const otherOption = (_a = diagnostics.alternateMode) == null ? void 0 : _a.getOptionsNameMap().optionsNameMap.get(unknownOption.toLowerCase()); + if (otherOption) { + return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic( + sourceFile, + node, + otherOption !== tscBuildOption ? diagnostics.alternateMode.diagnostic : Diagnostics.Option_build_must_be_the_first_command_line_argument, + unknownOption + ); } const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName); return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption); @@ -41740,6 +42194,7 @@ function parseOptionValue(args, i, diagnostics, opt, options, errors) { case "listOrElement": Debug.fail("listOrElement not supported here"); break; + // If not a primitive, the possible types are specified in what is effectively a map of options. default: options[opt.name] = parseCustomTypeOption(opt, args[i], errors); i++; @@ -41793,10 +42248,10 @@ var buildOptionsDidYouMeanDiagnostics = { unknownDidYouMeanDiagnostic: Diagnostics.Unknown_build_option_0_Did_you_mean_1, optionTypeMismatchDiagnostic: Diagnostics.Build_option_0_requires_a_value_of_type_1 }; -function parseBuildCommand(args) { +function parseBuildCommand(commandLine) { const { options, watchOptions, fileNames: projects, errors } = parseCommandLineWorker( buildOptionsDidYouMeanDiagnostics, - args + commandLine ); const buildOptions = options; if (projects.length === 0) { @@ -42080,6 +42535,7 @@ function convertToJson(sourceFile, rootExpression, errors, returnValue, jsonConv return false; case 106 /* NullKeyword */: return null; + // eslint-disable-line no-restricted-syntax case 11 /* StringLiteral */: if (!isDoubleQuotedString(valueExpression)) { errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected)); @@ -42173,7 +42629,7 @@ function convertToTSConfig(configParseResult, configFileName, host) { const providedKeys = new Set(optionMap.keys()); const impliedCompilerOptions = {}; for (const option in computedOptions) { - if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) { + if (!providedKeys.has(option) && optionDependsOn(option, providedKeys)) { const implied = computedOptions[option].computeValue(configParseResult.options); const defaultValue = computedOptions[option].computeValue({}); if (implied !== defaultValue) { @@ -42184,6 +42640,17 @@ function convertToTSConfig(configParseResult, configFileName, host) { assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions))); return config; } +function optionDependsOn(option, dependsOn) { + const seen = /* @__PURE__ */ new Set(); + return optionDependsOnRecursive(option); + function optionDependsOnRecursive(option2) { + var _a; + if (addToSeen(seen, option2)) { + return some((_a = computedOptions[option2]) == null ? void 0 : _a.dependencies, (dep) => dependsOn.has(dep) || optionDependsOnRecursive(dep)); + } + return false; + } +} function optionMapToObject(optionMap) { return Object.fromEntries(optionMap); } @@ -42559,8 +43026,6 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis validatedFilesSpecBeforeSubstitution, validatedIncludeSpecsBeforeSubstitution, validatedExcludeSpecsBeforeSubstitution, - pathPatterns: void 0, - // Initialized on first use isDefaultIncludeSpec }; } @@ -42699,6 +43164,9 @@ function getErrorForNoInputFiles({ includeSpecs, excludeSpecs }, configFileName) function shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles, resolutionStack) { return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0); } +function isSolutionConfig(config) { + return !config.fileNames.length && hasProperty(config.raw, "references"); +} function canJsonReportNoInputFiles(raw) { return !hasProperty(raw, "files") && !hasProperty(raw, "references"); } @@ -42740,7 +43208,7 @@ function parseConfig(json, sourceFile, host, basePath, configFileName, resolutio if (ownConfig.raw.compileOnSave === void 0 && result.compileOnSave) ownConfig.raw.compileOnSave = result.compileOnSave; if (sourceFile && result.extendedSourceFiles) sourceFile.extendedSourceFiles = arrayFrom(result.extendedSourceFiles.keys()); ownConfig.options = assign(result.options, ownConfig.options); - ownConfig.watchOptions = ownConfig.watchOptions && result.watchOptions ? assign(result.watchOptions, ownConfig.watchOptions) : ownConfig.watchOptions || result.watchOptions; + ownConfig.watchOptions = ownConfig.watchOptions && result.watchOptions ? assignWatchOptions(result, ownConfig.watchOptions) : ownConfig.watchOptions || result.watchOptions; } return ownConfig; function applyExtendedConfig(result, extendedConfigPath) { @@ -42764,9 +43232,14 @@ function parseConfig(json, sourceFile, host, basePath, configFileName, resolutio result.compileOnSave = extendsRaw.compileOnSave; } assign(result.options, extendedConfig.options); - result.watchOptions = result.watchOptions && extendedConfig.watchOptions ? assign({}, result.watchOptions, extendedConfig.watchOptions) : result.watchOptions || extendedConfig.watchOptions; + result.watchOptions = result.watchOptions && extendedConfig.watchOptions ? assignWatchOptions(result, extendedConfig.watchOptions) : result.watchOptions || extendedConfig.watchOptions; } } + function assignWatchOptions(result, watchOptions) { + if (result.watchOptionsCopied) return assign(result.watchOptions, watchOptions); + result.watchOptionsCopied = true; + return assign({}, result.watchOptions, watchOptions); + } } function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) { if (hasProperty(json, "excludes")) { @@ -43288,6 +43761,7 @@ function getOptionValueWithEmptyStrings(value, option) { return typeof value === "boolean" ? value : ""; case "listOrElement": if (!isArray(value)) return getOptionValueWithEmptyStrings(value, option.element); + // fall through to list case "list": const elementType = option.element; return isArray(value) ? mapDefined(value, (v) => getOptionValueWithEmptyStrings(v, elementType)) : ""; @@ -43808,7 +44282,7 @@ function getConditions(options, resolutionMode) { } function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) { const moduleResolutionState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options); - return forEachAncestorDirectory(containingDirectory, (ancestorDirectory) => { + return forEachAncestorDirectoryStoppingAtGlobalCache(host, containingDirectory, (ancestorDirectory) => { if (getBaseFileName(ancestorDirectory) !== "node_modules") { const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules"); const candidate = combinePaths(nodeModulesFolder, packageName); @@ -44264,8 +44738,7 @@ function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, co } } function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) { - var _a; - const { baseUrl, paths, configFile } = state.compilerOptions; + const { baseUrl, paths } = state.compilerOptions; if (paths && !pathIsRelative(moduleName)) { if (state.traceEnabled) { if (baseUrl) { @@ -44274,7 +44747,7 @@ function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName); } const baseDirectory = getPathsBasePath(state.compilerOptions, state.host); - const pathPatterns = (configFile == null ? void 0 : configFile.configFileSpecs) ? (_a = configFile.configFileSpecs).pathPatterns || (_a.pathPatterns = tryParsePatterns(paths)) : void 0; + const pathPatterns = tryParsePatterns(paths); return tryLoadModuleUsingPaths( extensions, moduleName, @@ -44586,25 +45059,28 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, return toSearchResult({ resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) }); } if (!isExternalModuleNameRelative(moduleName)) { - let resolved2; if (features & 2 /* Imports */ && startsWith(moduleName, "#")) { - resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); - } - if (!resolved2 && features & 4 /* SelfName */) { - resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); - } - if (!resolved2) { - if (moduleName.includes(":")) { - if (traceEnabled) { - trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2)); - } - return void 0; + const resolved3 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); + if (resolved3) { + return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } }; } + } + if (features & 4 /* SelfName */) { + const resolved3 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); + if (resolved3) { + return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } }; + } + } + if (moduleName.includes(":")) { if (traceEnabled) { - trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2)); + trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2)); } - resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); + return void 0; } + if (traceEnabled) { + trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2)); + } + let resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference); if (extensions2 & 4 /* Declaration */) { resolved2 ?? (resolved2 = resolveFromTypeRoot(moduleName, state2)); } @@ -44732,10 +45208,11 @@ function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecor } return tryAddingExtensions(extensionless, extensions, extension, onlyRecordFailures, state); } -function loadFileNameFromPackageJsonField(extensions, candidate, onlyRecordFailures, state) { +function loadFileNameFromPackageJsonField(extensions, candidate, packageJsonValue, onlyRecordFailures, state) { if (extensions & 1 /* TypeScript */ && fileExtensionIsOneOf(candidate, supportedTSImplementationExtensions) || extensions & 4 /* Declaration */ && fileExtensionIsOneOf(candidate, supportedDeclarationExtensions)) { const result = tryFile(candidate, onlyRecordFailures, state); - return result !== void 0 ? { path: candidate, ext: tryExtractTSExtension(candidate), resolvedUsingTsExtension: void 0 } : void 0; + const ext = tryExtractTSExtension(candidate); + return result !== void 0 ? { path: candidate, ext, resolvedUsingTsExtension: packageJsonValue ? !endsWith(packageJsonValue, ext) : void 0 } : void 0; } if (state.isConfigLookup && extensions === 8 /* Json */ && fileExtensionIs(candidate, ".json" /* Json */)) { const result = tryFile(candidate, onlyRecordFailures, state); @@ -44897,6 +45374,7 @@ function loadEntrypointsFromExportMap(scope, exports2, state, extensions) { const result = loadFileNameFromPackageJsonField( extensions, finalPath, + target, /*onlyRecordFailures*/ false, state @@ -44941,7 +45419,8 @@ function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options) }; } function getPackageScopeForPath(directory, state) { - return forEachAncestorDirectory( + return forEachAncestorDirectoryStoppingAtGlobalCache( + state.host, directory, (dir) => getPackageJsonInfo( dir, @@ -45037,7 +45516,14 @@ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFail } } const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => { - const fromFile = loadFileNameFromPackageJsonField(extensions2, candidate2, onlyRecordFailures2, state2); + const fromFile = loadFileNameFromPackageJsonField( + extensions2, + candidate2, + /*packageJsonValue*/ + void 0, + onlyRecordFailures2, + state2 + ); if (fromFile) { return noPackageId(fromFile); } @@ -45073,17 +45559,8 @@ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFail if (state.traceEnabled) { trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName); } - const result = tryLoadModuleUsingPaths( - extensions, - moduleName, - candidate, - versionPaths.paths, - /*pathPatterns*/ - void 0, - loader, - onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, - state - ); + const pathPatterns = tryParsePatterns(versionPaths.paths); + const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, pathPatterns, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state); if (result) { return removeIgnoredPackageId(result.value); } @@ -45146,7 +45623,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec mainExport = scope.contents.packageJsonContent.exports["."]; } if (mainExport) { - const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport( + const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport( extensions, state, cache, @@ -45156,7 +45633,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec /*isImports*/ false ); - return loadModuleFromTargetImportOrExport( + return loadModuleFromTargetExportOrImport( mainExport, "", /*pattern*/ @@ -45174,7 +45651,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec void 0 ); } - const result = loadModuleFromImportsOrExports( + const result = loadModuleFromExportsOrImports( extensions, state, cache, @@ -45228,7 +45705,7 @@ function loadModuleFromImports(extensions, moduleName, directory, state, cache, void 0 ); } - const result = loadModuleFromImportsOrExports( + const result = loadModuleFromExportsOrImports( extensions, state, cache, @@ -45255,19 +45732,19 @@ function comparePatternKeys(a, b) { const bPatternIndex = b.indexOf("*"); const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; - if (baseLenA > baseLenB) return -1; - if (baseLenB > baseLenA) return 1; - if (aPatternIndex === -1) return 1; - if (bPatternIndex === -1) return -1; - if (a.length > b.length) return -1; - if (b.length > a.length) return 1; - return 0; + if (baseLenA > baseLenB) return -1 /* LessThan */; + if (baseLenB > baseLenA) return 1 /* GreaterThan */; + if (aPatternIndex === -1) return 1 /* GreaterThan */; + if (bPatternIndex === -1) return -1 /* LessThan */; + if (a.length > b.length) return -1 /* LessThan */; + if (b.length > a.length) return 1 /* GreaterThan */; + return 0 /* EqualTo */; } -function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) { - const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports); +function loadModuleFromExportsOrImports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) { + const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports); if (!endsWith(moduleName, directorySeparator) && !moduleName.includes("*") && hasProperty(lookupTable, moduleName)) { const target = lookupTable[moduleName]; - return loadModuleFromTargetImportOrExport( + return loadModuleFromTargetExportOrImport( target, /*subpath*/ "", @@ -45282,7 +45759,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe const target = lookupTable[potentialTarget]; const starPos = potentialTarget.indexOf("*"); const subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos)); - return loadModuleFromTargetImportOrExport( + return loadModuleFromTargetExportOrImport( target, subpath, /*pattern*/ @@ -45292,7 +45769,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe } else if (endsWith(potentialTarget, "*") && startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) { const target = lookupTable[potentialTarget]; const subpath = moduleName.substring(potentialTarget.length - 1); - return loadModuleFromTargetImportOrExport( + return loadModuleFromTargetExportOrImport( target, subpath, /*pattern*/ @@ -45302,7 +45779,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe } else if (startsWith(moduleName, potentialTarget)) { const target = lookupTable[potentialTarget]; const subpath = moduleName.substring(potentialTarget.length); - return loadModuleFromTargetImportOrExport( + return loadModuleFromTargetExportOrImport( target, subpath, /*pattern*/ @@ -45322,9 +45799,9 @@ function hasOneAsterisk(patternKey) { const firstStar = patternKey.indexOf("*"); return firstStar !== -1 && firstStar === patternKey.lastIndexOf("*"); } -function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) { - return loadModuleFromTargetImportOrExport; - function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) { +function getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) { + return loadModuleFromTargetExportOrImport; + function loadModuleFromTargetExportOrImport(target, subpath, pattern, key) { if (typeof target === "string") { if (!pattern && subpath.length > 0 && !endsWith(target, "/")) { if (state.traceEnabled) { @@ -45402,6 +45879,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec return toSearchResult(withPackageId(scope, loadFileNameFromPackageJsonField( extensions, finalPath, + target, /*onlyRecordFailures*/ false, state @@ -45413,7 +45891,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec if (condition === "default" || state.conditions.includes(condition) || isApplicableVersionedTypesKey(state.conditions, condition)) { traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition); const subTarget = target[condition]; - const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key); + const result = loadModuleFromTargetExportOrImport(subTarget, subpath, pattern, key); if (result) { traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition); traceIfEnabled(state, Diagnostics.Exiting_conditional_exports); @@ -45438,7 +45916,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec ); } for (const elem of target) { - const result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key); + const result = loadModuleFromTargetExportOrImport(elem, subpath, pattern, key); if (result) { return result; } @@ -45514,6 +45992,8 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec return toSearchResult(withPackageId(scope, loadFileNameFromPackageJsonField( extensions, possibleInputWithInputExtension, + /*packageJsonValue*/ + void 0, /*onlyRecordFailures*/ false, state @@ -45589,17 +46069,30 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, return lookup(secondaryExtensions); } function lookup(extensions2) { - return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => { - if (getBaseFileName(ancestorDirectory) !== "node_modules") { - const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state); - if (resolutionFromCache) { - return resolutionFromCache; + return forEachAncestorDirectoryStoppingAtGlobalCache( + state.host, + normalizeSlashes(directory), + (ancestorDirectory) => { + if (getBaseFileName(ancestorDirectory) !== "node_modules") { + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state); + if (resolutionFromCache) { + return resolutionFromCache; + } + return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference)); } - return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference)); } - }); + ); } } +function forEachAncestorDirectoryStoppingAtGlobalCache(host, directory, callback) { + var _a; + const globalCache = (_a = host == null ? void 0 : host.getGlobalTypingsCacheLocation) == null ? void 0 : _a.call(host); + return forEachAncestorDirectory(directory, (ancestorDirectory) => { + const result = callback(ancestorDirectory); + if (result !== void 0) return result; + if (ancestorDirectory === globalCache) return false; + }) || void 0; +} function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { const nodeModulesFolder = combinePaths(directory, "node_modules"); const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host); @@ -45675,17 +46168,8 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, node trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, rest); } const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host); - const fromPaths = tryLoadModuleUsingPaths( - extensions, - rest, - packageDirectory, - versionPaths.paths, - /*pathPatterns*/ - void 0, - loader, - !packageDirectoryExists, - state - ); + const pathPatterns = tryParsePatterns(versionPaths.paths); + const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, versionPaths.paths, pathPatterns, loader, !packageDirectoryExists, state); if (fromPaths) { return fromPaths.value; } @@ -45693,7 +46177,6 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, node return loader(extensions, candidate, !nodeModulesDirectoryExists, state); } function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, onlyRecordFailures, state) { - pathPatterns || (pathPatterns = tryParsePatterns(paths)); const matchedPattern = matchPatternOrExact(pathPatterns, moduleName); if (matchedPattern) { const matchedStar = isString(matchedPattern) ? void 0 : matchedText(matchedPattern, moduleName); @@ -45805,28 +46288,32 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host, return { value: resolvedUsingSettings }; } if (!isExternalModuleNameRelative(moduleName)) { - const resolved2 = forEachAncestorDirectory(containingDirectory, (directory) => { - const resolutionFromCache = tryFindNonRelativeModuleNameInCache( - cache, - moduleName, - /*mode*/ - void 0, - directory, - redirectedReference, - state - ); - if (resolutionFromCache) { - return resolutionFromCache; + const resolved2 = forEachAncestorDirectoryStoppingAtGlobalCache( + state.host, + containingDirectory, + (directory) => { + const resolutionFromCache = tryFindNonRelativeModuleNameInCache( + cache, + moduleName, + /*mode*/ + void 0, + directory, + redirectedReference, + state + ); + if (resolutionFromCache) { + return resolutionFromCache; + } + const searchName = normalizePath(combinePaths(directory, moduleName)); + return toSearchResult(loadModuleFromFileNoPackageId( + extensions, + searchName, + /*onlyRecordFailures*/ + false, + state + )); } - const searchName = normalizePath(combinePaths(directory, moduleName)); - return toSearchResult(loadModuleFromFileNoPackageId( - extensions, - searchName, - /*onlyRecordFailures*/ - false, - state - )); - }); + ); if (resolved2) return resolved2; if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) { let resolved3 = loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state); @@ -45869,7 +46356,7 @@ function resolveFromTypeRoot(moduleName, state) { } } function shouldAllowImportingTsExtension(compilerOptions, fromFileName) { - return !!compilerOptions.allowImportingTsExtensions || fromFileName && isDeclarationFileName(fromFileName); + return getAllowImportingTsExtensions(compilerOptions) || !!fromFileName && isDeclarationFileName(fromFileName); } function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) { const traceEnabled = isTraceEnabled(compilerOptions, host); @@ -45960,20 +46447,24 @@ function getModuleInstanceStateCached(node, visited = /* @__PURE__ */ new Map()) } function getModuleInstanceStateWorker(node, visited) { switch (node.kind) { + // 1. interface declarations, type alias declarations case 264 /* InterfaceDeclaration */: case 265 /* TypeAliasDeclaration */: return 0 /* NonInstantiated */; + // 2. const enum declarations case 266 /* EnumDeclaration */: if (isEnumConst(node)) { return 2 /* ConstEnumOnly */; } break; + // 3. non-exported import declarations case 272 /* ImportDeclaration */: case 271 /* ImportEqualsDeclaration */: if (!hasSyntacticModifier(node, 32 /* Export */)) { return 0 /* NonInstantiated */; } break; + // 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain case 278 /* ExportDeclaration */: const exportDeclaration = node; if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 279 /* NamedExports */) { @@ -45990,6 +46481,7 @@ function getModuleInstanceStateWorker(node, visited) { return state; } break; + // 5. other uninstantiated module declarations. case 268 /* ModuleBlock */: { let state = 0 /* NonInstantiated */; forEachChild(node, (n) => { @@ -46107,7 +46599,7 @@ function createBinder() { var inStrictMode; var inAssignmentPattern = false; var symbolCount = 0; - var Symbol47; + var Symbol48; var classifiableNames; var unreachableFlow = createFlowNode( 1 /* Unreachable */, @@ -46136,7 +46628,7 @@ function createBinder() { inStrictMode = bindInStrictMode(file, opts); classifiableNames = /* @__PURE__ */ new Set(); symbolCount = 0; - Symbol47 = objectAllocator.getSymbolConstructor(); + Symbol48 = objectAllocator.getSymbolConstructor(); Debug.attachFlowNodeDebugInfo(unreachableFlow); Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow); if (!file.locals) { @@ -46187,7 +46679,7 @@ function createBinder() { } function createSymbol(flags, name) { symbolCount++; - return new Symbol47(flags, name); + return new Symbol48(flags, name); } function addDeclarationToSymbol(symbol, node, symbolFlags) { symbol.flags |= symbolFlags; @@ -46600,6 +47092,7 @@ function createBinder() { case 351 /* JSDocImportTag */: bindJSDocImportTag(node); break; + // In source files and blocks, bind functions first to match hoisting that occurs at runtime case 307 /* SourceFile */: { bindEachFunctionsFirst(node.statements); bind(node.endOfFileToken); @@ -46620,6 +47113,7 @@ function createBinder() { case 303 /* PropertyAssignment */: case 230 /* SpreadElement */: inAssignmentPattern = saveInAssignmentPattern; + // falls through default: bindEachChild(node); break; @@ -46641,6 +47135,7 @@ function createBinder() { if (isJSDocTypeAssertion(expr)) { return false; } + // fallthrough case 235 /* NonNullExpression */: return isNarrowingExpression(expr.expression); case 226 /* BinaryExpression */: @@ -47472,6 +47967,10 @@ function createBinder() { } function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) { switch (container.kind) { + // Modules, source files, and classes need specialized handling for how their + // members are declared (for example, a member of a class will go into a specific + // symbol table depending on if it is static or not). We defer to specialized + // handlers to take care of declaring these child members. case 267 /* ModuleDeclaration */: return declareModuleMember(node, symbolFlags, symbolExcludes); case 307 /* SourceFile */: @@ -47613,6 +48112,7 @@ function createBinder() { declareModuleMember(node, symbolFlags, symbolExcludes); break; } + // falls through default: Debug.assertNode(blockScopeContainer, canHaveLocals); if (!blockScopeContainer.locals) { @@ -47933,6 +48433,7 @@ function createBinder() { } function bindWorker(node) { switch (node.kind) { + /* Strict mode checks */ case 80 /* Identifier */: if (node.flags & 4096 /* IdentifierIsInJSDocNamespace */) { let parentNode = node.parent; @@ -47942,6 +48443,7 @@ function createBinder() { bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */); break; } + // falls through case 110 /* ThisKeyword */: if (currentFlow && (isExpression(node) || parent2.kind === 304 /* ShorthandPropertyAssignment */)) { node.flowNode = currentFlow; @@ -48030,6 +48532,7 @@ function createBinder() { return; case 182 /* TypePredicate */: break; + // Binding the children will handle everything case 168 /* TypeParameter */: return bindTypeParameter(node); case 169 /* Parameter */: @@ -48094,6 +48597,7 @@ function createBinder() { return bindObjectDefinePrototypeProperty(node); case 0 /* None */: break; + // Nothing to do default: return Debug.fail("Unknown call expression assignment declaration kind"); } @@ -48101,6 +48605,7 @@ function createBinder() { bindCallExpression(node); } break; + // Members of classes, interfaces, and modules case 231 /* ClassExpression */: case 263 /* ClassDeclaration */: inStrictMode = true; @@ -48113,10 +48618,12 @@ function createBinder() { return bindEnumDeclaration(node); case 267 /* ModuleDeclaration */: return bindModuleDeclaration(node); + // Jsx-attributes case 292 /* JsxAttributes */: return bindJsxAttributes(node); case 291 /* JsxAttribute */: return bindJsxAttribute(node, 4 /* Property */, 0 /* PropertyExcludes */); + // Imports and exports case 271 /* ImportEqualsDeclaration */: case 274 /* NamespaceImport */: case 276 /* ImportSpecifier */: @@ -48137,6 +48644,7 @@ function createBinder() { if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) { return; } + // falls through case 268 /* ModuleBlock */: return updateStrictModeStatementList(node.statements); case 341 /* JSDocParameterTag */: @@ -48146,6 +48654,7 @@ function createBinder() { if (node.parent.kind !== 322 /* JSDocTypeLiteral */) { break; } + // falls through case 348 /* JSDocPropertyTag */: const propTag = node; const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 316 /* JSDocOptionalType */ ? 4 /* Property */ | 16777216 /* Optional */ : 4 /* Property */; @@ -48358,6 +48867,7 @@ function createBinder() { declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */); } break; + // Namespaces are not allowed in javascript files, so do nothing here case 267 /* ModuleDeclaration */: break; default: @@ -48854,6 +49364,7 @@ function getContainerFlags(node) { if (isObjectLiteralOrClassExpressionMethodOrAccessor(node)) { return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */; } + // falls through case 176 /* Constructor */: case 262 /* FunctionDeclaration */: case 173 /* MethodSignature */: @@ -49301,31 +49812,29 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true }; } } - if (!specifier) { - const local = getLocalModuleSpecifier( - modulePath.path, - info, - compilerOptions, - host, - options.overrideImportMode || importingSourceFile.impliedNodeFormat, - preferences, - /*pathsOnly*/ - modulePath.isRedirect - ); - if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) { - continue; - } - if (modulePath.isRedirect) { - redirectPathsSpecifiers = append(redirectPathsSpecifiers, local); - } else if (pathIsBareSpecifier(local)) { - if (pathContainsNodeModules(local)) { - relativeSpecifiers = append(relativeSpecifiers, local); - } else { - pathsSpecifiers = append(pathsSpecifiers, local); - } - } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) { + const local = getLocalModuleSpecifier( + modulePath.path, + info, + compilerOptions, + host, + options.overrideImportMode || importingSourceFile.impliedNodeFormat, + preferences, + /*pathsOnly*/ + modulePath.isRedirect || !!specifier + ); + if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) { + continue; + } + if (modulePath.isRedirect) { + redirectPathsSpecifiers = append(redirectPathsSpecifiers, local); + } else if (pathIsBareSpecifier(local)) { + if (pathContainsNodeModules(local)) { relativeSpecifiers = append(relativeSpecifiers, local); + } else { + pathsSpecifiers = append(pathsSpecifiers, local); } + } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) { + relativeSpecifiers = append(relativeSpecifiers, local); } } return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: relativeSpecifiers ?? emptyArray, computedWithoutCache: true }; @@ -49371,7 +49880,7 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im importMode, prefersTsExtension(allowedEndings) ); - const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0; + const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) : void 0; if (pathsOnly) { return fromPaths; } @@ -49427,9 +49936,11 @@ function getNearestAncestorDirectoryWithPackageJson(host, fileName) { if (host.getNearestAncestorDirectoryWithPackageJson) { return host.getNearestAncestorDirectoryWithPackageJson(fileName); } - return forEachAncestorDirectory(fileName, (directory) => { - return host.fileExists(combinePaths(directory, "package.json")) ? directory : void 0; - }); + return forEachAncestorDirectoryStoppingAtGlobalCache( + host, + fileName, + (directory) => host.fileExists(combinePaths(directory, "package.json")) ? directory : void 0 + ); } function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) { var _a; @@ -49447,25 +49958,29 @@ function forEachFileNameOfModule(importingFileName, importedFileName, host, pref } const symlinkedDirectories = (_a = host.getSymlinkCache) == null ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath(); const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd); - const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(fullImportedFileName), (realPathDirectory) => { - const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName))); - if (!symlinkDirectories) return void 0; - if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) { - return false; + const result = symlinkedDirectories && forEachAncestorDirectoryStoppingAtGlobalCache( + host, + getDirectoryPath(fullImportedFileName), + (realPathDirectory) => { + const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName))); + if (!symlinkDirectories) return void 0; + if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) { + return false; + } + return forEach(targets, (target) => { + if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) { + return; + } + const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName); + for (const symlinkDirectory of symlinkDirectories) { + const option = resolvePath(symlinkDirectory, relative); + const result2 = cb(option, target === referenceRedirect); + shouldFilterIgnoredPaths = true; + if (result2) return result2; + } + }); } - return forEach(targets, (target) => { - if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) { - return; - } - const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName); - for (const symlinkDirectory of symlinkDirectories) { - const option = resolvePath(symlinkDirectory, relative); - const result2 = cb(option, target === referenceRedirect); - shouldFilterIgnoredPaths = true; - if (result2) return result2; - } - }); - }); + ); return result || (preferSymlinks ? forEach(targets, (p) => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? void 0 : cb(p, p === referenceRedirect)) : void 0); } function getAllModulePaths(info, importedFileName, host, preferences, compilerOptions, options = {}) { @@ -49594,10 +50109,11 @@ function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) { return ambientModuleDeclare.name.text; } } -function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) { +function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) { for (const key in paths) { for (const patternText2 of paths[key]) { - const pattern = normalizePath(patternText2); + const normalized = normalizePath(patternText2); + const pattern = getRelativePathIfInSameVolume(normalized, baseDirectory, getCanonicalFileName) ?? normalized; const indexOfStar = pattern.indexOf("*"); const candidates = allowedEndings.map((ending) => ({ ending, @@ -49926,6 +50442,8 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa subModuleName, versionPaths.paths, allowedEndings, + packageRootPath, + getCanonicalFileName, host, options ); @@ -50219,9 +50737,9 @@ function createTypeChecker(host) { }; var cancellationToken; var scanner2; - var Symbol47 = objectAllocator.getSymbolConstructor(); + var Symbol48 = objectAllocator.getSymbolConstructor(); var Type29 = objectAllocator.getTypeConstructor(); - var Signature14 = objectAllocator.getSignatureConstructor(); + var Signature13 = objectAllocator.getSignatureConstructor(); var typeCount = 0; var symbolCount = 0; var totalInstantiationCount = 0; @@ -50253,17 +50771,7 @@ function createTypeChecker(host) { var checkBinaryExpression = createCheckBinaryExpression(); var emitResolver = createResolver(); var nodeBuilder = createNodeBuilder(); - var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, { - isEntityNameVisible, - isExpandoFunctionDeclaration, - getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration, - requiresAddingImplicitUndefined, - isUndefinedIdentifierExpression(node) { - Debug.assert(isExpressionNode(node)); - return getSymbolAtLocation(node) === undefinedSymbol; - }, - isDefinitelyReferenceToGlobalSymbolObject - }); + var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, nodeBuilder.syntacticBuilderResolver); var evaluate = createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression @@ -50281,34 +50789,10 @@ function createTypeChecker(host) { nodeGlobals, mergeSymbol }); - const nodeGlobalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */); + var nodeGlobalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */); nodeGlobalThisSymbol.exports = denoContext.combinedGlobals; nodeGlobalThisSymbol.declarations = []; nodeGlobals.set(nodeGlobalThisSymbol.escapedName, nodeGlobalThisSymbol); - nodeGlobals.set( - "onmessage", - createSymbol(1536 /* Module */, "onmessage", 8 /* Readonly */) - ); - nodeGlobals.set( - "onabort", - createSymbol(1536 /* Module */, "onabort", 8 /* Readonly */) - ); - nodeGlobals.set( - "ReportingObserver", - createSymbol(1536 /* Module */, "ReportingObserver", 8 /* Readonly */) - ); - nodeGlobals.set( - "PerformanceObserver", - createSymbol(1536 /* Module */, "PerformanceObserver", 8 /* Readonly */) - ); - nodeGlobals.set( - "PerformanceObserverEntryList", - createSymbol(1536 /* Module */, "PerformanceObserverEntryList", 8 /* Readonly */) - ); - nodeGlobals.set( - "PerformanceResourceTiming", - createSymbol(1536 /* Module */, "PerformanceResourceTiming", 8 /* Readonly */) - ); var argumentsSymbol = createSymbol(4 /* Property */, "arguments"); var requireSymbol = createSymbol(4 /* Property */, "require"); var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules"; @@ -50402,6 +50886,7 @@ function createTypeChecker(host) { getBaseTypeOfLiteralType, getWidenedType, getWidenedLiteralType, + fillMissingTypeArguments, getTypeFromTypeNode: (nodeIn) => { const node = getParseTreeNode(nodeIn, isTypeNode); return node ? getTypeFromTypeNode(node) : errorType; @@ -50958,6 +51443,15 @@ function createTypeChecker(host) { emptyArray ); emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */; + var emptyFreshJsxObjectType = createAnonymousType( + /*symbol*/ + void 0, + emptySymbols, + emptyArray, + emptyArray, + emptyArray + ); + emptyFreshJsxObjectType.objectFlags |= 2048 /* JsxAttributes */ | 8192 /* FreshLiteral */ | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */; var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */); emptyTypeLiteralSymbol.members = createSymbolTable(); var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray); @@ -51082,6 +51576,12 @@ function createTypeChecker(host) { /*isReadonly*/ true ); + var anyBaseTypeIndexInfo = createIndexInfo( + stringType, + anyType, + /*isReadonly*/ + false + ); var iterationTypesCache = /* @__PURE__ */ new Map(); var noIterationTypes = { get yieldType() { @@ -51439,7 +51939,7 @@ function createTypeChecker(host) { } function createSymbol(flags, name, checkFlags) { symbolCount++; - const symbol = new Symbol47(flags | 33554432 /* Transient */, name); + const symbol = new Symbol48(flags | 33554432 /* Transient */, name); symbol.links = new SymbolLinks(); symbol.links.checkFlags = checkFlags || 0 /* None */; return symbol; @@ -52052,6 +52552,7 @@ function createTypeChecker(host) { if (isEntityNameExpression(node.expression)) { return node.expression; } + // falls through default: return void 0; } @@ -52347,10 +52848,19 @@ function createTypeChecker(host) { function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) { return usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */; } - function isOnlyImportableAsDefault(usage) { + function isOnlyImportableAsDefault(usage, resolvedModule) { if (100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) { const usageMode = getEmitSyntaxForModuleSpecifierExpression(usage); - return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */); + if (usageMode === 99 /* ESNext */) { + resolvedModule ?? (resolvedModule = resolveExternalModuleName( + usage, + usage, + /*ignoreErrors*/ + true + )); + const targetFile = resolvedModule && getSourceFileOfModule(resolvedModule); + return targetFile && (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === ".d.json.ts"); + } } return false; } @@ -52418,7 +52928,7 @@ function createTypeChecker(host) { if (!specifier) { return exportDefaultSymbol; } - const hasDefaultOnly = isOnlyImportableAsDefault(specifier); + const hasDefaultOnly = isOnlyImportableAsDefault(specifier, moduleSymbol); const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier); if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) { if (hasExportAssignmentSymbol(moduleSymbol) && !allowSyntheticDefaultImports) { @@ -52620,12 +53130,14 @@ function createTypeChecker(host) { let symbolFromModule = getExportOfModule(targetSymbol, nameText, specifier, dontResolveAlias); if (symbolFromModule === void 0 && nameText === "default" /* Default */) { const file = (_a = moduleSymbol.declarations) == null ? void 0 : _a.find(isSourceFile); - if (isOnlyImportableAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) { + if (isOnlyImportableAsDefault(moduleSpecifier, moduleSymbol) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) { symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); } } const symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ? combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : symbolFromModule || symbolFromVariable; - if (!symbol) { + if (isImportOrExportSpecifier(specifier) && isOnlyImportableAsDefault(moduleSpecifier, moduleSymbol) && nameText !== "default" /* Default */) { + error2(name, Diagnostics.Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0, ModuleKind[moduleKind]); + } else if (!symbol) { errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name); } return symbol; @@ -53238,14 +53750,14 @@ function createTypeChecker(host) { return ambientModule; } const currentSourceFile = getSourceFileOfNode(location); - const contextSpecifier = isStringLiteralLike(location) ? location : ((_a = isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : void 0) == null ? void 0 : _a.name) || ((_b = isLiteralImportTypeNode(location) ? location : void 0) == null ? void 0 : _b.argument.literal) || (isInJSFile(location) && isJSDocImportTag(location) ? location.moduleSpecifier : void 0) || (isVariableDeclaration(location) && location.initializer && isRequireCall( + const contextSpecifier = isStringLiteralLike(location) ? location : ((_a = isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : void 0) == null ? void 0 : _a.name) || ((_b = isLiteralImportTypeNode(location) ? location : void 0) == null ? void 0 : _b.argument.literal) || (isVariableDeclaration(location) && location.initializer && isRequireCall( location.initializer, /*requireStringLiteralLikeArgument*/ true - ) ? location.initializer.arguments[0] : void 0) || ((_c = findAncestor(location, isImportCall)) == null ? void 0 : _c.arguments[0]) || ((_d = findAncestor(location, isImportDeclaration)) == null ? void 0 : _d.moduleSpecifier) || ((_e = findAncestor(location, isExternalModuleImportEqualsDeclaration)) == null ? void 0 : _e.moduleReference.expression) || ((_f = findAncestor(location, isExportDeclaration)) == null ? void 0 : _f.moduleSpecifier); + ) ? location.initializer.arguments[0] : void 0) || ((_c = findAncestor(location, isImportCall)) == null ? void 0 : _c.arguments[0]) || ((_d = findAncestor(location, or(isImportDeclaration, isJSDocImportTag, isExportDeclaration))) == null ? void 0 : _d.moduleSpecifier) || ((_e = findAncestor(location, isExternalModuleImportEqualsDeclaration)) == null ? void 0 : _e.moduleReference.expression); const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? host.getModeForUsageLocation(currentSourceFile, contextSpecifier) : host.getDefaultResolutionModeForFile(currentSourceFile); const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions); - const resolvedModule = (_g = host.getResolvedModule(currentSourceFile, moduleReference, mode)) == null ? void 0 : _g.resolvedModule; + const resolvedModule = (_f = host.getResolvedModule(currentSourceFile, moduleReference, mode)) == null ? void 0 : _f.resolvedModule; const resolutionDiagnostic = errorNode && resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule, currentSourceFile); const sourceFile = resolvedModule && (!resolutionDiagnostic || resolutionDiagnostic === Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set) && host.getSourceFile(resolvedModule.resolvedFileName); if (sourceFile) { @@ -53253,7 +53765,7 @@ function createTypeChecker(host) { error2(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName); } if (resolvedModule.resolvedUsingTsExtension && isDeclarationFileName(moduleReference)) { - const importOrExport = ((_h = findAncestor(location, isImportDeclaration)) == null ? void 0 : _h.importClause) || findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration)); + const importOrExport = ((_g = findAncestor(location, isImportDeclaration)) == null ? void 0 : _g.importClause) || findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration)); if (errorNode && importOrExport && !importOrExport.isTypeOnly || findAncestor(location, isImportCall)) { error2( errorNode, @@ -53262,11 +53774,41 @@ function createTypeChecker(host) { ); } } else if (resolvedModule.resolvedUsingTsExtension && !shouldAllowImportingTsExtension(compilerOptions, currentSourceFile.fileName)) { - const importOrExport = ((_i = findAncestor(location, isImportDeclaration)) == null ? void 0 : _i.importClause) || findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration)); + const importOrExport = ((_h = findAncestor(location, isImportDeclaration)) == null ? void 0 : _h.importClause) || findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration)); if (errorNode && !((importOrExport == null ? void 0 : importOrExport.isTypeOnly) || findAncestor(location, isImportTypeNode))) { const tsExtension = Debug.checkDefined(tryExtractTSExtension(moduleReference)); error2(errorNode, Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled, tsExtension); } + } else if (compilerOptions.rewriteRelativeImportExtensions && !(location.flags & 33554432 /* Ambient */) && !isDeclarationFileName(moduleReference) && !isLiteralImportTypeNode(location) && !isPartOfTypeOnlyImportOrExportDeclaration(location)) { + const shouldRewrite = shouldRewriteModuleSpecifier(moduleReference, compilerOptions); + if (!resolvedModule.resolvedUsingTsExtension && shouldRewrite) { + error2( + errorNode, + Diagnostics.This_relative_import_path_is_unsafe_to_rewrite_because_it_looks_like_a_file_name_but_actually_resolves_to_0, + getRelativePathFromFile(getNormalizedAbsolutePath(currentSourceFile.fileName, host.getCurrentDirectory()), resolvedModule.resolvedFileName, hostGetCanonicalFileName(host)) + ); + } else if (resolvedModule.resolvedUsingTsExtension && !shouldRewrite && sourceFileMayBeEmitted(sourceFile, host)) { + error2( + errorNode, + Diagnostics.This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path, + getAnyExtensionFromPath(moduleReference) + ); + } else if (resolvedModule.resolvedUsingTsExtension && shouldRewrite) { + const redirect = host.getResolvedProjectReferenceToRedirect(sourceFile.path); + if (redirect) { + const ignoreCase = !host.useCaseSensitiveFileNames(); + const ownRootDir = host.getCommonSourceDirectory(); + const otherRootDir = getCommonSourceDirectoryOfConfig(redirect.commandLine, ignoreCase); + const rootDirPath = getRelativePathFromDirectory(ownRootDir, otherRootDir, ignoreCase); + const outDirPath = getRelativePathFromDirectory(compilerOptions.outDir || ownRootDir, redirect.commandLine.options.outDir || otherRootDir, ignoreCase); + if (rootDirPath !== outDirPath) { + error2( + errorNode, + Diagnostics.This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files + ); + } + } + } } if (sourceFile.symbol) { if (errorNode && resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) { @@ -53292,14 +53834,11 @@ function createTypeChecker(host) { if (ext === ".ts" /* Ts */ || ext === ".js" /* Js */ || ext === ".tsx" /* Tsx */ || ext === ".jsx" /* Jsx */) { diagnosticDetails = createModeMismatchDetails(currentSourceFile); } + const message = (overrideHost == null ? void 0 : overrideHost.kind) === 272 /* ImportDeclaration */ && ((_i = overrideHost.importClause) == null ? void 0 : _i.isTypeOnly) ? Diagnostics.Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute : (overrideHost == null ? void 0 : overrideHost.kind) === 205 /* ImportType */ ? Diagnostics.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute : Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead; diagnostics.add(createDiagnosticForNodeFromMessageChain( getSourceFileOfNode(errorNode), errorNode, - chainDiagnosticMessages( - diagnosticDetails, - Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead, - moduleReference - ) + chainDiagnosticMessages(diagnosticDetails, message, moduleReference) )); } } @@ -53926,6 +54465,7 @@ function createTypeChecker(host) { if (!isExternalOrCommonJsModule(location)) { break; } + // falls through case 267 /* ModuleDeclaration */: const sym = getSymbolOfDeclaration(location); if (result = callback( @@ -53991,7 +54531,7 @@ function createTypeChecker(host) { const links = getSymbolLinks(symbol); const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map()); const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node); - const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`; + const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation ? getNodeId(firstRelevantLocation) : 0}|${meaning}`; if (cache.has(key)) { return cache.get(key); } @@ -54448,12 +54988,194 @@ function createTypeChecker(host) { return getTypeFromTypeNode(node); } function createNodeBuilder() { + const syntacticBuilderResolver = { + evaluateEntityNameExpression, + isExpandoFunctionDeclaration, + hasLateBindableName, + shouldRemoveDeclaration(context, node) { + return !(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */); + }, + createRecoveryBoundary(context) { + return createRecoveryBoundary(context); + }, + isDefinitelyReferenceToGlobalSymbolObject, + getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration, + requiresAddingImplicitUndefined(declaration, symbol, enclosingDeclaration) { + var _a; + switch (declaration.kind) { + case 172 /* PropertyDeclaration */: + case 171 /* PropertySignature */: + case 348 /* JSDocPropertyTag */: + symbol ?? (symbol = getSymbolOfDeclaration(declaration)); + const type = getTypeOfSymbol(symbol); + return !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declaration) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type)); + case 169 /* Parameter */: + case 341 /* JSDocParameterTag */: + return requiresAddingImplicitUndefined(declaration, enclosingDeclaration); + default: + Debug.assertNever(declaration); + } + }, + isOptionalParameter, + isUndefinedIdentifierExpression(node) { + Debug.assert(isExpressionNode(node)); + return getSymbolAtLocation(node) === undefinedSymbol; + }, + isEntityNameVisible(context, entityName, shouldComputeAliasToMakeVisible) { + return isEntityNameVisible(entityName, context.enclosingDeclaration, shouldComputeAliasToMakeVisible); + }, + serializeExistingTypeNode(context, typeNode, addUndefined) { + return serializeExistingTypeNode(context, typeNode, !!addUndefined); + }, + serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) { + const context = syntacticContext; + const signature = getSignatureFromDeclaration(signatureDeclaration); + const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper); + return serializeInferredReturnTypeForSignature(context, signature, returnType); + }, + serializeTypeOfExpression(syntacticContext, expr) { + const context = syntacticContext; + const type = instantiateType(getWidenedType(getRegularTypeOfExpression(expr)), context.mapper); + return typeToTypeNodeHelper(type, context); + }, + serializeTypeOfDeclaration(syntacticContext, declaration, symbol) { + var _a; + const context = syntacticContext; + symbol ?? (symbol = getSymbolOfDeclaration(declaration)); + let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol)); + if (type === void 0) { + type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType; + } + const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration); + if (addUndefinedForParameter) { + type = getOptionalType(type); + } + return serializeInferredTypeForDeclaration(symbol, context, type); + }, + serializeNameOfParameter(context, parameter) { + return parameterToParameterDeclarationName(getSymbolOfDeclaration(parameter), parameter, context); + }, + serializeEntityName(syntacticContext, node) { + const context = syntacticContext; + const symbol = getSymbolAtLocation( + node, + /*ignoreErrors*/ + true + ); + if (!symbol) return void 0; + if (!isValueSymbolAccessible(symbol, context.enclosingDeclaration)) return void 0; + return symbolToExpression(symbol, context, 111551 /* Value */ | 1048576 /* ExportValue */); + }, + serializeTypeName(context, node, isTypeOf, typeArguments) { + return serializeTypeName(context, node, isTypeOf, typeArguments); + }, + getJsDocPropertyOverride(syntacticContext, jsDocTypeLiteral, jsDocProperty) { + const context = syntacticContext; + const name = isIdentifier(jsDocProperty.name) ? jsDocProperty.name : jsDocProperty.name.right; + const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, jsDocTypeLiteral), name.escapedText); + const overrideTypeNode = typeViaParent && jsDocProperty.typeExpression && getTypeFromTypeNode2(context, jsDocProperty.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0; + return overrideTypeNode; + }, + enterNewScope(context, node) { + if (isFunctionLike(node) || isJSDocSignature(node)) { + const signature = getSignatureFromDeclaration(node); + const expandedParams = getExpandedParameters( + signature, + /*skipUnionExpanding*/ + true + )[0]; + return enterNewScope(context, node, expandedParams, signature.typeParameters); + } else { + const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))]; + return enterNewScope( + context, + node, + /*expandedParams*/ + void 0, + typeParameters + ); + } + }, + markNodeReuse(context, range, location) { + return setTextRange2(context, range, location); + }, + trackExistingEntityName(context, node) { + return trackExistingEntityName(node, context); + }, + trackComputedName(context, accessExpression) { + trackComputedName(accessExpression, context.enclosingDeclaration, context); + }, + getModuleSpecifierOverride(syntacticContext, parent2, lit) { + const context = syntacticContext; + if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) { + let name = lit.text; + const nodeSymbol = getNodeLinks(parent2).resolvedSymbol; + const meaning = parent2.isTypeOf ? 111551 /* Value */ : 788968 /* Type */; + const parentSymbol = nodeSymbol && isSymbolAccessible( + nodeSymbol, + context.enclosingDeclaration, + meaning, + /*shouldComputeAliasesToMakeVisible*/ + false + ).accessibility === 0 /* Accessible */ && lookupSymbolChain( + nodeSymbol, + context, + meaning, + /*yieldModuleSymbol*/ + true + )[0]; + if (parentSymbol && isExternalModuleSymbol(parentSymbol)) { + name = getSpecifierForModuleSymbol(parentSymbol, context); + } else { + const targetFile = getExternalModuleFileFromDeclaration(parent2); + if (targetFile) { + name = getSpecifierForModuleSymbol(targetFile.symbol, context); + } + } + if (name.includes("/node_modules/")) { + context.encounteredError = true; + if (context.tracker.reportLikelyUnsafeImportRequiredError) { + context.tracker.reportLikelyUnsafeImportRequiredError(name); + } + } + return name; + } + }, + canReuseTypeNode(context, typeNode) { + return canReuseTypeNode(context, typeNode); + }, + canReuseTypeNodeAnnotation(syntacticContext, node, existing, symbol, requiresAddingUndefined) { + var _a; + const context = syntacticContext; + if (context.enclosingDeclaration === void 0) return false; + symbol ?? (symbol = getSymbolOfDeclaration(node)); + let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol)); + if (type === void 0) { + if (symbol.flags & 98304 /* Accessor */) { + type = node.kind === 178 /* SetAccessor */ ? getWriteTypeOfSymbol(symbol) : getTypeOfAccessors(symbol); + } else if (isValueSignatureDeclaration(node)) { + type = getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } else { + type = getTypeOfSymbol(symbol); + } + } + let annotationType = getTypeFromTypeNodeWithoutContext(existing); + if (isErrorType(annotationType)) { + return true; + } + if (requiresAddingUndefined && annotationType) { + annotationType = addOptionality(annotationType, !isParameter(node)); + } + return !!annotationType && typeNodeIsEquivalentToType(node, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type); + } + }; return { + syntacticBuilderResolver, typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)), typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)), - expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)), - serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)), - serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)), + serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)), + serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)), + serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)), indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper( indexInfo, context, @@ -54501,65 +55223,6 @@ function createTypeChecker(host) { } return range; } - function expressionOrTypeToTypeNode(context, expr, type, addUndefined) { - const restoreFlags = saveRestoreFlags(context); - if (expr && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) { - syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined); - } - context.internalFlags |= 2 /* NoSyntacticPrinter */; - const result = expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined); - restoreFlags(); - return result; - } - function expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined) { - if (expr) { - const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0; - if (typeNode && !isConstTypeReference(typeNode)) { - const result = tryReuseExistingTypeNode(context, typeNode, type, expr.parent, addUndefined); - if (result) { - return result; - } - } - } - if (addUndefined) { - type = getOptionalType(type); - } - return typeToTypeNodeHelper(type, context); - } - function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined) { - const originalType = type; - if (addUndefined) { - type = getOptionalType(type, !isParameter(host2)); - } - const clone2 = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2); - if (clone2) { - if (addUndefined && containsNonMissingUndefinedType(type) && !someType(getTypeFromTypeNode2(context, typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) { - return factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); - } - return clone2; - } - if (addUndefined && originalType !== type) { - const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2); - if (cloneMissingUndefined) { - return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); - } - } - return void 0; - } - function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType = getTypeFromTypeNode2( - context, - existing, - /*noMappedTypes*/ - true - )) { - if (annotationType && typeNodeIsEquivalentToType(host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) { - const result = tryReuseExistingTypeNodeHelper(context, existing); - if (result) { - return result; - } - } - return void 0; - } function symbolToNode(symbol, context, meaning) { if (context.internalFlags & 1 /* WriteComputedProps */) { if (symbol.valueDeclaration) { @@ -54583,6 +55246,7 @@ function createTypeChecker(host) { internalFlags: internalFlags || 0 /* None */, tracker: void 0, encounteredError: false, + suppressReportInferenceFallback: false, reportedDiagnostic: false, visitedTypes: void 0, symbolDepth: void 0, @@ -54601,6 +55265,7 @@ function createTypeChecker(host) { typeParameterNames: void 0, typeParameterNamesByText: void 0, typeParameterNamesByTextNextNameCount: void 0, + enclosingSymbolTypes: /* @__PURE__ */ new Map(), mapper: void 0 }; context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost); @@ -54610,6 +55275,19 @@ function createTypeChecker(host) { } return context.encounteredError ? void 0 : resultingNode; } + function addSymbolTypeToContext(context, symbol, type) { + const id = getSymbolId(symbol); + const oldType = context.enclosingSymbolTypes.get(id); + context.enclosingSymbolTypes.set(id, type); + return restore; + function restore() { + if (oldType) { + context.enclosingSymbolTypes.set(id, oldType); + } else { + context.enclosingSymbolTypes.delete(id); + } + } + } function saveRestoreFlags(context) { const flags = context.flags; const internalFlags = context.internalFlags; @@ -55021,8 +55699,8 @@ function createTypeChecker(host) { if (isInstantiationExpressionType) { const instantiationExpressionType = type2; const existing = instantiationExpressionType.node; - if (isTypeQueryNode(existing)) { - const typeNode = tryReuseExistingNonParameterTypeNode(context, existing, type2); + if (isTypeQueryNode(existing) && getTypeFromTypeNode2(context, existing) === type2) { + const typeNode = syntacticNodeBuilder.tryReuseExistingTypeNode(context, existing); if (typeNode) { return typeNode; } @@ -55364,6 +56042,9 @@ function createTypeChecker(host) { } function createTypeNodesFromResolvedType(resolvedType) { if (checkTruncationLength(context)) { + if (context.flags & 1 /* NoTruncation */) { + return [addSyntheticTrailingComment(factory.createNotEmittedTypeElement(), 3 /* MultiLineCommentTrivia */, "elided")]; + } return [factory.createPropertySignature( /*modifiers*/ void 0, @@ -55401,15 +56082,20 @@ function createTypeChecker(host) { } } if (checkTruncationLength(context) && i + 2 < properties.length - 1) { - typeElements.push(factory.createPropertySignature( - /*modifiers*/ - void 0, - `... ${properties.length - i} more ...`, - /*questionToken*/ - void 0, - /*type*/ - void 0 - )); + if (context.flags & 1 /* NoTruncation */) { + const typeElement = typeElements.pop(); + typeElements.push(addSyntheticTrailingComment(typeElement, 3 /* MultiLineCommentTrivia */, `... ${properties.length - i} more elided ...`)); + } else { + typeElements.push(factory.createPropertySignature( + /*modifiers*/ + void 0, + `... ${properties.length - i} more ...`, + /*questionToken*/ + void 0, + /*type*/ + void 0 + )); + } addPropertyToElementList(properties[properties.length - 1], context, typeElements); break; } @@ -55427,7 +56113,7 @@ function createTypeChecker(host) { void 0 ); } - return factory.createKeywordTypeNode(133 /* AnyKeyword */); + return addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided"); } function shouldUsePlaceholderForProperty(propertySymbol, context) { var _a; @@ -55503,7 +56189,7 @@ function createTypeChecker(host) { const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */); for (const signature of signatures) { const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 173 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken }); - typeElements.push(preserveCommentsOn(methodDeclaration)); + typeElements.push(preserveCommentsOn(methodDeclaration, signature.declaration || propertySymbol.valueDeclaration)); } if (signatures.length || !optionalToken) { return; @@ -55538,8 +56224,8 @@ function createTypeChecker(host) { optionalToken, propertyTypeNode ); - typeElements.push(preserveCommentsOn(propertySignature)); - function preserveCommentsOn(node) { + typeElements.push(preserveCommentsOn(propertySignature, propertySymbol.valueDeclaration)); + function preserveCommentsOn(node, range) { var _a2; const jsdocPropertyTag = (_a2 = propertySymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 348 /* JSDocPropertyTag */); if (jsdocPropertyTag) { @@ -55547,8 +56233,8 @@ function createTypeChecker(host) { if (commentText) { setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]); } - } else if (propertySymbol.valueDeclaration) { - setCommentRange2(context, node, propertySymbol.valueDeclaration); + } else if (range) { + setCommentRange2(context, node, range); } return node; } @@ -55563,15 +56249,17 @@ function createTypeChecker(host) { if (some(types)) { if (checkTruncationLength(context)) { if (!isBareList) { - return [factory.createTypeReferenceNode( - "...", - /*typeArguments*/ - void 0 - )]; + return [ + context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided") : factory.createTypeReferenceNode( + "...", + /*typeArguments*/ + void 0 + ) + ]; } else if (types.length > 2) { return [ typeToTypeNodeHelper(types[0], context), - factory.createTypeReferenceNode( + context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - 2} more elided ...`) : factory.createTypeReferenceNode( `... ${types.length - 2} more ...`, /*typeArguments*/ void 0 @@ -55587,11 +56275,13 @@ function createTypeChecker(host) { for (const type of types) { i++; if (checkTruncationLength(context) && i + 2 < types.length - 1) { - result.push(factory.createTypeReferenceNode( - `... ${types.length - i} more ...`, - /*typeArguments*/ - void 0 - )); + result.push( + context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - i} more elided ...`) : factory.createTypeReferenceNode( + `... ${types.length - i} more ...`, + /*typeArguments*/ + void 0 + ) + ); const typeNode2 = typeToTypeNodeHelper(types[types.length - 1], context); if (typeNode2) { result.push(typeNode2); @@ -55761,14 +56451,85 @@ function createTypeChecker(host) { cleanup == null ? void 0 : cleanup(); return node; } - function isNewScopeNode(node) { - return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node); - } - function getTypeParametersInScope(node) { - return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))]; - } - function getParametersInScope(node) { - return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0; + function createRecoveryBoundary(context) { + if (cancellationToken && cancellationToken.throwIfCancellationRequested) { + cancellationToken.throwIfCancellationRequested(); + } + let trackedSymbols; + let unreportedErrors; + let hadError = false; + const oldTracker = context.tracker; + const oldTrackedSymbols = context.trackedSymbols; + context.trackedSymbols = void 0; + const oldEncounteredError = context.encounteredError; + context.tracker = new SymbolTrackerImpl(context, { + ...oldTracker.inner, + reportCyclicStructureError() { + markError(() => oldTracker.reportCyclicStructureError()); + }, + reportInaccessibleThisError() { + markError(() => oldTracker.reportInaccessibleThisError()); + }, + reportInaccessibleUniqueSymbolError() { + markError(() => oldTracker.reportInaccessibleUniqueSymbolError()); + }, + reportLikelyUnsafeImportRequiredError(specifier) { + markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier)); + }, + reportNonSerializableProperty(name) { + markError(() => oldTracker.reportNonSerializableProperty(name)); + }, + reportPrivateInBaseOfClassExpression(propertyName) { + markError(() => oldTracker.reportPrivateInBaseOfClassExpression(propertyName)); + }, + trackSymbol(sym, decl, meaning) { + (trackedSymbols ?? (trackedSymbols = [])).push([sym, decl, meaning]); + return false; + }, + moduleResolverHost: context.tracker.moduleResolverHost + }, context.tracker.moduleResolverHost); + return { + startRecoveryScope, + finalizeBoundary, + markError, + hadError: () => hadError + }; + function markError(unreportedError) { + hadError = true; + if (unreportedError) { + (unreportedErrors ?? (unreportedErrors = [])).push(unreportedError); + } + } + function startRecoveryScope() { + const trackedSymbolsTop = (trackedSymbols == null ? void 0 : trackedSymbols.length) ?? 0; + const unreportedErrorsTop = (unreportedErrors == null ? void 0 : unreportedErrors.length) ?? 0; + return () => { + hadError = false; + if (trackedSymbols) { + trackedSymbols.length = trackedSymbolsTop; + } + if (unreportedErrors) { + unreportedErrors.length = unreportedErrorsTop; + } + }; + } + function finalizeBoundary() { + context.tracker = oldTracker; + context.trackedSymbols = oldTrackedSymbols; + context.encounteredError = oldEncounteredError; + unreportedErrors == null ? void 0 : unreportedErrors.forEach((fn) => fn()); + if (hadError) { + return false; + } + trackedSymbols == null ? void 0 : trackedSymbols.forEach( + ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol( + symbol, + enclosingDeclaration, + meaning + ) + ); + return true; + } } function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters, mapper) { const cleanupContext = cloneNodeBuilderContext(context); @@ -55911,7 +56672,7 @@ function createTypeChecker(host) { return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode); } function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) { - return typeNode && tryReuseExistingNonParameterTypeNode(context, typeNode, type) || typeToTypeNodeHelper(type, context); + return typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context); } function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) { const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context); @@ -56525,41 +57286,46 @@ function createTypeChecker(host) { } return enclosingDeclaration; } - function serializeTypeForDeclaration(context, declaration, type, symbol) { - var _a, _b; - const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration); - const enclosingDeclaration = context.enclosingDeclaration; - const restoreFlags = saveRestoreFlags(context); - if (declaration && hasInferredType(declaration) && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) { - syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context); - } - context.internalFlags |= 2 /* NoSyntacticPrinter */; - if (enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */)) { - const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol); - if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) { - const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation); - const addUndefined = addUndefinedForParameter || !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declWithExistingAnnotation) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type)); - const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined); - if (result2) { - restoreFlags(); - return result2; - } - } - } - if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) { + function serializeInferredTypeForDeclaration(symbol, context, type) { + if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === context.enclosingFile))) { context.flags |= 1048576 /* AllowUniqueESSymbolType */; } - const decl = declaration ?? symbol.valueDeclaration ?? ((_b = symbol.declarations) == null ? void 0 : _b[0]); - const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0; - const result = expressionOrTypeToTypeNode(context, expr, type, addUndefinedForParameter); - restoreFlags(); + const result = typeToTypeNodeHelper(type, context); return result; } + function serializeTypeForDeclaration(context, declaration, type, symbol) { + var _a; + let result; + const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration); + const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]); + if (decl) { + if (isAccessor(decl)) { + result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context); + } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) { + const restore = addSymbolTypeToContext(context, symbol, type); + result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context); + restore(); + } + } + if (!result) { + if (addUndefinedForParameter) { + type = getOptionalType(type); + } + result = serializeInferredTypeForDeclaration(symbol, context, type); + } + return result ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) { if (typeFromTypeNode === type) { return true; } - if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertySignature(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) { + if (!annotatedDeclaration) { + return false; + } + if ((isPropertySignature(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) { + return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode; + } + if (isParameter(annotatedDeclaration) && hasEffectiveQuestionToken(annotatedDeclaration)) { return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode; } return false; @@ -56570,37 +57336,32 @@ function createTypeChecker(host) { if (suppressAny) context.flags &= ~256 /* SuppressAnyReturnType */; let returnTypeNode; const returnType = getReturnTypeOfSignature(signature); - if (returnType && !(suppressAny && isTypeAny(returnType))) { - if (signature.declaration && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) { - syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context); + if (!(suppressAny && isTypeAny(returnType))) { + if (signature.declaration && !nodeIsSynthesized(signature.declaration)) { + const declarationSymbol = getSymbolOfDeclaration(signature.declaration); + const restore = addSymbolTypeToContext(context, declarationSymbol, returnType); + returnTypeNode = syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, declarationSymbol, context); + restore(); } - context.internalFlags |= 2 /* NoSyntacticPrinter */; - returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature); - } else if (!suppressAny) { + if (!returnTypeNode) { + returnTypeNode = serializeInferredReturnTypeForSignature(context, signature, returnType); + } + } + if (!returnTypeNode && !suppressAny) { returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */); } restoreFlags(); return returnTypeNode; } - function serializeReturnTypeForSignatureWorker(context, signature) { + function serializeInferredReturnTypeForSignature(context, signature, returnType) { + const oldSuppressReportInferenceFallback = context.suppressReportInferenceFallback; + context.suppressReportInferenceFallback = true; const typePredicate = getTypePredicateOfSignature(signature); - const type = getReturnTypeOfSignature(signature); - if (context.enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) { - const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration); - if (annotation) { - const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration); - if (result) { - return result; - } - } - } - if (typePredicate) { - return typePredicateToTypePredicateNodeHelper(typePredicate, context); - } - const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration); - return expressionOrTypeToTypeNode(context, expr, type); + const returnTypeNode = typePredicate ? typePredicateToTypePredicateNodeHelper(context.mapper ? instantiateTypePredicate(typePredicate, context.mapper) : typePredicate, context) : typeToTypeNodeHelper(returnType, context); + context.suppressReportInferenceFallback = oldSuppressReportInferenceFallback; + return returnTypeNode; } - function trackExistingEntityName(node, context) { + function trackExistingEntityName(node, context, enclosingDeclaration = context.enclosingDeclaration) { let introducesError = false; const leftmost = getFirstIdentifier(node); if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) { @@ -56651,7 +57412,7 @@ function createTypeChecker(host) { if ( // Check for unusable parameters symbols symAtLocation === unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node - symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference + symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it should point to the same reference symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym) ) { if (symAtLocation !== unknownSymbol) { @@ -56672,7 +57433,7 @@ function createTypeChecker(host) { if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the current context if they are are resolvable !isDeclarationName(node) && isSymbolAccessible( sym, - context.enclosingDeclaration, + enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ false @@ -56680,7 +57441,7 @@ function createTypeChecker(host) { context.tracker.reportInferenceFallback(node); introducesError = true; } else { - context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning); + context.tracker.trackSymbol(sym, enclosingDeclaration, meaning); } return { introducesError, node: attachSymbolToLeftmostIdentifier(node) }; } @@ -56724,6 +57485,15 @@ function createTypeChecker(host) { return symbolToTypeNode(resolvedSymbol, context, meaning, typeArguments); } function canReuseTypeNode(context, existing) { + const type = getTypeFromTypeNode2( + context, + existing, + /*noMappedTypes*/ + true + ); + if (!type) { + return false; + } if (isInJSFile(existing)) { if (isLiteralImportTypeNode(existing)) { void getTypeFromImportTypeNode(existing); @@ -56733,29 +57503,16 @@ function createTypeChecker(host) { !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol)))); } } - if (isThisTypeNode(existing)) { - if (context.mapper === void 0) return true; - const type = getTypeFromTypeNode2( - context, - existing, - /*noMappedTypes*/ - true - ); - return !!type; - } if (isTypeReferenceNode(existing)) { if (isConstTypeReference(existing)) return false; - const type = getTypeFromTypeReference(existing); const symbol = getNodeLinks(existing).resolvedSymbol; if (!symbol) return false; if (symbol.flags & 262144 /* TypeParameter */) { - const type2 = getDeclaredTypeOfSymbol(symbol); - if (context.mapper && getMappedType(type2, context.mapper) !== type2) { - return false; - } + const declaredType = getDeclaredTypeOfSymbol(symbol); + return !(context.mapper && getMappedType(declaredType, context.mapper) !== declaredType); } if (isInJSDoc(existing)) { - return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */; + return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && !!(symbol.flags & 788968 /* Type */); } } if (isTypeOperatorNode(existing) && existing.operator === 158 /* UniqueKeyword */ && existing.type.kind === 155 /* SymbolKeyword */) { @@ -56764,512 +57521,16 @@ function createTypeChecker(host) { } return true; } - function serializeExistingTypeNode(context, typeNode) { + function serializeExistingTypeNode(context, typeNode, addUndefined) { const type = getTypeFromTypeNode2(context, typeNode); + if (addUndefined && !someType(type, (t) => !!(t.flags & 32768 /* Undefined */)) && canReuseTypeNode(context, typeNode)) { + const clone2 = syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode); + if (clone2) { + return factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); + } + } return typeToTypeNodeHelper(type, context); } - function tryReuseExistingTypeNodeHelper(context, existing) { - if (cancellationToken && cancellationToken.throwIfCancellationRequested) { - cancellationToken.throwIfCancellationRequested(); - } - let hadError = false; - const { finalizeBoundary, startRecoveryScope } = createRecoveryBoundary(); - const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode); - if (!finalizeBoundary()) { - return void 0; - } - context.approximateLength += existing.end - existing.pos; - return transformed; - function visitExistingNodeTreeSymbols(node) { - if (hadError) return node; - const recover = startRecoveryScope(); - const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0; - const result = visitExistingNodeTreeSymbolsWorker(node); - onExitNewScope == null ? void 0 : onExitNewScope(); - if (hadError) { - if (isTypeNode(node) && !isTypePredicateNode(node)) { - recover(); - return serializeExistingTypeNode(context, node); - } - return node; - } - return result ? setTextRange2(context, result, node) : void 0; - } - function createRecoveryBoundary() { - let trackedSymbols; - let unreportedErrors; - const oldTracker = context.tracker; - const oldTrackedSymbols = context.trackedSymbols; - context.trackedSymbols = void 0; - const oldEncounteredError = context.encounteredError; - context.tracker = new SymbolTrackerImpl(context, { - ...oldTracker.inner, - reportCyclicStructureError() { - markError(() => oldTracker.reportCyclicStructureError()); - }, - reportInaccessibleThisError() { - markError(() => oldTracker.reportInaccessibleThisError()); - }, - reportInaccessibleUniqueSymbolError() { - markError(() => oldTracker.reportInaccessibleUniqueSymbolError()); - }, - reportLikelyUnsafeImportRequiredError(specifier) { - markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier)); - }, - reportNonSerializableProperty(name) { - markError(() => oldTracker.reportNonSerializableProperty(name)); - }, - trackSymbol(sym, decl, meaning) { - (trackedSymbols ?? (trackedSymbols = [])).push([sym, decl, meaning]); - return false; - }, - moduleResolverHost: context.tracker.moduleResolverHost - }, context.tracker.moduleResolverHost); - return { - startRecoveryScope: startRecoveryScope2, - finalizeBoundary: finalizeBoundary2 - }; - function markError(unreportedError) { - hadError = true; - (unreportedErrors ?? (unreportedErrors = [])).push(unreportedError); - } - function startRecoveryScope2() { - const trackedSymbolsTop = (trackedSymbols == null ? void 0 : trackedSymbols.length) ?? 0; - const unreportedErrorsTop = (unreportedErrors == null ? void 0 : unreportedErrors.length) ?? 0; - return () => { - hadError = false; - if (trackedSymbols) { - trackedSymbols.length = trackedSymbolsTop; - } - if (unreportedErrors) { - unreportedErrors.length = unreportedErrorsTop; - } - }; - } - function finalizeBoundary2() { - context.tracker = oldTracker; - context.trackedSymbols = oldTrackedSymbols; - context.encounteredError = oldEncounteredError; - unreportedErrors == null ? void 0 : unreportedErrors.forEach((fn) => fn()); - if (hadError) { - return false; - } - trackedSymbols == null ? void 0 : trackedSymbols.forEach( - ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol( - symbol, - enclosingDeclaration, - meaning - ) - ); - return true; - } - } - function onEnterNewScope(node) { - return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node)); - } - function tryVisitSimpleTypeNode(node) { - const innerNode = skipTypeParentheses(node); - switch (innerNode.kind) { - case 183 /* TypeReference */: - return tryVisitTypeReference(innerNode); - case 186 /* TypeQuery */: - return tryVisitTypeQuery(innerNode); - case 199 /* IndexedAccessType */: - return tryVisitIndexedAccess(innerNode); - case 198 /* TypeOperator */: - const typeOperatorNode = innerNode; - if (typeOperatorNode.operator === 143 /* KeyOfKeyword */) { - return tryVisitKeyOf(typeOperatorNode); - } - } - return visitNode(node, visitExistingNodeTreeSymbols, isTypeNode); - } - function tryVisitIndexedAccess(node) { - const resultObjectType = tryVisitSimpleTypeNode(node.objectType); - if (resultObjectType === void 0) { - return void 0; - } - return factory.updateIndexedAccessTypeNode(node, resultObjectType, visitNode(node.indexType, visitExistingNodeTreeSymbols, isTypeNode)); - } - function tryVisitKeyOf(node) { - Debug.assertEqual(node.operator, 143 /* KeyOfKeyword */); - const type = tryVisitSimpleTypeNode(node.type); - if (type === void 0) { - return void 0; - } - return factory.updateTypeOperatorNode(node, type); - } - function tryVisitTypeQuery(node) { - const { introducesError, node: exprName } = trackExistingEntityName(node.exprName, context); - if (!introducesError) { - return factory.updateTypeQueryNode( - node, - exprName, - visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode) - ); - } - const serializedName = serializeTypeName( - context, - node.exprName, - /*isTypeOf*/ - true - ); - if (serializedName) { - return setTextRange2(context, serializedName, node.exprName); - } - } - function tryVisitTypeReference(node) { - if (canReuseTypeNode(context, node)) { - const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context); - const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode); - if (!introducesError) { - const updated = factory.updateTypeReferenceNode( - node, - newName, - typeArguments - ); - return setTextRange2(context, updated, node); - } else { - const serializedName = serializeTypeName( - context, - node.typeName, - /*isTypeOf*/ - false, - typeArguments - ); - if (serializedName) { - return setTextRange2(context, serializedName, node.typeName); - } - } - } - } - function visitExistingNodeTreeSymbolsWorker(node) { - if (isJSDocTypeExpression(node)) { - return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode); - } - if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) { - return factory.createKeywordTypeNode(133 /* AnyKeyword */); - } - if (isJSDocUnknownType(node)) { - return factory.createKeywordTypeNode(159 /* UnknownKeyword */); - } - if (isJSDocNullableType(node)) { - return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createLiteralTypeNode(factory.createNull())]); - } - if (isJSDocOptionalType(node)) { - return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); - } - if (isJSDocNonNullableType(node)) { - return visitNode(node.type, visitExistingNodeTreeSymbols); - } - if (isJSDocVariadicType(node)) { - return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode)); - } - if (isJSDocTypeLiteral(node)) { - return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => { - const name = visitNode(isIdentifier(t.name) ? t.name : t.name.right, visitExistingNodeTreeSymbols, isIdentifier); - const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, node), name.escapedText); - const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode2(context, t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0; - return factory.createPropertySignature( - /*modifiers*/ - void 0, - name, - t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(58 /* QuestionToken */) : void 0, - overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) - ); - })); - } - if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") { - return setOriginalNode(factory.createKeywordTypeNode(133 /* AnyKeyword */), node); - } - if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) { - return factory.createTypeLiteralNode([factory.createIndexSignature( - /*modifiers*/ - void 0, - [factory.createParameterDeclaration( - /*modifiers*/ - void 0, - /*dotDotDotToken*/ - void 0, - "x", - /*questionToken*/ - void 0, - visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols, isTypeNode) - )], - visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols, isTypeNode) - )]); - } - if (isJSDocFunctionType(node)) { - if (isJSDocConstructSignature(node)) { - let newTypeNode; - return factory.createConstructorTypeNode( - /*modifiers*/ - void 0, - visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration), - mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration( - /*modifiers*/ - void 0, - getEffectiveDotDotDotForParameter(p), - setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p), - factory.cloneNode(p.questionToken), - visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode), - /*initializer*/ - void 0 - )), - visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) - ); - } else { - return factory.createFunctionTypeNode( - visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration), - map(node.parameters, (p, i) => factory.createParameterDeclaration( - /*modifiers*/ - void 0, - getEffectiveDotDotDotForParameter(p), - setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p), - factory.cloneNode(p.questionToken), - visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode), - /*initializer*/ - void 0 - )), - visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) - ); - } - } - if (isThisTypeNode(node)) { - if (canReuseTypeNode(context, node)) { - return node; - } - hadError = true; - return node; - } - if (isTypeParameterDeclaration(node)) { - return factory.updateTypeParameterDeclaration( - node, - visitNodes2(node.modifiers, visitExistingNodeTreeSymbols, isModifier), - setTextRange2(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node), - visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode), - visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode) - ); - } - if (isIndexedAccessTypeNode(node)) { - const result = tryVisitIndexedAccess(node); - if (!result) { - hadError = true; - return node; - } - return result; - } - if (isTypeReferenceNode(node)) { - const result = tryVisitTypeReference(node); - if (result) { - return result; - } - hadError = true; - return node; - } - if (isLiteralImportTypeNode(node)) { - const nodeSymbol = getNodeLinks(node).resolvedSymbol; - if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic - (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic - !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) { - return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode2(context, node), context), node); - } - return factory.updateImportTypeNode( - node, - factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), - visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes), - visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName), - visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode), - node.isTypeOf - ); - } - if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) { - if (!hasDynamicName(node)) { - return visitEachChild2(node, visitExistingNodeTreeSymbols); - } - if (!(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) { - return void 0; - } - } - if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) { - let visited = visitEachChild2(node, visitExistingNodeTreeSymbols); - if (visited === node) { - visited = setTextRange2(context, factory.cloneNode(node), node); - } - visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */); - if (isParameter(node)) { - visited.modifiers = void 0; - } - return visited; - } - if (isTypeQueryNode(node)) { - const result = tryVisitTypeQuery(node); - if (!result) { - hadError = true; - return node; - } - return result; - } - if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) { - const { node: result, introducesError } = trackExistingEntityName(node.expression, context); - if (!introducesError) { - return factory.updateComputedPropertyName(node, result); - } else { - const type = getWidenedType(getRegularTypeOfExpression(node.expression)); - const computedPropertyNameType = typeToTypeNodeHelper(type, context); - let literal; - if (isLiteralTypeNode(computedPropertyNameType)) { - literal = computedPropertyNameType.literal; - } else { - const evaluated = evaluateEntityNameExpression(node.expression); - const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral( - evaluated.value, - /*isSingleQuote*/ - void 0 - ) : typeof evaluated.value === "number" ? factory.createNumericLiteral( - evaluated.value, - /*numericLiteralFlags*/ - 0 - ) : void 0; - if (!literalNode) { - if (isImportTypeNode(computedPropertyNameType)) { - trackComputedName(node.expression, context.enclosingDeclaration, context); - } - return node; - } - literal = literalNode; - } - if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) { - return factory.createIdentifier(literal.text); - } - if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) { - return literal; - } - return factory.updateComputedPropertyName(node, literal); - } - } - if (isTypePredicateNode(node)) { - let parameterName; - if (isIdentifier(node.parameterName)) { - const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context); - hadError = hadError || introducesError; - parameterName = result; - } else { - parameterName = factory.cloneNode(node.parameterName); - } - return factory.updateTypePredicateNode(node, factory.cloneNode(node.assertsModifier), parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode)); - } - if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) { - const visited = visitEachChild2(node, visitExistingNodeTreeSymbols); - const clone2 = setTextRange2(context, visited === node ? factory.cloneNode(node) : visited, node); - const flags = getEmitFlags(clone2); - setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */)); - return clone2; - } - if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) { - const clone2 = factory.cloneNode(node); - clone2.singleQuote = true; - return clone2; - } - if (isConditionalTypeNode(node)) { - const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode); - const disposeScope = onEnterNewScope(node); - const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode); - const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode); - disposeScope(); - const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode); - return factory.updateConditionalTypeNode( - node, - checkType, - extendType, - trueType2, - falseType2 - ); - } - if (isTypeOperatorNode(node)) { - if (node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) { - if (!canReuseTypeNode(context, node)) { - hadError = true; - return node; - } - } else if (node.operator === 143 /* KeyOfKeyword */) { - const result = tryVisitKeyOf(node); - if (!result) { - hadError = true; - return node; - } - return result; - } - } - return visitEachChild2(node, visitExistingNodeTreeSymbols); - function visitEachChild2(node2, visitor) { - const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node2); - return visitEachChild( - node2, - visitor, - /*context*/ - void 0, - nonlocalNode ? visitNodesWithoutCopyingPositions : void 0 - ); - } - function visitNodesWithoutCopyingPositions(nodes, visitor, test, start, count) { - let result = visitNodes2(nodes, visitor, test, start, count); - if (result) { - if (result.pos !== -1 || result.end !== -1) { - if (result === nodes) { - result = factory.createNodeArray(nodes.slice(), nodes.hasTrailingComma); - } - setTextRangePosEnd(result, -1, -1); - } - } - return result; - } - function getEffectiveDotDotDotForParameter(p) { - return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0); - } - function getNameForJSDocFunctionParameter(p, index) { - return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`; - } - function rewriteModuleSpecifier(parent2, lit) { - if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) { - let name = lit.text; - const nodeSymbol = getNodeLinks(node).resolvedSymbol; - const meaning = parent2.isTypeOf ? 111551 /* Value */ : 788968 /* Type */; - const parentSymbol = nodeSymbol && isSymbolAccessible( - nodeSymbol, - context.enclosingDeclaration, - meaning, - /*shouldComputeAliasesToMakeVisible*/ - false - ).accessibility === 0 /* Accessible */ && lookupSymbolChain( - nodeSymbol, - context, - meaning, - /*yieldModuleSymbol*/ - true - )[0]; - if (parentSymbol && isExternalModuleSymbol(parentSymbol)) { - name = getSpecifierForModuleSymbol(parentSymbol, context); - } else { - const targetFile = getExternalModuleFileFromDeclaration(parent2); - if (targetFile) { - name = getSpecifierForModuleSymbol(targetFile.symbol, context); - } - } - if (name.includes("/node_modules/")) { - context.encounteredError = true; - if (context.tracker.reportLikelyUnsafeImportRequiredError) { - context.tracker.reportLikelyUnsafeImportRequiredError(name); - } - } - if (name !== lit.text) { - return setOriginalNode(factory.createStringLiteral(name), lit); - } - } - return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral); - } - } - } function symbolTableToDeclarationStatements(symbolTable, context) { var _a; const serializePropertySymbolForClass = makeSerializePropertySymbol( @@ -57520,7 +57781,9 @@ function createTypeChecker(host) { const skipMembershipCheck = !isPrivate; if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) { const scopeCleanup = cloneNodeBuilderContext(context); + context.tracker.pushErrorFallbackNode(find(symbol.declarations, (d) => getSourceFileOfNode(d) === context.enclosingFile)); serializeSymbolWorker(symbol, isPrivate, propertyAsAlias); + context.tracker.popErrorFallbackNode(); scopeCleanup(); } } @@ -57743,13 +58006,7 @@ function createTypeChecker(host) { context.flags |= 8388608 /* InTypeAlias */; const oldEnclosingDecl = context.enclosingDeclaration; context.enclosingDeclaration = jsdocAliasDecl; - const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && tryReuseExistingNonParameterTypeNode( - context, - jsdocAliasDecl.typeExpression.type, - aliasType, - /*host*/ - void 0 - ) || typeToTypeNodeHelper(aliasType, context); + const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && syntacticNodeBuilder.tryReuseExistingTypeNode(context, jsdocAliasDecl.typeExpression.type) || typeToTypeNodeHelper(aliasType, context); addResult( setSyntheticLeadingComments( factory.createTypeAliasDeclaration( @@ -57982,7 +58239,7 @@ function createTypeChecker(host) { } return cleanup(factory.createExpressionWithTypeArguments( expr, - map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode2(context, a)) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context)) + map(e.typeArguments, (a) => syntacticNodeBuilder.tryReuseExistingTypeNode(context, a) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context)) )); function cleanup(result2) { context.enclosingDeclaration = oldEnclosing; @@ -58178,6 +58435,7 @@ function createTypeChecker(host) { ); break; } + // else fall through and treat commonjs require just like import= case 271 /* ImportEqualsDeclaration */: if (target.escapedName === "export=" /* ExportEquals */ && some(target.declarations, (d) => isSourceFile(d) && isJsonSourceFile(d))) { serializeMaybeAliasAssignment(symbol); @@ -58468,7 +58726,7 @@ function createTypeChecker(host) { } function makeSerializePropertySymbol(createProperty2, methodKind, useAccessors) { return function serializePropertySymbol(p, isStatic2, baseType) { - var _a2, _b, _c, _d, _e; + var _a2, _b, _c, _d, _e, _f; const modifierFlags = getDeclarationModifierFlagsFromSymbol(p); const isPrivate = !!(modifierFlags & 2 /* Private */); if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) { @@ -58498,6 +58756,7 @@ function createTypeChecker(host) { }); Debug.assert(!!setter); const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0; + const setterDeclaration = (_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor); result.push(setTextRange2( context, factory.createSetAccessorDeclaration( @@ -58511,39 +58770,28 @@ function createTypeChecker(host) { paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value", /*questionToken*/ void 0, - isPrivate ? void 0 : serializeTypeForDeclaration( - context, - /*declaration*/ - void 0, - getWriteTypeOfSymbol(p), - p - ) + isPrivate ? void 0 : serializeTypeForDeclaration(context, setterDeclaration, getWriteTypeOfSymbol(p), p) )], /*body*/ void 0 ), - ((_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor)) || firstPropertyLikeDecl + setterDeclaration ?? firstPropertyLikeDecl )); } if (p.flags & 32768 /* GetAccessor */) { const isPrivate2 = modifierFlags & 2 /* Private */; + const getterDeclaration = (_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor); result.push(setTextRange2( context, factory.createGetAccessorDeclaration( factory.createModifiersFromModifierFlags(flag), name, [], - isPrivate2 ? void 0 : serializeTypeForDeclaration( - context, - /*declaration*/ - void 0, - getTypeOfSymbol(p), - p - ), + isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getterDeclaration, getTypeOfSymbol(p), p), /*body*/ void 0 ), - ((_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor)) || firstPropertyLikeDecl + getterDeclaration ?? firstPropertyLikeDecl )); } return result; @@ -58554,19 +58802,13 @@ function createTypeChecker(host) { factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag), name, p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0, - isPrivate ? void 0 : serializeTypeForDeclaration( - context, - /*declaration*/ - void 0, - getWriteTypeOfSymbol(p), - p - ), + isPrivate ? void 0 : serializeTypeForDeclaration(context, (_d = p.declarations) == null ? void 0 : _d.find(isSetAccessorDeclaration), getWriteTypeOfSymbol(p), p), // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357 // interface members can't have initializers, however class members _can_ /*initializer*/ void 0 ), - ((_d = p.declarations) == null ? void 0 : _d.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl + ((_e = p.declarations) == null ? void 0 : _e.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl ); } if (p.flags & (8192 /* Method */ | 16 /* Function */)) { @@ -58584,7 +58826,7 @@ function createTypeChecker(host) { /*initializer*/ void 0 ), - ((_e = p.declarations) == null ? void 0 : _e.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0] + ((_f = p.declarations) == null ? void 0 : _f.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0] ); } const results2 = []; @@ -58627,7 +58869,7 @@ function createTypeChecker(host) { return []; } if (baseSigs.length === signatures.length) { - let failed = false; + let failed2 = false; for (let i = 0; i < baseSigs.length; i++) { if (!compareSignaturesIdentical( signatures[i], @@ -58640,11 +58882,11 @@ function createTypeChecker(host) { true, compareTypesIdentical )) { - failed = true; + failed2 = true; break; } } - if (!failed) { + if (!failed2) { return []; } } @@ -58950,6 +59192,7 @@ function createTypeChecker(host) { if (isBindingPattern(node.name) && !node.name.elements.length) { return false; } + // falls through case 267 /* ModuleDeclaration */: case 263 /* ClassDeclaration */: case 264 /* InterfaceDeclaration */: @@ -58974,6 +59217,8 @@ function createTypeChecker(host) { if (hasEffectiveModifier(node, 2 /* Private */ | 4 /* Protected */)) { return false; } + // Public properties/methods are visible if its parents are visible, so: + // falls through case 176 /* Constructor */: case 180 /* ConstructSignature */: case 179 /* CallSignature */: @@ -58991,14 +59236,20 @@ function createTypeChecker(host) { case 196 /* ParenthesizedType */: case 202 /* NamedTupleMember */: return isDeclarationVisible(node.parent); + // Default binding, import specifier and namespace import is visible + // only on demand so by default it is not visible case 273 /* ImportClause */: case 274 /* NamespaceImport */: case 276 /* ImportSpecifier */: return false; + // Type parameters are always visible case 168 /* TypeParameter */: + // Source file and namespace export are always visible + // falls through case 307 /* SourceFile */: case 270 /* NamespaceExportDeclaration */: return true; + // Export assignments do not create name bindings outside the module case 277 /* ExportAssignment */: return false; default: @@ -59808,7 +60059,7 @@ function createTypeChecker(host) { /*reportErrors*/ false ) : unknownType; - return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType))); + return addOptionality(getWidenedLiteralTypeForInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType))); } if (isBindingPattern(element.name)) { return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2); @@ -59842,7 +60093,6 @@ function createTypeChecker(host) { const flags = 4 /* Property */ | (e.initializer ? 16777216 /* Optional */ : 0); const symbol = createSymbol(flags, text); symbol.links.type = getTypeFromBindingElement(e, includePatternInType, reportErrors2); - symbol.links.bindingElement = e; members.set(symbol.escapedName, symbol); }); const result = createAnonymousType( @@ -60087,7 +60337,7 @@ function createTypeChecker(host) { const getter = getDeclarationOfKind(symbol, 177 /* GetAccessor */); const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */); const accessor = tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration); - let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration( + let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && getWidenedTypeForVariableLikeDeclaration( accessor, /*reportErrors*/ true @@ -60943,11 +61193,20 @@ function createTypeChecker(host) { return type; } function isLateBindableName(node) { + return isLateBindableAST(node) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression)); + } + function isLateBindableIndexSignature(node) { + return isLateBindableAST(node) && isTypeUsableAsIndexSignature(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression)); + } + function isLateBindableAST(node) { if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) { return false; } const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression; - return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr)); + return isEntityNameExpression(expr); + } + function isTypeUsableAsIndexSignature(type) { + return isTypeAssignableTo(type, stringNumberSymbolType); } function isLateBoundName(name) { return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) === 64 /* at */; @@ -60956,6 +61215,10 @@ function createTypeChecker(host) { const name = getNameOfDeclaration(node); return !!name && isLateBindableName(name); } + function hasLateBindableIndexSignature(node) { + const name = getNameOfDeclaration(node); + return !!name && isLateBindableIndexSignature(name); + } function hasBindableName(node) { return !hasDynamicName(node) || hasLateBindableName(node); } @@ -61009,6 +61272,24 @@ function createTypeChecker(host) { } return links.resolvedSymbol; } + function lateBindIndexSignature(parent2, earlySymbols, lateSymbols, decl) { + let indexSymbol = lateSymbols.get("__index" /* Index */); + if (!indexSymbol) { + const early = earlySymbols == null ? void 0 : earlySymbols.get("__index" /* Index */); + if (!early) { + indexSymbol = createSymbol(0 /* None */, "__index" /* Index */, 4096 /* Late */); + } else { + indexSymbol = cloneSymbol(early); + indexSymbol.links.checkFlags |= 4096 /* Late */; + } + lateSymbols.set("__index" /* Index */, indexSymbol); + } + if (!indexSymbol.declarations) { + indexSymbol.declarations = [decl]; + } else if (!decl.symbol.isReplaceableByMethod) { + indexSymbol.declarations.push(decl); + } + } function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) { const links = getSymbolLinks(symbol); if (!links[resolutionKind]) { @@ -61023,6 +61304,8 @@ function createTypeChecker(host) { if (isStatic2 === hasStaticModifier(member)) { if (hasLateBindableName(member)) { lateBindMember(symbol, earlySymbols, lateSymbols, member); + } else if (hasLateBindableIndexSignature(member)) { + lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member); } } } @@ -61131,12 +61414,7 @@ function createTypeChecker(host) { addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType)); callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */)); constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* Construct */)); - const inheritedIndexInfos = instantiatedBaseType !== anyType ? getIndexInfosOfType(instantiatedBaseType) : [createIndexInfo( - stringType, - anyType, - /*isReadonly*/ - false - )]; + const inheritedIndexInfos = instantiatedBaseType !== anyType ? getIndexInfosOfType(instantiatedBaseType) : [anyBaseTypeIndexInfo]; indexInfos = concatenate(indexInfos, filter(inheritedIndexInfos, (info) => !findIndexInfo(indexInfos, info.keyType))); } } @@ -61153,7 +61431,7 @@ function createTypeChecker(host) { resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments); } function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) { - const sig = new Signature14(checker, flags); + const sig = new Signature13(checker, flags); sig.declaration = declaration; sig.typeParameters = typeParameters; sig.parameters = parameters; @@ -61480,8 +61758,13 @@ function createTypeChecker(host) { if (left.typeParameters && right.typeParameters) { paramMapper = createTypeMapper(right.typeParameters, left.typeParameters); } + let flags = (left.flags | right.flags) & (167 /* PropagatingFlags */ & ~1 /* HasRestParameter */); const declaration = left.declaration; const params = combineUnionParameters(left, right, paramMapper); + const lastParam = lastOrUndefined(params); + if (lastParam && getCheckFlags(lastParam) & 32768 /* RestParameter */) { + flags |= 1 /* HasRestParameter */; + } const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper); const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); const result = createSignature( @@ -61494,7 +61777,7 @@ function createTypeChecker(host) { /*resolvedTypePredicate*/ void 0, minArgCount, - (left.flags | right.flags) & 167 /* PropagatingFlags */ + flags ); result.compositeKind = 1048576 /* Union */; result.compositeSignatures = concatenate(left.compositeKind !== 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]); @@ -61657,17 +61940,12 @@ function createTypeChecker(host) { members = createSymbolTable(getNamedOrIndexSignatureMembers(members)); addInheritedMembers(members, getPropertiesOfType(baseConstructorType)); } else if (baseConstructorType === anyType) { - baseConstructorIndexInfo = createIndexInfo( - stringType, - anyType, - /*isReadonly*/ - false - ); + baseConstructorIndexInfo = anyBaseTypeIndexInfo; } } const indexSymbol = getIndexSymbolFromSymbolTable(members); if (indexSymbol) { - indexInfos = getIndexInfosOfIndexSymbol(indexSymbol); + indexInfos = getIndexInfosOfIndexSymbol(indexSymbol, arrayFrom(members.values())); } else { if (baseConstructorIndexInfo) { indexInfos = append(indexInfos, baseConstructorIndexInfo); @@ -63286,7 +63564,7 @@ function createTypeChecker(host) { return signature.isolatedSignatureType; } function getIndexSymbol(symbol) { - return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : void 0; + return symbol.members ? getIndexSymbolFromSymbolTable(getMembersOfSymbol(symbol)) : void 0; } function getIndexSymbolFromSymbolTable(symbolTable) { return symbolTable.get("__index" /* Index */); @@ -63296,23 +63574,61 @@ function createTypeChecker(host) { } function getIndexInfosOfSymbol(symbol) { const indexSymbol = getIndexSymbol(symbol); - return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol) : emptyArray; + return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol, arrayFrom(getMembersOfSymbol(symbol).values())) : emptyArray; } - function getIndexInfosOfIndexSymbol(indexSymbol) { + function getIndexInfosOfIndexSymbol(indexSymbol, siblingSymbols = indexSymbol.parent ? arrayFrom(getMembersOfSymbol(indexSymbol.parent).values()) : void 0) { if (indexSymbol.declarations) { const indexInfos = []; + let hasComputedNumberProperty = false; + let readonlyComputedNumberProperty = true; + let hasComputedSymbolProperty = false; + let readonlyComputedSymbolProperty = true; + let hasComputedStringProperty = false; + let readonlyComputedStringProperty = true; + const computedPropertySymbols = []; for (const declaration of indexSymbol.declarations) { - if (declaration.parameters.length === 1) { - const parameter = declaration.parameters[0]; - if (parameter.type) { - forEachType(getTypeFromTypeNode(parameter.type), (keyType) => { - if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) { - indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration)); + if (isIndexSignatureDeclaration(declaration)) { + if (declaration.parameters.length === 1) { + const parameter = declaration.parameters[0]; + if (parameter.type) { + forEachType(getTypeFromTypeNode(parameter.type), (keyType) => { + if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) { + indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration)); + } + }); + } + } + } else if (hasLateBindableIndexSignature(declaration)) { + const declName = isBinaryExpression(declaration) ? declaration.left : declaration.name; + const keyType = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName); + if (findIndexInfo(indexInfos, keyType)) { + continue; + } + if (isTypeAssignableTo(keyType, stringNumberSymbolType)) { + if (isTypeAssignableTo(keyType, numberType)) { + hasComputedNumberProperty = true; + if (!hasEffectiveReadonlyModifier(declaration)) { + readonlyComputedNumberProperty = false; } - }); + } else if (isTypeAssignableTo(keyType, esSymbolType)) { + hasComputedSymbolProperty = true; + if (!hasEffectiveReadonlyModifier(declaration)) { + readonlyComputedSymbolProperty = false; + } + } else { + hasComputedStringProperty = true; + if (!hasEffectiveReadonlyModifier(declaration)) { + readonlyComputedStringProperty = false; + } + } + computedPropertySymbols.push(declaration.symbol); } } } + const allPropertySymbols = concatenate(computedPropertySymbols, filter(siblingSymbols, (s) => s !== indexSymbol)); + if (hasComputedStringProperty && !findIndexInfo(indexInfos, stringType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedStringProperty, 0, allPropertySymbols, stringType)); + if (hasComputedNumberProperty && !findIndexInfo(indexInfos, numberType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedNumberProperty, 0, allPropertySymbols, numberType)); + if (hasComputedSymbolProperty && !findIndexInfo(indexInfos, esSymbolType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedSymbolProperty, 0, allPropertySymbols, esSymbolType)); return indexInfos; } return emptyArray; @@ -66158,7 +66474,7 @@ function createTypeChecker(host) { const links = getNodeLinks(node); if (!links.resolvedType) { const aliasSymbol = getAliasSymbolForTypeNode(node); - if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) { + if (!node.symbol || getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) { links.resolvedType = emptyTypeLiteralType; } else { let type = createObjectType(16 /* Anonymous */, node.symbol); @@ -66550,6 +66866,9 @@ function createTypeChecker(host) { return getTypeFromTemplateTypeNode(node); case 205 /* ImportType */: return getTypeFromImportTypeNode(node); + // This function assumes that an identifier, qualified name, or property access expression is a type expression + // Callers should first ensure this by calling `isPartOfTypeNode` + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. case 80 /* Identifier */: case 166 /* QualifiedName */: case 211 /* PropertyAccessExpression */: @@ -66797,6 +67116,7 @@ function createTypeChecker(host) { return !!tp.isThisType; case 80 /* Identifier */: return !tp.isThisType && isPartOfTypeNode(node2) && maybeTypeParameterReference(node2) && getTypeFromTypeNodeWorker(node2) === tp; + // use worker because we're looking for === equality case 186 /* TypeQuery */: const entityName = node2.exprName; const firstIdentifier = getFirstIdentifier(entityName); @@ -67216,6 +67536,7 @@ function createTypeChecker(host) { if (!isConstAssertion(node)) { break; } + // fallthrough case 294 /* JsxExpression */: case 217 /* ParenthesizedExpression */: return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer); @@ -68311,7 +68632,7 @@ function createTypeChecker(host) { const [sourceType, targetType] = getTypeNamesForErrorDisplay(source2, target2); let generalizedSource = source2; let generalizedSourceType = sourceType; - if (isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) { + if (!(target2.flags & 131072 /* Never */) && isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) { generalizedSource = getBaseTypeOfLiteralType(source2); Debug.assert(!isTypeAssignableTo(generalizedSource, target2), "generalized source shouldn't be assignable"); generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource); @@ -71343,7 +71664,7 @@ function createTypeChecker(host) { case 219 /* ArrowFunction */: if (noImplicitAny && !declaration.name) { if (wideningKind === 3 /* GeneratorYield */) { - error2(declaration, Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString); + error2(declaration, Diagnostics.Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation, typeAsString); } else { error2(declaration, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); } @@ -71361,11 +71682,37 @@ function createTypeChecker(host) { } errorOrSuggestion(noImplicitAny, declaration, diagnostic, declarationNameToString(getNameOfDeclaration(declaration)), typeAsString); } + function shouldReportErrorsFromWideningWithContextualSignature(declaration, wideningKind) { + const signature = getContextualSignatureForFunctionLikeDeclaration(declaration); + if (!signature) { + return true; + } + let returnType = getReturnTypeOfSignature(signature); + const flags = getFunctionFlags(declaration); + switch (wideningKind) { + case 1 /* FunctionReturn */: + if (flags & 1 /* Generator */) { + returnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, !!(flags & 2 /* Async */)) ?? returnType; + } else if (flags & 2 /* Async */) { + returnType = getAwaitedTypeNoAlias(returnType) ?? returnType; + } + return isGenericType(returnType); + case 3 /* GeneratorYield */: + const yieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, !!(flags & 2 /* Async */)); + return !!yieldType && isGenericType(yieldType); + case 2 /* GeneratorNext */: + const nextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, !!(flags & 2 /* Async */)); + return !!nextType && isGenericType(nextType); + } + return false; + } function reportErrorsFromWidening(declaration, type, wideningKind) { addLazyDiagnostic(() => { - if (noImplicitAny && getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) { - if (!reportWideningErrorsInType(type)) { - reportImplicitAny(declaration, type, wideningKind); + if (noImplicitAny && getObjectFlags(type) & 65536 /* ContainsWideningType */) { + if (!wideningKind || isFunctionLikeDeclaration(declaration) && shouldReportErrorsFromWideningWithContextualSignature(declaration, wideningKind)) { + if (!reportWideningErrorsInType(type)) { + reportImplicitAny(declaration, type, wideningKind); + } } } }); @@ -72535,6 +72882,7 @@ function createTypeChecker(host) { if (isCallExpression(node.parent)) { return Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function; } + // falls through default: if (node.parent.kind === 304 /* ShorthandPropertyAssignment */) { return Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer; @@ -72568,6 +72916,7 @@ function createTypeChecker(host) { const symbol = getResolvedSymbol(node); return symbol !== unknownSymbol ? `${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}|${getSymbolId(symbol)}` : void 0; } + // falls through case 110 /* ThisKeyword */: return `0|${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}`; case 235 /* NonNullExpression */: @@ -74121,6 +74470,9 @@ function createTypeChecker(host) { break; case 28 /* CommaToken */: return narrowType(type, expr.right, assumeTrue); + // Ordinarily we won't see && and || expressions in control flow analysis because the Binder breaks those + // expressions down to individual conditional control flows. However, we may encounter them when analyzing + // aliased conditional expressions. case 56 /* AmpersandAmpersandToken */: return assumeTrue ? narrowType( narrowType( @@ -74564,6 +74916,7 @@ function createTypeChecker(host) { } } } + // falls through case 110 /* ThisKeyword */: case 108 /* SuperKeyword */: case 211 /* PropertyAccessExpression */: @@ -74624,6 +74977,12 @@ function createTypeChecker(host) { function getControlFlowContainer(node) { return findAncestor(node.parent, (node2) => isFunctionLike(node2) && !getImmediatelyInvokedFunctionExpression(node2) || node2.kind === 268 /* ModuleBlock */ || node2.kind === 307 /* SourceFile */ || node2.kind === 172 /* PropertyDeclaration */); } + function isSymbolAssignedDefinitely(symbol) { + if (symbol.lastAssignmentPos !== void 0) { + return symbol.lastAssignmentPos < 0; + } + return isSymbolAssigned(symbol) && symbol.lastAssignmentPos !== void 0 && symbol.lastAssignmentPos < 0; + } function isSymbolAssigned(symbol) { return !isPastLastAssignment( symbol, @@ -74643,7 +75002,7 @@ function createTypeChecker(host) { markNodeAssignments(parent2); } } - return !symbol.lastAssignmentPos || location && symbol.lastAssignmentPos < location.pos; + return !symbol.lastAssignmentPos || location && Math.abs(symbol.lastAssignmentPos) < location.pos; } function isSomeSymbolAssigned(rootDeclaration) { Debug.assert(isVariableDeclaration(rootDeclaration) || isParameter(rootDeclaration)); @@ -74664,12 +75023,19 @@ function createTypeChecker(host) { function markNodeAssignments(node) { switch (node.kind) { case 80 /* Identifier */: - if (isAssignmentTarget(node)) { + const assigmentTarget = getAssignmentTargetKind(node); + if (assigmentTarget !== 0 /* None */) { const symbol = getResolvedSymbol(node); - if (isParameterOrMutableLocalVariable(symbol) && symbol.lastAssignmentPos !== Number.MAX_VALUE) { - const referencingFunction = findAncestor(node, isFunctionOrSourceFile); - const declaringFunction = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile); - symbol.lastAssignmentPos = referencingFunction === declaringFunction ? extendAssignmentPosition(node, symbol.valueDeclaration) : Number.MAX_VALUE; + const hasDefiniteAssignment = assigmentTarget === 1 /* Definite */ || symbol.lastAssignmentPos !== void 0 && symbol.lastAssignmentPos < 0; + if (isParameterOrMutableLocalVariable(symbol)) { + if (symbol.lastAssignmentPos === void 0 || Math.abs(symbol.lastAssignmentPos) !== Number.MAX_VALUE) { + const referencingFunction = findAncestor(node, isFunctionOrSourceFile); + const declaringFunction = findAncestor(symbol.valueDeclaration, isFunctionOrSourceFile); + symbol.lastAssignmentPos = referencingFunction === declaringFunction ? extendAssignmentPosition(node, symbol.valueDeclaration) : Number.MAX_VALUE; + } + if (hasDefiniteAssignment && symbol.lastAssignmentPos > 0) { + symbol.lastAssignmentPos *= -1; + } } } return; @@ -74686,7 +75052,8 @@ function createTypeChecker(host) { true ); if (symbol && isParameterOrMutableLocalVariable(symbol)) { - symbol.lastAssignmentPos = Number.MAX_VALUE; + const sign = symbol.lastAssignmentPos !== void 0 && symbol.lastAssignmentPos < 0 ? -1 : 1; + symbol.lastAssignmentPos = sign * Number.MAX_VALUE; } } return; @@ -74919,15 +75286,16 @@ function createTypeChecker(host) { } function markJsxAliasReferenced(node) { if (!getJsxNamespaceContainerForImplicitImport(node)) { - const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0; + const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found : void 0; const jsxFactoryNamespace = getJsxNamespace(node); const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? node.tagName : node; + const shouldFactoryRefErr = compilerOptions.jsx !== 1 /* Preserve */ && compilerOptions.jsx !== 3 /* ReactNative */; let jsxFactorySym; if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) { jsxFactorySym = resolveName( jsxFactoryLocation, jsxFactoryNamespace, - 111551 /* Value */, + shouldFactoryRefErr ? 111551 /* Value */ : 111551 /* Value */ & ~384 /* Enum */, jsxFactoryRefErr, /*isUse*/ true @@ -74946,7 +75314,7 @@ function createTypeChecker(host) { resolveName( jsxFactoryLocation, localJsxNamespace, - 111551 /* Value */, + shouldFactoryRefErr ? 111551 /* Value */ : 111551 /* Value */ & ~384 /* Enum */, jsxFactoryRefErr, /*isUse*/ true @@ -75270,6 +75638,7 @@ function createTypeChecker(host) { } const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); let declaration = localOrExportSymbol.valueDeclaration; + const immediateDeclaration = declaration; if (declaration && declaration.kind === 208 /* BindingElement */ && contains(contextualBindingPatterns, declaration.parent) && findAncestor(node, (parent2) => parent2 === declaration.parent)) { return nonInferrableAnyType; } @@ -75315,7 +75684,8 @@ function createTypeChecker(host) { while (flowContainer !== declarationContainer && (flowContainer.kind === 218 /* FunctionExpression */ || flowContainer.kind === 219 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstantVariable(localOrExportSymbol) && type !== autoArrayType || isParameterOrMutableLocalVariable(localOrExportSymbol) && isPastLastAssignment(localOrExportSymbol, node))) { flowContainer = getControlFlowContainer(flowContainer); } - const assumeInitialized = isParameter2 || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */; + const isNeverInitialized = immediateDeclaration && isVariableDeclaration(immediateDeclaration) && !immediateDeclaration.initializer && !immediateDeclaration.exclamationToken && isMutableLocalVariableDeclaration(immediateDeclaration) && !isSymbolAssignedDefinitely(symbol); + const assumeInitialized = isParameter2 || isAlias || isOuterVariable && !isNeverInitialized || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */; const initialType = isAutomaticTypeInNonNull ? undefinedType : assumeInitialized ? isParameter2 ? removeOptionalityFromDeclaredType(type, declaration) : type : typeIsAutomatic ? undefinedType : getOptionalType(type); const flowType = isAutomaticTypeInNonNull ? getNonNullableType(getFlowTypeOfReference(node, type, initialType, flowContainer)) : getFlowTypeOfReference(node, type, initialType, flowContainer); if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) { @@ -76223,46 +76593,108 @@ function createTypeChecker(host) { function isCircularMappedProperty(symbol) { return !!(getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.links.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0); } + function isExcludedMappedPropertyName(constraint, propertyNameType) { + if (constraint.flags & 16777216 /* Conditional */) { + const type = constraint; + return !!(getReducedType(getTrueTypeFromConditionalType(type)).flags & 131072 /* Never */) && getActualTypeVariable(getFalseTypeFromConditionalType(type)) === getActualTypeVariable(type.checkType) && isTypeAssignableTo(propertyNameType, type.extendsType); + } + if (constraint.flags & 2097152 /* Intersection */) { + return some(constraint.types, (t) => isExcludedMappedPropertyName(t, propertyNameType)); + } + return false; + } function getTypeOfPropertyOfContextualType(type, name, nameType) { return mapType( type, (t) => { - var _a; - if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) { - const constraint = getConstraintTypeFromMappedType(t); - const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint; - const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name)); - if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) { - return substituteIndexedMappedType(t, propertyNameType); + if (t.flags & 2097152 /* Intersection */) { + let types; + let indexInfoCandidates; + let ignoreIndexInfos = false; + for (const constituentType of t.types) { + if (!(constituentType.flags & 524288 /* Object */)) { + continue; + } + if (isGenericMappedType(constituentType) && getMappedTypeNameTypeKind(constituentType) !== 2 /* Remapping */) { + const substitutedType = getIndexedMappedTypeSubstitutedTypeOfContextualType(constituentType, name, nameType); + types = appendContextualPropertyTypeConstituent(types, substitutedType); + continue; + } + const propertyType = getTypeOfConcretePropertyOfContextualType(constituentType, name); + if (!propertyType) { + if (!ignoreIndexInfos) { + indexInfoCandidates = append(indexInfoCandidates, constituentType); + } + continue; + } + ignoreIndexInfos = true; + indexInfoCandidates = void 0; + types = appendContextualPropertyTypeConstituent(types, propertyType); } - } else if (t.flags & 3670016 /* StructuredType */) { - const prop = getPropertyOfType(t, name); - if (prop) { - return isCircularMappedProperty(prop) ? void 0 : removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */)); - } - if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) { - const restType = getElementTypeOfSliceOfTupleType( - t, - t.target.fixedLength, - /*endSkipCount*/ - 0, - /*writing*/ - false, - /*noReductions*/ - true - ); - if (restType) { - return restType; + if (indexInfoCandidates) { + for (const candidate of indexInfoCandidates) { + const indexInfoType = getTypeFromIndexInfosOfContextualType(candidate, name, nameType); + types = appendContextualPropertyTypeConstituent(types, indexInfoType); } } - return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type; + if (!types) { + return; + } + if (types.length === 1) { + return types[0]; + } + return getIntersectionType(types); } - return void 0; + if (!(t.flags & 524288 /* Object */)) { + return; + } + return isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */ ? getIndexedMappedTypeSubstitutedTypeOfContextualType(t, name, nameType) : getTypeOfConcretePropertyOfContextualType(t, name) ?? getTypeFromIndexInfosOfContextualType(t, name, nameType); }, /*noReductions*/ true ); } + function appendContextualPropertyTypeConstituent(types, type) { + return type ? append(types, type.flags & 1 /* Any */ ? unknownType : type) : types; + } + function getIndexedMappedTypeSubstitutedTypeOfContextualType(type, name, nameType) { + const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name)); + const constraint = getConstraintTypeFromMappedType(type); + if (type.nameType && isExcludedMappedPropertyName(type.nameType, propertyNameType) || isExcludedMappedPropertyName(constraint, propertyNameType)) { + return; + } + const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint; + if (!isTypeAssignableTo(propertyNameType, constraintOfConstraint)) { + return; + } + return substituteIndexedMappedType(type, propertyNameType); + } + function getTypeOfConcretePropertyOfContextualType(type, name) { + const prop = getPropertyOfType(type, name); + if (!prop || isCircularMappedProperty(prop)) { + return; + } + return removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */)); + } + function getTypeFromIndexInfosOfContextualType(type, name, nameType) { + var _a; + if (isTupleType(type) && isNumericLiteralName(name) && +name >= 0) { + const restType = getElementTypeOfSliceOfTupleType( + type, + type.target.fixedLength, + /*endSkipCount*/ + 0, + /*writing*/ + false, + /*noReductions*/ + true + ); + if (restType) { + return restType; + } + } + return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(type), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type; + } function getContextualTypeForObjectLiteralMethod(node, contextFlags) { Debug.assert(isObjectLiteralMethod(node)); if (node.flags & 67108864 /* InWithStatement */) { @@ -76675,7 +77107,7 @@ function createTypeChecker(host) { return getContextualTypeForArgumentAtIndex(node, 0); } function getEffectiveFirstArgumentForJsxSignature(signature, node) { - return getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node); + return isJsxOpeningFragment(node) || getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node); } function getJsxPropsTypeFromCallSignature(sig, context) { let propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType); @@ -76706,6 +77138,7 @@ function createTypeChecker(host) { return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation); } function getStaticTypeOfReferencedJsxConstructor(context) { + if (isJsxOpeningFragment(context)) return getJSXFragmentType(context); if (isJsxIntrinsicTagName(context.tagName)) { const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context); const fakeSignature = createSignatureForJSXIntrinsic(context, result); @@ -76805,13 +77238,14 @@ function createTypeChecker(host) { const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0; const paramSymbol = createSymbol( 1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0), - paramName || `arg${i}` + paramName || `arg${i}`, + isRestParam ? 32768 /* RestParameter */ : isOptional ? 16384 /* OptionalParameter */ : 0 ); paramSymbol.links.type = isRestParam ? createArrayType(unionParamType) : unionParamType; params[i] = paramSymbol; } if (needsExtraRestElement) { - const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args"); + const restParamSymbol = createSymbol(1 /* FunctionScopedVariable */, "args", 32768 /* RestParameter */); restParamSymbol.links.type = createArrayType(getTypeAtPosition(shorter, longestCount)); if (shorter === right) { restParamSymbol.links.type = instantiateType(restParamSymbol.links.type, mapper); @@ -76826,8 +77260,13 @@ function createTypeChecker(host) { if (left.typeParameters && right.typeParameters) { paramMapper = createTypeMapper(right.typeParameters, left.typeParameters); } + let flags = (left.flags | right.flags) & (167 /* PropagatingFlags */ & ~1 /* HasRestParameter */); const declaration = left.declaration; const params = combineIntersectionParameters(left, right, paramMapper); + const lastParam = lastOrUndefined(params); + if (lastParam && getCheckFlags(lastParam) & 32768 /* RestParameter */) { + flags |= 1 /* HasRestParameter */; + } const thisParam = combineIntersectionThisParam(left.thisParameter, right.thisParameter, paramMapper); const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); const result = createSignature( @@ -76840,7 +77279,7 @@ function createTypeChecker(host) { /*resolvedTypePredicate*/ void 0, minArgCount, - (left.flags | right.flags) & 167 /* PropagatingFlags */ + flags ); result.compositeKind = 2097152 /* Intersection */; result.compositeSignatures = concatenate(left.compositeKind === 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]); @@ -76959,7 +77398,7 @@ function createTypeChecker(host) { return globalRegExpType; } function checkSpreadExpression(node, checkMode) { - if (languageVersion < 2 /* SpreadElements */) { + if (languageVersion < LanguageFeatureMinimumTarget.SpreadElements) { checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */); } const arrayOrIterableType = checkExpression(node.expression, checkMode); @@ -76993,7 +77432,7 @@ function createTypeChecker(host) { for (let i = 0; i < elementCount; i++) { const e = elements[i]; if (e.kind === 230 /* SpreadElement */) { - if (languageVersion < 2 /* SpreadElements */) { + if (languageVersion < LanguageFeatureMinimumTarget.SpreadElements) { checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */); } const spreadType = checkExpression(e.expression, checkMode, forceTuple); @@ -77112,7 +77551,7 @@ function createTypeChecker(host) { const firstDecl = (_a = symbol.declarations) == null ? void 0 : _a[0]; return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* ESSymbol */); } - function getObjectLiteralIndexInfo(node, offset, properties, keyType) { + function getObjectLiteralIndexInfo(isReadonly, offset, properties, keyType) { const propTypes = []; for (let i = offset; i < properties.length; i++) { const prop = properties[i]; @@ -77121,7 +77560,7 @@ function createTypeChecker(host) { } } const unionType = propTypes.length ? getUnionType(propTypes, 2 /* Subtype */) : undefinedType; - return createIndexInfo(keyType, unionType, isConstContext(node)); + return createIndexInfo(keyType, unionType, isReadonly); } function getImmediateAliasedSymbol(symbol) { Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here."); @@ -77218,7 +77657,7 @@ function createTypeChecker(host) { addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type); } } else if (memberDecl.kind === 305 /* SpreadAssignment */) { - if (languageVersion < 2 /* ObjectAssign */) { + if (languageVersion < LanguageFeatureMinimumTarget.ObjectAssign) { checkExternalEmitHelpers(memberDecl, 2 /* Assign */); } if (propertiesArray.length > 0) { @@ -77284,9 +77723,10 @@ function createTypeChecker(host) { return createObjectLiteralType(); function createObjectLiteralType() { const indexInfos = []; - if (hasComputedStringProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, stringType)); - if (hasComputedNumberProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, numberType)); - if (hasComputedSymbolProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, esSymbolType)); + const isReadonly = isConstContext(node); + if (hasComputedStringProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, stringType)); + if (hasComputedNumberProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, numberType)); + if (hasComputedSymbolProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, esSymbolType)); const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, indexInfos); result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */; if (isJSObjectLiteral) { @@ -77335,7 +77775,8 @@ function createTypeChecker(host) { ); } checkJsxChildren(node); - return getJsxElementTypeAt(node) || anyType; + const jsxElementType = getJsxElementTypeAt(node); + return isErrorType(jsxElementType) ? anyType : jsxElementType; } function isHyphenatedJsxName(name) { return name.includes("-"); @@ -77347,8 +77788,6 @@ function createTypeChecker(host) { return node.initializer ? checkExpressionForMutableLocation(node.initializer, checkMode) : trueType; } function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode = 0 /* Normal */) { - const attributes = openingLikeElement.attributes; - const contextualType = getContextualType2(attributes, 0 /* None */); const allAttributesTable = strictNullChecks ? createSymbolTable() : void 0; let attributesTable = createSymbolTable(); let spread = emptyJsxObjectType; @@ -77357,96 +77796,105 @@ function createTypeChecker(host) { let explicitlySpecifyChildrenAttribute = false; let objectFlags = 2048 /* JsxAttributes */; const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement)); - for (const attributeDecl of attributes.properties) { - const member = attributeDecl.symbol; - if (isJsxAttribute(attributeDecl)) { - const exprType = checkJsxAttribute(attributeDecl, checkMode); - objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */; - const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName); - attributeSymbol.declarations = member.declarations; - attributeSymbol.parent = member.parent; - if (member.valueDeclaration) { - attributeSymbol.valueDeclaration = member.valueDeclaration; - } - attributeSymbol.links.type = exprType; - attributeSymbol.links.target = member; - attributesTable.set(attributeSymbol.escapedName, attributeSymbol); - allAttributesTable == null ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol); - if (getEscapedTextOfJsxAttributeName(attributeDecl.name) === jsxChildrenPropertyName) { - explicitlySpecifyChildrenAttribute = true; - } - if (contextualType) { - const prop = getPropertyOfType(contextualType, member.escapedName); - if (prop && prop.declarations && isDeprecatedSymbol(prop) && isIdentifier(attributeDecl.name)) { - addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText); + const isJsxOpenFragment = isJsxOpeningFragment(openingLikeElement); + let attributesSymbol; + let attributeParent = openingLikeElement; + if (!isJsxOpenFragment) { + const attributes = openingLikeElement.attributes; + attributesSymbol = attributes.symbol; + attributeParent = attributes; + const contextualType = getContextualType2(attributes, 0 /* None */); + for (const attributeDecl of attributes.properties) { + const member = attributeDecl.symbol; + if (isJsxAttribute(attributeDecl)) { + const exprType = checkJsxAttribute(attributeDecl, checkMode); + objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */; + const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName); + attributeSymbol.declarations = member.declarations; + attributeSymbol.parent = member.parent; + if (member.valueDeclaration) { + attributeSymbol.valueDeclaration = member.valueDeclaration; + } + attributeSymbol.links.type = exprType; + attributeSymbol.links.target = member; + attributesTable.set(attributeSymbol.escapedName, attributeSymbol); + allAttributesTable == null ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol); + if (getEscapedTextOfJsxAttributeName(attributeDecl.name) === jsxChildrenPropertyName) { + explicitlySpecifyChildrenAttribute = true; + } + if (contextualType) { + const prop = getPropertyOfType(contextualType, member.escapedName); + if (prop && prop.declarations && isDeprecatedSymbol(prop) && isIdentifier(attributeDecl.name)) { + addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText); + } + } + if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) { + const inferenceContext = getInferenceContext(attributes); + Debug.assert(inferenceContext); + const inferenceNode = attributeDecl.initializer.expression; + addIntraExpressionInferenceSite(inferenceContext, inferenceNode, exprType); + } + } else { + Debug.assert(attributeDecl.kind === 293 /* JsxSpreadAttribute */); + if (attributesTable.size > 0) { + spread = getSpreadType( + spread, + createJsxAttributesTypeHelper(), + attributes.symbol, + objectFlags, + /*readonly*/ + false + ); + attributesTable = createSymbolTable(); + } + const exprType = getReducedType(checkExpression(attributeDecl.expression, checkMode & 2 /* Inferential */)); + if (isTypeAny(exprType)) { + hasSpreadAnyType = true; + } + if (isValidSpreadType(exprType)) { + spread = getSpreadType( + spread, + exprType, + attributes.symbol, + objectFlags, + /*readonly*/ + false + ); + if (allAttributesTable) { + checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl); + } + } else { + error2(attributeDecl.expression, Diagnostics.Spread_types_may_only_be_created_from_object_types); + typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType; } } - if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) { - const inferenceContext = getInferenceContext(attributes); - Debug.assert(inferenceContext); - const inferenceNode = attributeDecl.initializer.expression; - addIntraExpressionInferenceSite(inferenceContext, inferenceNode, exprType); - } - } else { - Debug.assert(attributeDecl.kind === 293 /* JsxSpreadAttribute */); + } + if (!hasSpreadAnyType) { if (attributesTable.size > 0) { spread = getSpreadType( spread, - createJsxAttributesType(), + createJsxAttributesTypeHelper(), attributes.symbol, objectFlags, /*readonly*/ false ); - attributesTable = createSymbolTable(); - } - const exprType = getReducedType(checkExpression(attributeDecl.expression, checkMode & 2 /* Inferential */)); - if (isTypeAny(exprType)) { - hasSpreadAnyType = true; - } - if (isValidSpreadType(exprType)) { - spread = getSpreadType( - spread, - exprType, - attributes.symbol, - objectFlags, - /*readonly*/ - false - ); - if (allAttributesTable) { - checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl); - } - } else { - error2(attributeDecl.expression, Diagnostics.Spread_types_may_only_be_created_from_object_types); - typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType; } } } - if (!hasSpreadAnyType) { - if (attributesTable.size > 0) { - spread = getSpreadType( - spread, - createJsxAttributesType(), - attributes.symbol, - objectFlags, - /*readonly*/ - false - ); - } - } - const parent2 = openingLikeElement.parent.kind === 284 /* JsxElement */ ? openingLikeElement.parent : void 0; - if (parent2 && parent2.openingElement === openingLikeElement && getSemanticJsxChildren(parent2.children).length > 0) { + const parent2 = openingLikeElement.parent; + if ((isJsxElement(parent2) && parent2.openingElement === openingLikeElement || isJsxFragment(parent2) && parent2.openingFragment === openingLikeElement) && getSemanticJsxChildren(parent2.children).length > 0) { const childrenTypes = checkJsxChildren(parent2, checkMode); if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") { if (explicitlySpecifyChildrenAttribute) { - error2(attributes, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName)); + error2(attributeParent, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName)); } - const contextualType2 = getApparentTypeOfContextualType( + const contextualType = isJsxOpeningElement(openingLikeElement) ? getApparentTypeOfContextualType( openingLikeElement.attributes, /*contextFlags*/ void 0 - ); - const childrenContextualType = contextualType2 && getTypeOfPropertyOfContextualType(contextualType2, jsxChildrenPropertyName); + ) : void 0; + const childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName); const childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName); childrenPropSymbol.links.type = childrenTypes.length === 1 ? childrenTypes[0] : childrenContextualType && someType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) : createArrayType(getUnionType(childrenTypes)); childrenPropSymbol.valueDeclaration = factory.createPropertySignature( @@ -77458,14 +77906,14 @@ function createTypeChecker(host) { /*type*/ void 0 ); - setParent(childrenPropSymbol.valueDeclaration, attributes); + setParent(childrenPropSymbol.valueDeclaration, attributeParent); childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol; const childPropMap = createSymbolTable(); childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol); spread = getSpreadType( spread, - createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, emptyArray), - attributes.symbol, + createAnonymousType(attributesSymbol, childPropMap, emptyArray, emptyArray, emptyArray), + attributesSymbol, objectFlags, /*readonly*/ false @@ -77478,14 +77926,17 @@ function createTypeChecker(host) { if (typeToIntersect && spread !== emptyJsxObjectType) { return getIntersectionType([typeToIntersect, spread]); } - return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread); - function createJsxAttributesType() { + return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesTypeHelper() : spread); + function createJsxAttributesTypeHelper() { objectFlags |= 8192 /* FreshLiteral */; - const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, emptyArray); - result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */; - return result; + return createJsxAttributesType(objectFlags, attributesSymbol, attributesTable); } } + function createJsxAttributesType(objectFlags, attributesSymbol, attributesTable) { + const result = createAnonymousType(attributesSymbol, attributesTable, emptyArray, emptyArray, emptyArray); + result.objectFlags |= objectFlags | 8192 /* FreshLiteral */ | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */; + return result; + } function checkJsxChildren(node, checkMode) { const childrenTypes = []; for (const child of node.children) { @@ -77567,7 +78018,7 @@ function createTypeChecker(host) { return void 0; } const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */; - const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations; + const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed; const specifier = getJSXRuntimeImportSpecifier(file, runtimeImportSpecifier); const mod = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage, location); const result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : void 0; @@ -77791,10 +78242,10 @@ function createTypeChecker(host) { } checkJsxPreconditions(node); markJsxAliasReferenced(node); + const sig = getResolvedSignature(node); + checkDeprecatedSignature(sig, node); if (isNodeOpeningLikeElement) { const jsxOpeningLikeNode = node; - const sig = getResolvedSignature(jsxOpeningLikeNode); - checkDeprecatedSignature(sig, node); const elementTypeConstraint = getJsxElementTypeTypeAt(jsxOpeningLikeNode); if (elementTypeConstraint !== void 0) { const tagName = jsxOpeningLikeNode.tagName; @@ -78195,7 +78646,7 @@ function createTypeChecker(host) { const isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType; let prop; if (isPrivateIdentifier(right)) { - if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) { + if (languageVersion < LanguageFeatureMinimumTarget.PrivateNamesAndClassStaticBlocks || languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators || !useDefineForClassFields) { if (assignmentKind !== 0 /* None */) { checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldSet */); } @@ -78430,6 +78881,13 @@ function createTypeChecker(host) { return getIntersectionType(x); } function reportNonexistentProperty(propNode, containingType, isUncheckedJS) { + const links = getNodeLinks(propNode); + const cache = links.nonExistentPropCheckCache || (links.nonExistentPropCheckCache = /* @__PURE__ */ new Set()); + const key = `${getTypeId(containingType)}|${isUncheckedJS}`; + if (cache.has(key)) { + return; + } + cache.add(key); let errorInfo; let relatedInfo; if (!isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* Union */ && !(containingType.flags & 402784252 /* Primitive */)) { @@ -78821,6 +79279,7 @@ function createTypeChecker(host) { return !!(t.flags & (16384 /* Void */ | 32768 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */)); } function hasCorrectArity(node, args, signature, signatureHelpTrailingComma = false) { + if (isJsxOpeningFragment(node)) return true; let argCount; let callIsIncomplete = false; let effectiveParameterCount = getParameterCount(signature); @@ -79094,9 +79553,9 @@ function createTypeChecker(host) { } return 2 /* Mixed */; } - function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) { + function checkApplicableSignatureForJsxCallLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) { const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node); - const attributesType = checkExpressionWithContextualType( + const attributesType = isJsxOpeningFragment(node) ? createJsxAttributesTypeFromAttributesProperty(node) : checkExpressionWithContextualType( node.attributes, paramType, /*inferenceContext*/ @@ -79108,8 +79567,8 @@ function createTypeChecker(host) { checkAttributesType, paramType, relation, - reportErrors2 ? node.tagName : void 0, - node.attributes, + reportErrors2 ? isJsxOpeningFragment(node) ? node : node.tagName : void 0, + isJsxOpeningFragment(node) ? void 0 : node.attributes, /*headMessage*/ void 0, containingMessageChain, @@ -79180,10 +79639,11 @@ function createTypeChecker(host) { return true; } if (reportErrors2) { - const diag2 = createDiagnosticForNode(node.tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(node.tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount); - const tagNameDeclaration = (_a = getSymbolAtLocation(node.tagName)) == null ? void 0 : _a.valueDeclaration; + const tagName = node.tagName; + const diag2 = createDiagnosticForNode(tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount); + const tagNameDeclaration = (_a = getSymbolAtLocation(tagName)) == null ? void 0 : _a.valueDeclaration; if (tagNameDeclaration) { - addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(node.tagName))); + addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(tagName))); } if (errorOutputContainer && errorOutputContainer.skipLogging) { (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2); @@ -79201,8 +79661,8 @@ function createTypeChecker(host) { } function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) { const errorOutputContainer = { errors: void 0, skipLogging: true }; - if (isJsxOpeningLikeElement(node)) { - if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) { + if (isJsxCallLike(node)) { + if (!checkApplicableSignatureForJsxCallLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) { Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "jsx should have errors when reporting errors"); return errorOutputContainer.errors || emptyArray; } @@ -79302,6 +79762,9 @@ function createTypeChecker(host) { return result; } function getEffectiveCallArguments(node) { + if (isJsxOpeningFragment(node)) { + return [createSyntheticExpression(node, emptyFreshJsxObjectType)]; + } if (node.kind === 215 /* TaggedTemplateExpression */) { const template = node.template; const args2 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())]; @@ -79586,25 +80049,32 @@ function createTypeChecker(host) { const isTaggedTemplate = node.kind === 215 /* TaggedTemplateExpression */; const isDecorator2 = node.kind === 170 /* Decorator */; const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node); + const isJsxOpenFragment = isJsxOpeningFragment(node); const isInstanceof = node.kind === 226 /* BinaryExpression */; const reportErrors2 = !isInferencePartiallyBlocked && !candidatesOutArray; + let candidatesForArgumentError; + let candidateForArgumentArityError; + let candidateForTypeArgumentError; + let result; + let argCheckMode = 0 /* Normal */; + let candidates = []; let typeArguments; - if (!isDecorator2 && !isInstanceof && !isSuperCall(node)) { + if (!isDecorator2 && !isInstanceof && !isSuperCall(node) && !isJsxOpenFragment) { typeArguments = node.typeArguments; if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 108 /* SuperKeyword */) { forEach(typeArguments, checkSourceElement); } } - const candidates = candidatesOutArray || []; + candidates = candidatesOutArray || []; reorderCandidates(signatures, candidates, callChainFlags); - Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this"); + if (!isJsxOpenFragment) { + Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this"); + } const args = getEffectiveCallArguments(node); const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters; - let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */; - let candidatesForArgumentError; - let candidateForArgumentArityError; - let candidateForTypeArgumentError; - let result; + if (!isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive)) { + argCheckMode = 4 /* SkipContextSensitive */; + } const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 213 /* CallExpression */ && node.arguments.hasTrailingComma; if (candidates.length > 1) { result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma); @@ -79724,7 +80194,7 @@ function createTypeChecker(host) { true, headMessage ); - } else { + } else if (!isJsxOpenFragment) { const signaturesWithCorrectTypeArgumentArity = filter(signatures, (s) => hasCorrectTypeArgumentArity(s, typeArguments)); if (signaturesWithCorrectTypeArgumentArity.length === 0) { diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments, headMessage)); @@ -79734,12 +80204,12 @@ function createTypeChecker(host) { } } return result; - function addImplementationSuccessElaboration(failed, diagnostic) { + function addImplementationSuccessElaboration(failed2, diagnostic) { var _a, _b; const oldCandidatesForArgumentError = candidatesForArgumentError; const oldCandidateForArgumentArityError = candidateForArgumentArityError; const oldCandidateForTypeArgumentError = candidateForTypeArgumentError; - const failedSignatureDeclarations = ((_b = (_a = failed.declaration) == null ? void 0 : _a.symbol) == null ? void 0 : _b.declarations) || emptyArray; + const failedSignatureDeclarations = ((_b = (_a = failed2.declaration) == null ? void 0 : _a.symbol) == null ? void 0 : _b.declarations) || emptyArray; const isOverload2 = failedSignatureDeclarations.length > 1; const implDecl = isOverload2 ? find(failedSignatureDeclarations, (d) => isFunctionLikeDeclaration(d) && nodeIsPresent(d.body)) : void 0; if (implDecl) { @@ -80372,24 +80842,55 @@ function createTypeChecker(host) { 0 /* None */ ); } + function getJSXFragmentType(node) { + const sourceFileLinks = getNodeLinks(getSourceFileOfNode(node)); + if (sourceFileLinks.jsxFragmentType !== void 0) return sourceFileLinks.jsxFragmentType; + const jsxFragmentFactoryName = getJsxNamespace(node); + const shouldResolveFactoryReference = (compilerOptions.jsx === 2 /* React */ || compilerOptions.jsxFragmentFactory !== void 0) && jsxFragmentFactoryName !== "null"; + if (!shouldResolveFactoryReference) return sourceFileLinks.jsxFragmentType = anyType; + const shouldModuleRefErr = compilerOptions.jsx !== 1 /* Preserve */ && compilerOptions.jsx !== 3 /* ReactNative */; + const jsxFactoryRefErr = diagnostics ? Diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found : void 0; + const jsxFactorySymbol = getJsxNamespaceContainerForImplicitImport(node) ?? resolveName( + node, + jsxFragmentFactoryName, + shouldModuleRefErr ? 111551 /* Value */ : 111551 /* Value */ & ~384 /* Enum */, + /*nameNotFoundMessage*/ + jsxFactoryRefErr, + /*isUse*/ + true + ); + if (jsxFactorySymbol === void 0) return sourceFileLinks.jsxFragmentType = errorType; + if (jsxFactorySymbol.escapedName === ReactNames.Fragment) return sourceFileLinks.jsxFragmentType = getTypeOfSymbol(jsxFactorySymbol); + const resolvedAlias = (jsxFactorySymbol.flags & 2097152 /* Alias */) === 0 ? jsxFactorySymbol : resolveAlias(jsxFactorySymbol); + const reactExports = jsxFactorySymbol && getExportsOfSymbol(resolvedAlias); + const typeSymbol = reactExports && getSymbol2(reactExports, ReactNames.Fragment, 2 /* BlockScopedVariable */); + const type = typeSymbol && getTypeOfSymbol(typeSymbol); + return sourceFileLinks.jsxFragmentType = type === void 0 ? errorType : type; + } function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) { - if (isJsxIntrinsicTagName(node.tagName)) { - const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node); - const fakeSignature = createSignatureForJSXIntrinsic(node, result); - checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType( - node.attributes, - getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), - /*inferenceContext*/ - void 0, - 0 /* Normal */ - ), result, node.tagName, node.attributes); - if (length(node.typeArguments)) { - forEach(node.typeArguments, checkSourceElement); - diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments))); + const isJsxOpenFragment = isJsxOpeningFragment(node); + let exprTypes; + if (!isJsxOpenFragment) { + if (isJsxIntrinsicTagName(node.tagName)) { + const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node); + const fakeSignature = createSignatureForJSXIntrinsic(node, result); + checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType( + node.attributes, + getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), + /*inferenceContext*/ + void 0, + 0 /* Normal */ + ), result, node.tagName, node.attributes); + if (length(node.typeArguments)) { + forEach(node.typeArguments, checkSourceElement); + diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments))); + } + return fakeSignature; } - return fakeSignature; + exprTypes = checkExpression(node.tagName); + } else { + exprTypes = getJSXFragmentType(node); } - const exprTypes = checkExpression(node.tagName); const apparentType = getApparentType(exprTypes); if (isErrorType(apparentType)) { return resolveErrorCall(node); @@ -80405,7 +80906,11 @@ function createTypeChecker(host) { return resolveUntypedCall(node); } if (signatures.length === 0) { - error2(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName)); + if (isJsxOpenFragment) { + error2(node, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node)); + } else { + error2(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName)); + } return resolveErrorCall(node); } return resolveCall(node, signatures, candidatesOutArray, checkMode, 0 /* None */); @@ -80447,6 +80952,7 @@ function createTypeChecker(host) { return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode); case 170 /* Decorator */: return resolveDecorator(node, candidatesOutArray, checkMode); + case 289 /* JsxOpeningFragment */: case 286 /* JsxOpeningElement */: case 285 /* JsxSelfClosingElement */: return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode); @@ -80815,7 +81321,7 @@ function createTypeChecker(host) { } function checkTaggedTemplateExpression(node) { if (!checkGrammarTaggedTemplateChain(node)) checkGrammarTypeArguments(node, node.typeArguments); - if (languageVersion < 2 /* TaggedTemplates */) { + if (languageVersion < LanguageFeatureMinimumTarget.TaggedTemplates) { checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */); } const signature = getResolvedSignature(node); @@ -80934,9 +81440,17 @@ function createTypeChecker(host) { if (exprType === silentNeverType || isErrorType(exprType) || !some(typeArguments)) { return exprType; } + const links = getNodeLinks(node); + if (!links.instantiationExpressionTypes) { + links.instantiationExpressionTypes = /* @__PURE__ */ new Map(); + } + if (links.instantiationExpressionTypes.has(exprType.id)) { + return links.instantiationExpressionTypes.get(exprType.id); + } let hasSomeApplicableSignature = false; let nonApplicableType; const result = getInstantiatedType(exprType); + links.instantiationExpressionTypes.set(exprType.id, result); const errorType2 = hasSomeApplicableSignature ? nonApplicableType : exprType; if (errorType2) { diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType2))); @@ -81991,7 +82505,7 @@ function createTypeChecker(host) { }); } function checkIfExpressionRefinesParameter(func, expr, param, initType) { - const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode( + const antecedent = canHaveFlowNode(expr) && expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode( 2 /* Start */, /*node*/ void 0, @@ -82310,6 +82824,7 @@ function createTypeChecker(host) { hasError = true; break; } + // fallthrough case 7 /* ES2022 */: case 99 /* ESNext */: case 200 /* Preserve */: @@ -82317,6 +82832,7 @@ function createTypeChecker(host) { if (languageVersion >= 4 /* ES2017 */) { break; } + // fallthrough default: span ?? (span = getSpanOfTokenAtPosition(sourceFile, node.pos)); const message = isAwaitExpression(node) ? Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher; @@ -82525,7 +83041,7 @@ function createTypeChecker(host) { return silentNeverType; } if (isPrivateIdentifier(left)) { - if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) { + if (languageVersion < LanguageFeatureMinimumTarget.PrivateNamesAndClassStaticBlocks || languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators || !useDefineForClassFields) { checkExternalEmitHelpers(left, 2097152 /* ClassPrivateFieldIn */); } if (!getNodeLinks(left).resolvedSymbol && getContainingClass(left)) { @@ -82586,7 +83102,7 @@ function createTypeChecker(host) { if (propertyIndex < properties.length - 1) { error2(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); } else { - if (languageVersion < 5 /* ObjectSpreadRest */) { + if (languageVersion < LanguageFeatureMinimumTarget.ObjectSpreadRest) { checkExternalEmitHelpers(property, 4 /* Rest */); } const nonRestNames = []; @@ -82607,7 +83123,7 @@ function createTypeChecker(host) { } function checkArrayLiteralAssignment(node, sourceType, checkMode) { const elements = node.elements; - if (languageVersion < 2 /* DestructuringAssignment */ && compilerOptions.downlevelIteration) { + if (languageVersion < LanguageFeatureMinimumTarget.DestructuringAssignment && compilerOptions.downlevelIteration) { checkExternalEmitHelpers(node, 512 /* Read */); } const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* Destructuring */ | 128 /* PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType; @@ -82734,9 +83250,13 @@ function createTypeChecker(host) { return true; } return false; + // Some forms listed here for clarity case 222 /* VoidExpression */: + // Explicit opt-out case 216 /* TypeAssertionExpression */: + // Not SEF, but can produce useful type warnings case 234 /* AsExpression */: + // Not SEF, but can produce useful type warnings default: return false; } @@ -82899,7 +83419,9 @@ function createTypeChecker(host) { switch (node.kind) { case 223 /* AwaitExpression */: case 213 /* CallExpression */: + case 215 /* TaggedTemplateExpression */: case 212 /* ElementAccessExpression */: + case 236 /* MetaProperty */: case 214 /* NewExpression */: case 211 /* PropertyAccessExpression */: case 229 /* YieldExpression */: @@ -82915,6 +83437,8 @@ function createTypeChecker(host) { case 56 /* AmpersandAmpersandToken */: case 77 /* AmpersandAmpersandEqualsToken */: return 3 /* Sometimes */; + case 28 /* CommaToken */: + return getSyntacticNullishnessSemantics(node.right); } return 2 /* Never */; case 227 /* ConditionalExpression */: @@ -83377,10 +83901,10 @@ function createTypeChecker(host) { } const isAsync = (functionFlags & 2 /* Async */) !== 0; if (node.asteriskToken) { - if (isAsync && languageVersion < 5 /* AsyncGenerators */) { + if (isAsync && languageVersion < LanguageFeatureMinimumTarget.AsyncGenerators) { checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */); } - if (!isAsync && languageVersion < 2 /* Generators */ && compilerOptions.downlevelIteration) { + if (!isAsync && languageVersion < LanguageFeatureMinimumTarget.Generators && compilerOptions.downlevelIteration) { checkExternalEmitHelpers(node, 256 /* Values */); } } @@ -83611,7 +84135,7 @@ function createTypeChecker(host) { return createTupleType(elementTypes, elementFlags, type.target.readonly); } function widenTypeInferredFromInitializer(declaration, type) { - const widened = getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type); + const widened = getWidenedLiteralTypeForInitializer(declaration, type); if (isInJSFile(declaration)) { if (isEmptyLiteralType(widened)) { reportImplicitAny(declaration, anyType); @@ -83623,6 +84147,9 @@ function createTypeChecker(host) { } return widened; } + function getWidenedLiteralTypeForInitializer(declaration, type) { + return getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type); + } function isLiteralOfContextualType(candidateType, contextualType) { if (contextualType) { if (contextualType.flags & 3145728 /* UnionOrIntersection */) { @@ -83982,6 +84509,7 @@ function createTypeChecker(host) { if (node.expression.kind === 102 /* ImportKeyword */) { return checkImportCallExpression(node); } + // falls through case 214 /* NewExpression */: return checkCallExpression(node, checkMode); case 215 /* TaggedTemplateExpression */: @@ -84070,7 +84598,7 @@ function createTypeChecker(host) { const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* In */ | 16384 /* Out */); if (modifiers) { const symbol = getSymbolOfDeclaration(node.parent); - if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */))) { + if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) { error2(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types); } else if (modifiers === 8192 /* In */ || modifiers === 16384 /* Out */) { (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) }); @@ -84209,13 +84737,13 @@ function createTypeChecker(host) { } const functionFlags = getFunctionFlags(node); if (!(functionFlags & 4 /* Invalid */)) { - if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 5 /* AsyncGenerators */) { + if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < LanguageFeatureMinimumTarget.AsyncGenerators) { checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */); } - if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* AsyncFunctions */) { + if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < LanguageFeatureMinimumTarget.AsyncFunctions) { checkExternalEmitHelpers(node, 64 /* Awaiter */); } - if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* Generators */) { + if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < LanguageFeatureMinimumTarget.Generators) { checkExternalEmitHelpers(node, 128 /* Generator */); } } @@ -84351,6 +84879,7 @@ function createTypeChecker(host) { if (useDefineForClassFields) { break; } + // fall through case "prototype": const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1; const className = getNameOfSymbolAsWritten(getSymbolOfDeclaration(node)); @@ -84397,15 +84926,17 @@ function createTypeChecker(host) { if (indexSymbol == null ? void 0 : indexSymbol.declarations) { const indexSignatureMap = /* @__PURE__ */ new Map(); for (const declaration of indexSymbol.declarations) { - if (declaration.parameters.length === 1 && declaration.parameters[0].type) { - forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => { - const entry = indexSignatureMap.get(getTypeId(type)); - if (entry) { - entry.declarations.push(declaration); - } else { - indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] }); - } - }); + if (isIndexSignatureDeclaration(declaration)) { + if (declaration.parameters.length === 1 && declaration.parameters[0].type) { + forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => { + const entry = indexSignatureMap.get(getTypeId(type)); + if (entry) { + entry.declarations.push(declaration); + } else { + indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] }); + } + }); + } } } indexSignatureMap.forEach((entry) => { @@ -84447,7 +84978,7 @@ function createTypeChecker(host) { } function setNodeLinksForPrivateIdentifierScope(node) { if (isPrivateIdentifier(node.name)) { - if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) { + if (languageVersion < LanguageFeatureMinimumTarget.PrivateNamesAndClassStaticBlocks || languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators || !useDefineForClassFields) { for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) { getNodeLinks(lexicalScope).flags |= 1048576 /* ContainsClassWithPrivateIdentifiers */; } @@ -85094,6 +85625,8 @@ function createTypeChecker(host) { switch (d.kind) { case 264 /* InterfaceDeclaration */: case 265 /* TypeAliasDeclaration */: + // A jsdoc typedef and callback are, by definition, type aliases. + // falls through case 346 /* JSDocTypedefTag */: case 338 /* JSDocCallbackTag */: case 340 /* JSDocEnumTag */: @@ -85114,6 +85647,8 @@ function createTypeChecker(host) { return 1 /* ExportValue */; } d = expression; + // The below options all declare an Alias, which is allowed to merge with other values within the importing module. + // falls through case 271 /* ImportEqualsDeclaration */: case 274 /* NamespaceImport */: case 273 /* ImportClause */: @@ -85127,6 +85662,7 @@ function createTypeChecker(host) { case 208 /* BindingElement */: case 262 /* FunctionDeclaration */: case 276 /* ImportSpecifier */: + // https://github.com/Microsoft/TypeScript/pull/7591 case 80 /* Identifier */: return 1 /* ExportValue */; case 173 /* MethodSignature */: @@ -85475,6 +86011,7 @@ function createTypeChecker(host) { headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1; break; } + // falls through case 169 /* Parameter */: headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any; break; @@ -85581,7 +86118,7 @@ function createTypeChecker(host) { if (node.kind === 169 /* Parameter */) { checkExternalEmitHelpers(firstDecorator, 32 /* Param */); } - } else if (languageVersion < 99 /* ClassAndClassElementDecorators */) { + } else if (languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators) { checkExternalEmitHelpers(firstDecorator, 8 /* ESDecorateAndRunInitializers */); if (isClassDeclaration(node)) { if (!node.name) { @@ -86247,7 +86784,7 @@ function createTypeChecker(host) { potentialUnusedRenamedBindingElementsInTypes.push(node); return; } - if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ObjectSpreadRest */) { + if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < LanguageFeatureMinimumTarget.ObjectSpreadRest) { checkExternalEmitHelpers(node, 4 /* Rest */); } if (node.propertyName && node.propertyName.kind === 167 /* ComputedPropertyName */) { @@ -86283,7 +86820,7 @@ function createTypeChecker(host) { } } if (isBindingPattern(node.name)) { - if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < 2 /* BindingPatterns */ && compilerOptions.downlevelIteration) { + if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < LanguageFeatureMinimumTarget.BindingPatterns && compilerOptions.downlevelIteration) { checkExternalEmitHelpers(node, 512 /* Read */); } forEach(node.name.elements, checkSourceElement); @@ -86437,7 +86974,7 @@ function createTypeChecker(host) { } function checkVariableDeclarationList(node) { const blockScopeKind = getCombinedNodeFlags(node) & 7 /* BlockScoped */; - if ((blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) && languageVersion < 99 /* UsingAndAwaitUsing */) { + if ((blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) && languageVersion < LanguageFeatureMinimumTarget.UsingAndAwaitUsing) { checkExternalEmitHelpers(node, 16777216 /* AddDisposableResourceAndDisposeResources */); } forEach(node.declarations, checkSourceElement); @@ -86651,11 +87188,11 @@ function createTypeChecker(host) { grammarErrorOnNode(node.awaitModifier, Diagnostics.for_await_loops_cannot_be_used_inside_a_class_static_block); } else { const functionFlags = getFunctionFlags(container); - if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 5 /* ForAwaitOf */) { + if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < LanguageFeatureMinimumTarget.ForAwaitOf) { checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */); } } - } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ForOf */) { + } else if (compilerOptions.downlevelIteration && languageVersion < LanguageFeatureMinimumTarget.ForOf) { checkExternalEmitHelpers(node, 256 /* ForOfIncludes */); } if (node.initializer.kind === 261 /* VariableDeclarationList */) { @@ -86888,7 +87425,7 @@ function createTypeChecker(host) { return anyIterationTypes; } if (!(type.flags & 1048576 /* Union */)) { - const errorOutputContainer = errorNode ? { errors: void 0 } : void 0; + const errorOutputContainer = errorNode ? { errors: void 0, skipLogging: true } : void 0; const iterationTypes2 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer); if (iterationTypes2 === noIterationTypes) { if (errorNode) { @@ -87056,11 +87593,27 @@ function createTypeChecker(host) { if (isTypeAny(methodType)) { return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes); } - const signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0; - if (!some(signatures)) { + const allSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0; + const validSignatures = filter(allSignatures, (sig) => getMinArgumentCount(sig) === 0); + if (!some(validSignatures)) { + if (errorNode && some(allSignatures)) { + checkTypeAssignableTo( + type, + resolver.getGlobalIterableType( + /*reportErrors*/ + true + ), + errorNode, + /*headMessage*/ + void 0, + /*containingMessageChain*/ + void 0, + errorOutputContainer + ); + } return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes); } - const iteratorType = getIntersectionType(map(signatures, getReturnTypeOfSignature)); + const iteratorType = getIntersectionType(map(validSignatures, getReturnTypeOfSignature)); const iterationTypes = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache) ?? noIterationTypes; return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes); } @@ -87696,12 +88249,12 @@ function createTypeChecker(host) { return true; } function getFirstTransformableStaticClassElement(node) { - const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */ && classOrConstructorParameterIsDecorated( + const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators && classOrConstructorParameterIsDecorated( /*useLegacyDecorators*/ false, node ); - const willTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */; + const willTransformPrivateElementsOrClassStaticBlocks = languageVersion < LanguageFeatureMinimumTarget.PrivateNamesAndClassStaticBlocks || languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators; const willTransformInitializers = !emitStandardClassFields; if (willTransformStaticElementsOfDecoratedClass || willTransformPrivateElementsOrClassStaticBlocks) { for (const member of node.members) { @@ -87728,7 +88281,7 @@ function createTypeChecker(host) { if (node.name) return; const parent2 = walkUpOuterExpressions(node); if (!isNamedEvaluationSource(parent2)) return; - const willTransformESDecorators = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */; + const willTransformESDecorators = !legacyDecorators && languageVersion < LanguageFeatureMinimumTarget.ClassAndClassElementDecorators; let location; if (willTransformESDecorators && classOrConstructorParameterIsDecorated( /*useLegacyDecorators*/ @@ -87788,7 +88341,7 @@ function createTypeChecker(host) { const baseTypeNode = getEffectiveBaseTypeNode(node); if (baseTypeNode) { forEach(baseTypeNode.typeArguments, checkSourceElement); - if (languageVersion < 2 /* Classes */) { + if (languageVersion < LanguageFeatureMinimumTarget.Classes) { checkExternalEmitHelpers(baseTypeNode.parent, 1 /* Extends */); } const extendsNode = getClassExtendsHeritageElement(node); @@ -88294,6 +88847,9 @@ function createTypeChecker(host) { } function checkInterfaceDeclaration(node) { if (!checkGrammarModifiers(node)) checkGrammarInterfaceDeclaration(node); + if (!allowBlockDeclarations(node.parent)) { + grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "interface"); + } checkTypeParameters(node.typeParameters); addLazyDiagnostic(() => { checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0); @@ -88328,6 +88884,9 @@ function createTypeChecker(host) { function checkTypeAliasDeclaration(node) { checkGrammarModifiers(node); checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0); + if (!allowBlockDeclarations(node.parent)) { + grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "type"); + } checkExportsOnMergedDeclarations(node); checkTypeParameters(node.typeParameters); if (node.type.kind === 141 /* IntrinsicKeyword */) { @@ -88696,6 +89255,7 @@ function createTypeChecker(host) { break; case 271 /* ImportEqualsDeclaration */: if (isInternalModuleImportEqualsDeclaration(node)) break; + // falls through case 272 /* ImportDeclaration */: grammarErrorOnFirstToken(node, Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module); break; @@ -88708,6 +89268,7 @@ function createTypeChecker(host) { } break; } + // falls through case 263 /* ClassDeclaration */: case 266 /* EnumDeclaration */: case 262 /* FunctionDeclaration */: @@ -88971,6 +89532,7 @@ function createTypeChecker(host) { grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers); } if (checkExternalImportOrExportDeclaration(node)) { + let resolvedModule; const importClause = node.importClause; if (importClause && !checkGrammarImportClause(importClause)) { if (importClause.name) { @@ -88983,18 +89545,27 @@ function createTypeChecker(host) { checkExternalEmitHelpers(node, 65536 /* ImportStar */); } } else { - const moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier); - if (moduleExisted) { + resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier); + if (resolvedModule) { forEach(importClause.namedBindings.elements, checkImportBinding); } } } + if (!importClause.isTypeOnly && moduleKind === 199 /* NodeNext */ && isOnlyImportableAsDefault(node.moduleSpecifier, resolvedModule) && !hasTypeJsonImportAttribute(node)) { + error2(node.moduleSpecifier, Diagnostics.Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0, ModuleKind[moduleKind]); + } } else if (noUncheckedSideEffectImports && !importClause) { void resolveExternalModuleName(node, node.moduleSpecifier); } } checkImportAttributes(node); } + function hasTypeJsonImportAttribute(node) { + return !!node.attributes && node.attributes.elements.some((attr) => { + var _a; + return getTextOfIdentifierOrLiteral(attr.name) === "type" && ((_a = tryCast(attr.value, isStringLiteralLike)) == null ? void 0 : _a.text) === "json"; + }); + } function checkImportEqualsDeclaration(node) { if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { return; @@ -89384,6 +89955,7 @@ function createTypeChecker(host) { return checkJSDocPropertyTag(node); case 317 /* JSDocFunctionType */: checkJSDocFunctionType(node); + // falls through case 315 /* JSDocNonNullableType */: case 314 /* JSDocNullableType */: case 312 /* JSDocAllType */: @@ -89807,6 +90379,7 @@ function createTypeChecker(host) { switch (location.kind) { case 307 /* SourceFile */: if (!isExternalModule(location)) break; + // falls through case 267 /* ModuleDeclaration */: copyLocallyVisibleExportSymbols(getSymbolOfDeclaration(location).exports, meaning & 2623475 /* ModuleMember */); break; @@ -89818,6 +90391,9 @@ function createTypeChecker(host) { if (className) { copySymbol(location.symbol, meaning); } + // this fall-through is necessary because we would like to handle + // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration. + // falls through case 263 /* ClassDeclaration */: case 264 /* InterfaceDeclaration */: if (!isStaticSymbol) { @@ -89929,6 +90505,7 @@ function createTypeChecker(host) { if (isPropertyAccessExpression(entityName.parent) && getLeftmostAccessExpression(entityName.parent) === entityName) { return void 0; } + // falls through case 4 /* ThisProperty */: case 2 /* ModuleExports */: return getSymbolOfDeclaration(entityName.parent.parent); @@ -90108,7 +90685,7 @@ function createTypeChecker(host) { } else if (isJSDocMemberName(name)) { return resolveJSDocMemberName(name); } - } else if (isTypeReferenceIdentifier(name)) { + } else if (isEntityName(name) && isTypeReferenceIdentifier(name)) { const meaning = name.parent.kind === 183 /* TypeReference */ ? 788968 /* Type */ : 1920 /* Namespace */; const symbol = resolveEntityName( name, @@ -90222,6 +90799,7 @@ function createTypeChecker(host) { if (!isThisInTypeQuery(node)) { return getSymbolOfNameOrPropertyAccessExpression(node); } + // falls through case 110 /* ThisKeyword */: const container = getThisContainer( node, @@ -90239,6 +90817,7 @@ function createTypeChecker(host) { if (isInExpressionContext(node)) { return checkExpression(node).symbol; } + // falls through case 197 /* ThisType */: return getTypeFromThisTypeNode(node).symbol; case 108 /* SuperKeyword */: @@ -90261,6 +90840,7 @@ function createTypeChecker(host) { if (isCallExpression(parent2) && isBindableObjectDefinePropertyCall(parent2) && parent2.arguments[1] === node) { return getSymbolOfDeclaration(parent2); } + // falls through case 9 /* NumericLiteral */: const objectType = isElementAccessExpression(parent2) ? parent2.argumentExpression === node ? getTypeOfExpression(parent2.expression) : void 0 : isLiteralTypeNode(parent2) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0; return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text)); @@ -90290,6 +90870,7 @@ function createTypeChecker(host) { const symbol = getIntrinsicTagSymbol(node.parent); return symbol === unknownSymbol ? void 0 : symbol; } + // falls through default: return void 0; } @@ -90695,7 +91276,7 @@ function createTypeChecker(host) { const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter); if (!typeNode) return false; const type = getTypeFromTypeNode(typeNode); - return containsUndefinedType(type); + return isErrorType(type) || containsUndefinedType(type); } function requiresAddingImplicitUndefined(parameter, enclosingDeclaration) { return (isRequiredInitializedParameter(parameter, enclosingDeclaration) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter); @@ -90982,16 +91563,12 @@ function createTypeChecker(host) { } } function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, internalFlags, tracker) { - const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor); + const declaration = getParseTreeNode(declarationIn, hasInferredType); if (!declaration) { return factory.createToken(133 /* AnyKeyword */); } const symbol = getSymbolOfDeclaration(declaration); - const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType; - return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker); - } - function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) { - return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration); + return nodeBuilder.serializeTypeForDeclaration(declaration, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker); } function getAllAccessorDeclarationsForDeclaration(accessor) { accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration); @@ -91008,52 +91585,19 @@ function createTypeChecker(host) { getAccessor }; } - function getPossibleTypeNodeReuseExpression(declaration) { - return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarationsForDeclaration(declaration.parent).getAccessor) : void 0; - } - function getSingleReturnExpression(declaration) { - let candidateExpr; - if (declaration && !nodeIsMissing(declaration.body)) { - if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0; - const body = declaration.body; - if (body && isBlock(body)) { - forEachReturnStatement(body, (s) => { - if (!candidateExpr) { - candidateExpr = s.expression; - } else { - candidateExpr = void 0; - return true; - } - }); - } else { - candidateExpr = body; - } - } - return candidateExpr; - } function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, internalFlags, tracker) { const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike); if (!signatureDeclaration) { return factory.createToken(133 /* AnyKeyword */); } - return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker); + return nodeBuilder.serializeReturnTypeForSignature(signatureDeclaration, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker); } function createTypeOfExpression(exprIn, enclosingDeclaration, flags, internalFlags, tracker) { const expr = getParseTreeNode(exprIn, isExpression); if (!expr) { return factory.createToken(133 /* AnyKeyword */); } - const type = getWidenedType(getRegularTypeOfExpression(expr)); - return nodeBuilder.expressionOrTypeToTypeNode( - expr, - type, - /*addUndefined*/ - void 0, - enclosingDeclaration, - flags | 1024 /* MultilineObjectLiterals */, - internalFlags, - tracker - ); + return nodeBuilder.serializeTypeForExpression(expr, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker); } function hasGlobalName(name) { return denoGlobals.has(escapeLeadingUnderscores(name)); @@ -91204,22 +91748,6 @@ function createTypeChecker(host) { } return void 0; } - function getNonlocalEffectiveReturnTypeAnnotationNode(node) { - const direct = getEffectiveReturnTypeNode(node); - if (direct) { - return direct; - } - if (node.kind === 177 /* GetAccessor */) { - const other = getAllAccessorDeclarationsForDeclaration(node).setAccessor; - if (other) { - const param = getSetAccessorValueParameter(other); - if (param) { - return getEffectiveTypeAnnotationNode(param); - } - } - } - return void 0; - } function createResolver() { return { getReferencedExportContainer, @@ -91298,7 +91826,30 @@ function createTypeChecker(host) { return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker); }, isImportRequiredByAugmentation, - isDefinitelyReferenceToGlobalSymbolObject + isDefinitelyReferenceToGlobalSymbolObject, + createLateBoundIndexSignatures: (cls, enclosing, flags, internalFlags, tracker) => { + const sym = cls.symbol; + const staticInfos = getIndexInfosOfType(getTypeOfSymbol(sym)); + const instanceIndexSymbol = getIndexSymbol(sym); + const instanceInfos = instanceIndexSymbol && getIndexInfosOfIndexSymbol(instanceIndexSymbol, arrayFrom(getMembersOfSymbol(sym).values())); + let result; + for (const infoList of [staticInfos, instanceInfos]) { + if (!length(infoList)) continue; + result || (result = []); + for (const info of infoList) { + if (info.declaration) continue; + if (info === anyBaseTypeIndexInfo) continue; + const node = nodeBuilder.indexInfoToIndexSignatureDeclaration(info, enclosing, flags, internalFlags, tracker); + if (node && infoList === staticInfos) { + (node.modifiers || (node.modifiers = factory.createNodeArray())).unshift(factory.createModifier(126 /* StaticKeyword */)); + } + if (node) { + result.push(node); + } + } + } + return result; + } }; function isImportRequiredByAugmentation(node) { const file = getSourceFileOfNode(node); @@ -91604,6 +92155,8 @@ function createTypeChecker(host) { return ["__propKey"]; case 16777216 /* AddDisposableResourceAndDisposeResources */: return ["__addDisposableResource", "__disposeResources"]; + case 33554432 /* RewriteRelativeImportExtension */: + return ["__rewriteRelativeImportExtension"]; default: return Debug.fail("Unrecognized helper"); } @@ -92387,6 +92940,7 @@ function createTypeChecker(host) { ); break; } + // fallthrough case 7 /* ES2022 */: case 99 /* ESNext */: case 200 /* Preserve */: @@ -92394,6 +92948,7 @@ function createTypeChecker(host) { if (languageVersion >= 4 /* ES2017 */) { break; } + // fallthrough default: diagnostics.add( createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher) @@ -92751,7 +93306,7 @@ function createTypeChecker(host) { } return false; } - function allowLetAndConstDeclarations(parent2) { + function allowBlockDeclarations(parent2) { switch (parent2.kind) { case 245 /* IfStatement */: case 246 /* DoStatement */: @@ -92762,12 +93317,12 @@ function createTypeChecker(host) { case 250 /* ForOfStatement */: return false; case 256 /* LabeledStatement */: - return allowLetAndConstDeclarations(parent2.parent); + return allowBlockDeclarations(parent2.parent); } return true; } function checkGrammarForDisallowedBlockScopedVariableStatement(node) { - if (!allowLetAndConstDeclarations(node.parent)) { + if (!allowBlockDeclarations(node.parent)) { const blockScopeKind = getCombinedNodeFlagsCached(node.declarationList) & 7 /* BlockScoped */; if (blockScopeKind) { const keyword = blockScopeKind === 1 /* Let */ ? "let" : blockScopeKind === 2 /* Const */ ? "const" : blockScopeKind === 4 /* Using */ ? "using" : blockScopeKind === 6 /* AwaitUsing */ ? "await using" : Debug.fail("Unknown BlockScope flag"); @@ -93178,6 +93733,10 @@ var JsxNames; JsxNames2.IntrinsicClassAttributes = "IntrinsicClassAttributes"; JsxNames2.LibraryManagedAttributes = "LibraryManagedAttributes"; })(JsxNames || (JsxNames = {})); +var ReactNames; +((ReactNames2) => { + ReactNames2.Fragment = "Fragment"; +})(ReactNames || (ReactNames = {})); function getIterationTypesKeyFromIterationTypeKind(typeKind) { switch (typeKind) { case 0 /* Yield */: @@ -93203,7 +93762,7 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host) { var _a; return (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host); }, - useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames), + useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(), redirectTargetsMap: host.redirectTargetsMap, getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName), isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName), @@ -93211,7 +93770,8 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host) { getFileIncludeReasons: () => host.getFileIncludeReasons(), readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0, getDefaultResolutionModeForFile: (file) => host.getDefaultResolutionModeForFile(file), - getModeForResolutionAtIndex: (file, index) => host.getModeForResolutionAtIndex(file, index) + getModeForResolutionAtIndex: (file, index) => host.getModeForResolutionAtIndex(file, index), + getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation) }; } var SymbolTrackerImpl = class _SymbolTrackerImpl { @@ -93300,10 +93860,19 @@ var SymbolTrackerImpl = class _SymbolTrackerImpl { } reportInferenceFallback(node) { var _a; - if ((_a = this.inner) == null ? void 0 : _a.reportInferenceFallback) { + if (((_a = this.inner) == null ? void 0 : _a.reportInferenceFallback) && !this.context.suppressReportInferenceFallback) { + this.onDiagnosticReported(); this.inner.reportInferenceFallback(node); } } + pushErrorFallbackNode(node) { + var _a, _b; + return (_b = (_a = this.inner) == null ? void 0 : _a.pushErrorFallbackNode) == null ? void 0 : _b.call(_a, node); + } + popErrorFallbackNode() { + var _a, _b; + return (_b = (_a = this.inner) == null ? void 0 : _a.popErrorFallbackNode) == null ? void 0 : _b.call(_a); + } }; // src/compiler/visitorPublic.ts @@ -94582,13 +95151,13 @@ var visitEachChildTable = { ); }, // Transformation nodes - [354 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + [355 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { return context.factory.updatePartiallyEmittedExpression( node, Debug.checkDefined(nodeVisitor(node.expression, visitor, isExpression)) ); }, - [355 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + [356 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { return context.factory.updateCommaListExpression( node, nodesVisitor(node.elements, visitor, isExpression) @@ -95543,9 +96112,9 @@ function getDecoratorsOfParameters(node) { } return decorators; } -function getAllDecoratorsOfClass(node) { +function getAllDecoratorsOfClass(node, useLegacyDecorators) { const decorators = getDecorators(node); - const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node)); + const parameters = useLegacyDecorators ? getDecoratorsOfParameters(getFirstConstructorWithBody(node)) : void 0; if (!some(decorators) && !some(parameters)) { return void 0; } @@ -95559,18 +96128,27 @@ function getAllDecoratorsOfClassElement(member, parent2, useLegacyDecorators) { case 177 /* GetAccessor */: case 178 /* SetAccessor */: if (!useLegacyDecorators) { - return getAllDecoratorsOfMethod(member); + return getAllDecoratorsOfMethod( + member, + /*useLegacyDecorators*/ + false + ); } - return getAllDecoratorsOfAccessors(member, parent2); + return getAllDecoratorsOfAccessors( + member, + parent2, + /*useLegacyDecorators*/ + true + ); case 174 /* MethodDeclaration */: - return getAllDecoratorsOfMethod(member); + return getAllDecoratorsOfMethod(member, useLegacyDecorators); case 172 /* PropertyDeclaration */: return getAllDecoratorsOfProperty(member); default: return void 0; } } -function getAllDecoratorsOfAccessors(accessor, parent2) { +function getAllDecoratorsOfAccessors(accessor, parent2, useLegacyDecorators) { if (!accessor.body) { return void 0; } @@ -95580,7 +96158,7 @@ function getAllDecoratorsOfAccessors(accessor, parent2) { return void 0; } const decorators = getDecorators(firstAccessorWithDecorators); - const parameters = getDecoratorsOfParameters(setAccessor); + const parameters = useLegacyDecorators ? getDecoratorsOfParameters(setAccessor) : void 0; if (!some(decorators) && !some(parameters)) { return void 0; } @@ -95591,12 +96169,12 @@ function getAllDecoratorsOfAccessors(accessor, parent2) { setDecorators: setAccessor && getDecorators(setAccessor) }; } -function getAllDecoratorsOfMethod(method) { +function getAllDecoratorsOfMethod(method, useLegacyDecorators) { if (!method.body) { return void 0; } const decorators = getDecorators(method); - const parameters = getDecoratorsOfParameters(method); + const parameters = useLegacyDecorators ? getDecoratorsOfParameters(method) : void 0; if (!some(decorators) && !some(parameters)) { return void 0; } @@ -95641,6 +96219,13 @@ function isSimpleParameter(node) { function isSimpleParameterList(nodes) { return every(nodes, isSimpleParameter); } +function rewriteModuleSpecifier(node, compilerOptions) { + if (!node || !isStringLiteral(node) || !shouldRewriteModuleSpecifier(node.text, compilerOptions)) { + return node; + } + const updatedText = changeExtension(node.text, getOutputExtension(node.text, compilerOptions)); + return updatedText !== node.text ? setOriginalNode(setTextRange(factory.createStringLiteral(updatedText, node.singleQuote), node), node) : node; +} // src/compiler/transformers/destructuring.ts var FlattenLevel = /* @__PURE__ */ ((FlattenLevel2) => { @@ -96464,7 +97049,7 @@ function transformTypeScript(context) { let currentNamespaceContainerName; let currentLexicalScope; let currentScopeFirstDeclarationsOfName; - let enabledSubstitutions; + let enabledSubstitutions = 0 /* None */; let applicableSubstitutions; return transformSourceFileOrBundle; function transformSourceFileOrBundle(node) { @@ -96694,6 +97279,8 @@ function transformTypeScript(context) { case 148 /* ReadonlyKeyword */: case 103 /* InKeyword */: case 147 /* OutKeyword */: + // TypeScript accessibility and readonly modifiers are elided + // falls through case 188 /* ArrayType */: case 189 /* TupleType */: case 190 /* OptionalType */: @@ -96722,6 +97309,8 @@ function transformTypeScript(context) { case 199 /* IndexedAccessType */: case 200 /* MappedType */: case 201 /* LiteralType */: + // TypeScript type nodes are elided. + // falls through case 181 /* IndexSignature */: return void 0; case 265 /* TypeAliasDeclaration */: @@ -97965,7 +98554,14 @@ function transformTypeScript(context) { return void 0; } if (!node.exportClause || isNamespaceExport(node.exportClause)) { - return node; + return factory2.updateExportDeclaration( + node, + node.modifiers, + node.isTypeOnly, + node.exportClause, + node.moduleSpecifier, + node.attributes + ); } const allowEmpty = !!compilerOptions.verbatimModuleSyntax; const exportClause = visitNode( @@ -98004,8 +98600,10 @@ function transformTypeScript(context) { return void 0; } if (isExternalModuleImportEqualsDeclaration(node)) { - const isReferenced = shouldEmitAliasDeclaration(node); - return isReferenced ? visitEachChild(node, visitor, context) : void 0; + if (!shouldEmitAliasDeclaration(node)) { + return void 0; + } + return visitEachChild(node, visitor, context); } if (!shouldEmitImportEqualsDeclaration(node)) { return void 0; @@ -98272,7 +98870,7 @@ function transformClassFields(context) { const previousOnEmitNode = context.onEmitNode; context.onEmitNode = onEmitNode; let shouldTransformPrivateStaticElementsInFile = false; - let enabledSubstitutions; + let enabledSubstitutions = 0 /* None */; let classAliases; let pendingExpressions; let pendingStatements; @@ -98404,7 +99002,7 @@ function transformClassFields(context) { /*discarded*/ true ); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression( node, /*discarded*/ @@ -100344,6 +100942,7 @@ function transformClassFields(context) { if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) { break; } + // falls through case 262 /* FunctionDeclaration */: case 176 /* Constructor */: case 177 /* GetAccessor */: @@ -100619,6 +101218,7 @@ function createRuntimeTypeSerializer(context) { case 197 /* ThisType */: case 205 /* ImportType */: break; + // handle JSDoc types from an invalid parse case 312 /* JSDocAllType */: case 313 /* JSDocUnknownType */: case 317 /* JSDocFunctionType */: @@ -101218,7 +101818,11 @@ function transformLegacyDecorators(context) { } } function generateConstructorDecorationExpression(node) { - const allDecorators = getAllDecoratorsOfClass(node); + const allDecorators = getAllDecoratorsOfClass( + node, + /*useLegacyDecorators*/ + true + ); const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators); if (!decoratorExpressions) { return void 0; @@ -101464,6 +102068,7 @@ function transformESDecorators(context) { return Debug.fail("Not supported outside of a class. Use 'classElementVisitor' instead."); case 169 /* Parameter */: return visitParameterDeclaration(node); + // Support NamedEvaluation to ensure the correct class name for class expressions. case 226 /* BinaryExpression */: return visitBinaryExpression( node, @@ -101484,7 +102089,7 @@ function transformESDecorators(context) { return visitForStatement(node); case 244 /* ExpressionStatement */: return visitExpressionStatement(node); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression( node, /*discarded*/ @@ -101496,7 +102101,7 @@ function transformESDecorators(context) { /*discarded*/ false ); - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return visitPartiallyEmittedExpression( node, /*discarded*/ @@ -101520,6 +102125,7 @@ function transformESDecorators(context) { case 167 /* ComputedPropertyName */: return visitComputedPropertyName(node); case 174 /* MethodDeclaration */: + // object literal methods and accessors case 178 /* SetAccessor */: case 177 /* GetAccessor */: case 218 /* FunctionExpression */: @@ -101582,7 +102188,7 @@ function transformESDecorators(context) { /*discarded*/ true ); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression( node, /*discarded*/ @@ -101728,7 +102334,11 @@ function transformESDecorators(context) { let syntheticConstructor; let heritageClauses; let shouldTransformPrivateStaticElementsInClass = false; - const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass(node)); + const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass( + node, + /*useLegacyDecorators*/ + false + )); if (classDecorators) { classInfo2.classDecoratorsName = factory2.createUniqueName("_classDecorators", 16 /* Optimistic */ | 32 /* FileLevel */); classInfo2.classDescriptorName = factory2.createUniqueName("_classDescriptor", 16 /* Optimistic */ | 32 /* FileLevel */); @@ -103201,7 +103811,7 @@ function transformES2017(context) { const resolver = context.getEmitResolver(); const compilerOptions = context.getCompilerOptions(); const languageVersion = getEmitScriptTarget(compilerOptions); - let enabledSubstitutions; + let enabledSubstitutions = 0 /* None */; let enclosingSuperContainerFlags = 0; let enclosingFunctionParameterNames; let capturedSuperProperties; @@ -104076,7 +104686,7 @@ function transformES2018(context) { const previousOnSubstituteNode = context.onSubstituteNode; context.onSubstituteNode = onSubstituteNode; let exportedVariableStatement = false; - let enabledSubstitutions; + let enabledSubstitutions = 0 /* None */; let enclosingFunctionFlags; let parametersWithPrecedingObjectRestOrSpread; let enclosingSuperContainerFlags = 0; @@ -104164,7 +104774,7 @@ function transformES2018(context) { return visitObjectLiteralExpression(node); case 226 /* BinaryExpression */: return visitBinaryExpression(node, expressionResultIsUnused2); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression(node, expressionResultIsUnused2); case 299 /* CatchClause */: return visitCatchClause(node); @@ -107211,7 +107821,7 @@ function transformES2015(context) { ); } let convertedLoopState; - let enabledSubstitutions; + let enabledSubstitutions = 0 /* None */; return chainBundle(context, transformSourceFile); function transformSourceFile(node) { if (node.isDeclarationFile) { @@ -107304,6 +107914,7 @@ function transformES2015(context) { switch (node.kind) { case 126 /* StaticKeyword */: return void 0; + // elide static keyword case 263 /* ClassDeclaration */: return visitClassDeclaration(node); case 231 /* ClassExpression */: @@ -107382,7 +107993,7 @@ function transformES2015(context) { return visitParenthesizedExpression(node, expressionResultIsUnused2); case 226 /* BinaryExpression */: return visitBinaryExpression(node, expressionResultIsUnused2); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression(node, expressionResultIsUnused2); case 15 /* NoSubstitutionTemplateLiteral */: case 16 /* TemplateHead */: @@ -107766,12 +108377,14 @@ function transformES2015(context) { return false; } switch (node.kind) { + // stop at function boundaries case 219 /* ArrowFunction */: case 218 /* FunctionExpression */: case 262 /* FunctionDeclaration */: case 176 /* Constructor */: case 175 /* ClassStaticBlockDeclaration */: return false; + // only step into computed property names for class and object literal elements case 177 /* GetAccessor */: case 178 /* SetAccessor */: case 174 /* MethodDeclaration */: @@ -107980,12 +108593,14 @@ function transformES2015(context) { return factory2.createPartiallyEmittedExpression(node.right, node); } switch (node.kind) { + // stop at function boundaries case 219 /* ArrowFunction */: case 218 /* FunctionExpression */: case 262 /* FunctionDeclaration */: case 176 /* Constructor */: case 175 /* ClassStaticBlockDeclaration */: return node; + // only step into computed property names for class and object literal elements case 177 /* GetAccessor */: case 178 /* SetAccessor */: case 174 /* MethodDeclaration */: @@ -108031,12 +108646,14 @@ function transformES2015(context) { ); } switch (node.kind) { + // stop at function boundaries case 219 /* ArrowFunction */: case 218 /* FunctionExpression */: case 262 /* FunctionDeclaration */: case 176 /* Constructor */: case 175 /* ClassStaticBlockDeclaration */: return node; + // only step into computed property names for class and object literal elements case 177 /* GetAccessor */: case 178 /* SetAccessor */: case 174 /* MethodDeclaration */: @@ -110668,7 +111285,7 @@ function transformGenerators(context) { switch (node.kind) { case 226 /* BinaryExpression */: return visitBinaryExpression(node); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return visitCommaListExpression(node); case 227 /* ConditionalExpression */: return visitConditionalExpression(node); @@ -112564,6 +113181,7 @@ function transformModule(context) { const moduleInfoMap = []; let currentSourceFile; let currentModuleInfo; + let importsAndRequiresToRewriteOrShim; const noSubstitution = []; let needUMDDynamicImportHelper; return chainBundle(context, transformSourceFile); @@ -112574,6 +113192,20 @@ function transformModule(context) { currentSourceFile = node; currentModuleInfo = collectExternalModuleInfo(context, node); moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo; + if (compilerOptions.rewriteRelativeImportExtensions) { + forEachDynamicImportOrRequireCall( + node, + /*includeTypeSpaceImports*/ + false, + /*requireStringLiteralLikeArgument*/ + false, + (node2) => { + if (!isStringLiteralLike(node2.arguments[0]) || shouldRewriteModuleSpecifier(node2.arguments[0].text, compilerOptions)) { + importsAndRequiresToRewriteOrShim = append(importsAndRequiresToRewriteOrShim, node2); + } + } + ); + } const transformModule2 = getTransformModuleDelegate(moduleKind); const updated = transformModule2(node); currentSourceFile = void 0; @@ -113045,7 +113677,7 @@ function transformModule(context) { } } function visitorWorker(node, valueIsDiscarded) { - if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) { + if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */)) && !(importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length)) { return node; } switch (node.kind) { @@ -113059,11 +113691,17 @@ function transformModule(context) { return visitExpressionStatement(node); case 217 /* ParenthesizedExpression */: return visitParenthesizedExpression(node, valueIsDiscarded); - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return visitPartiallyEmittedExpression(node, valueIsDiscarded); case 213 /* CallExpression */: + const needsRewrite = node === firstOrUndefined(importsAndRequiresToRewriteOrShim); + if (needsRewrite) { + importsAndRequiresToRewriteOrShim.shift(); + } if (isImportCall(node) && host.shouldTransformImportCall(currentSourceFile)) { - return visitImportCallExpression(node); + return visitImportCallExpression(node, needsRewrite); + } else if (needsRewrite) { + return shimOrRewriteImportOrRequireCall(node); } break; case 226 /* BinaryExpression */: @@ -113355,13 +113993,27 @@ function transformModule(context) { } return visitEachChild(node, visitor, context); } - function visitImportCallExpression(node) { + function shimOrRewriteImportOrRequireCall(node) { + return factory2.updateCallExpression( + node, + node.expression, + /*typeArguments*/ + void 0, + visitNodes2(node.arguments, (arg) => { + if (arg === node.arguments[0]) { + return isStringLiteralLike(arg) ? rewriteModuleSpecifier(arg, compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(arg); + } + return visitor(arg); + }, isExpression) + ); + } + function visitImportCallExpression(node, rewriteOrShim) { if (moduleKind === 0 /* None */ && languageVersion >= 7 /* ES2020 */) { return visitEachChild(node, visitor, context); } const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions); const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression); - const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument; + const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument && rewriteOrShim ? isStringLiteral(firstArgument) ? rewriteModuleSpecifier(firstArgument, compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(firstArgument) : firstArgument; const containsLexicalThis = !!(node.transformFlags & 16384 /* ContainsLexicalThis */); switch (compilerOptions.module) { case 2 /* AMD */: @@ -113692,7 +114344,7 @@ function transformModule(context) { const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions); const args = []; if (moduleName) { - args.push(moduleName); + args.push(rewriteModuleSpecifier(moduleName, compilerOptions)); } return factory2.createCallExpression( factory2.createIdentifier("require"), @@ -114819,6 +115471,7 @@ function transformSystemModule(context) { if (!entry.importClause) { break; } + // falls through case 271 /* ImportEqualsDeclaration */: Debug.assert(importVariableName !== void 0); statements.push( @@ -115453,7 +116106,7 @@ function transformSystemModule(context) { return visitExpressionStatement(node); case 217 /* ParenthesizedExpression */: return visitParenthesizedExpression(node, valueIsDiscarded); - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return visitPartiallyEmittedExpression(node, valueIsDiscarded); case 226 /* BinaryExpression */: if (isDestructuringAssignment(node)) { @@ -115786,6 +116439,8 @@ function transformECMAScriptModule(context) { context.onSubstituteNode = onSubstituteNode; context.enableEmitNotification(307 /* SourceFile */); context.enableSubstitution(80 /* Identifier */); + const noSubstitution = /* @__PURE__ */ new Set(); + let importsAndRequiresToRewriteOrShim; let helperNameSubstitutions; let currentSourceFile; let importRequireStatements; @@ -115797,7 +116452,22 @@ function transformECMAScriptModule(context) { if (isExternalModule(node) || getIsolatedModules(compilerOptions)) { currentSourceFile = node; importRequireStatements = void 0; + if (compilerOptions.rewriteRelativeImportExtensions && (currentSourceFile.flags & 4194304 /* PossiblyContainsDynamicImport */ || isInJSFile(node))) { + forEachDynamicImportOrRequireCall( + node, + /*includeTypeSpaceImports*/ + false, + /*requireStringLiteralLikeArgument*/ + false, + (node2) => { + if (!isStringLiteralLike(node2.arguments[0]) || shouldRewriteModuleSpecifier(node2.arguments[0].text, compilerOptions)) { + importsAndRequiresToRewriteOrShim = append(importsAndRequiresToRewriteOrShim, node2); + } + } + ); + } let result = updateExternalModule(node); + addEmitHelpers(result, context.readEmitHelpers()); currentSourceFile = void 0; if (importRequireStatements) { result = factory2.updateSourceFile( @@ -115820,7 +116490,7 @@ function transformECMAScriptModule(context) { if (externalHelpersImportDeclaration) { const statements = []; const statementOffset = factory2.copyPrologue(node.statements, statements); - append(statements, externalHelpersImportDeclaration); + addRange(statements, visitArray([externalHelpersImportDeclaration], visitor, isStatement)); addRange(statements, visitNodes2(node.statements, visitor, isStatement, statementOffset)); return factory2.updateSourceFile( node, @@ -115839,14 +116509,52 @@ function transformECMAScriptModule(context) { case 278 /* ExportDeclaration */: const exportDecl = node; return visitExportDeclaration(exportDecl); + case 272 /* ImportDeclaration */: + return visitImportDeclaration(node); + case 213 /* CallExpression */: + if (node === (importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim[0])) { + return visitImportOrRequireCall(importsAndRequiresToRewriteOrShim.shift()); + } + break; + default: + if ((importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length) && rangeContainsRange(node, importsAndRequiresToRewriteOrShim[0])) { + return visitEachChild(node, visitor, context); + } } return node; } + function visitImportDeclaration(node) { + if (!compilerOptions.rewriteRelativeImportExtensions) { + return node; + } + const updatedModuleSpecifier = rewriteModuleSpecifier(node.moduleSpecifier, compilerOptions); + if (updatedModuleSpecifier === node.moduleSpecifier) { + return node; + } + return factory2.updateImportDeclaration( + node, + node.modifiers, + node.importClause, + updatedModuleSpecifier, + node.attributes + ); + } + function visitImportOrRequireCall(node) { + return factory2.updateCallExpression( + node, + node.expression, + node.typeArguments, + [ + isStringLiteralLike(node.arguments[0]) ? rewriteModuleSpecifier(node.arguments[0], compilerOptions) : emitHelpers().createRewriteRelativeImportExtensionsHelper(node.arguments[0]), + ...node.arguments.slice(1) + ] + ); + } function createRequireCall2(importNode) { const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions); const args = []; if (moduleName) { - args.push(moduleName); + args.push(rewriteModuleSpecifier(moduleName, compilerOptions)); } if (getEmitModuleKind(compilerOptions) === 200 /* Preserve */) { return factory2.createCallExpression( @@ -115991,11 +116699,16 @@ function transformECMAScriptModule(context) { return node; } function visitExportDeclaration(node) { - if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */) { - return node; - } - if (!node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) { - return node; + const updatedModuleSpecifier = rewriteModuleSpecifier(node.moduleSpecifier, compilerOptions); + if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */ || !node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) { + return !node.moduleSpecifier || updatedModuleSpecifier === node.moduleSpecifier ? node : factory2.updateExportDeclaration( + node, + node.modifiers, + node.isTypeOnly, + node.exportClause, + updatedModuleSpecifier, + node.attributes + ); } const oldIdentifier = node.exportClause.name; const synthName = factory2.getGeneratedNameForNode(oldIdentifier); @@ -116011,7 +116724,7 @@ function transformECMAScriptModule(context) { synthName ) ), - node.moduleSpecifier, + updatedModuleSpecifier, node.attributes ); setOriginalNode(importDecl, node.exportClause); @@ -116035,7 +116748,9 @@ function transformECMAScriptModule(context) { if ((isExternalModule(node) || getIsolatedModules(compilerOptions)) && compilerOptions.importHelpers) { helperNameSubstitutions = /* @__PURE__ */ new Map(); } + currentSourceFile = node; previousOnEmitNode(hint, node, emitCallback); + currentSourceFile = void 0; helperNameSubstitutions = void 0; } else { previousOnEmitNode(hint, node, emitCallback); @@ -116043,18 +116758,29 @@ function transformECMAScriptModule(context) { } function onSubstituteNode(hint, node) { node = previousOnSubstituteNode(hint, node); - if (helperNameSubstitutions && isIdentifier(node) && getEmitFlags(node) & 8192 /* HelperName */) { + if (node.id && noSubstitution.has(node.id)) { + return node; + } + if (isIdentifier(node) && getEmitFlags(node) & 8192 /* HelperName */) { return substituteHelperName(node); } return node; } function substituteHelperName(node) { - const name = idText(node); - let substitution = helperNameSubstitutions.get(name); - if (!substitution) { - helperNameSubstitutions.set(name, substitution = factory2.createUniqueName(name, 16 /* Optimistic */ | 32 /* FileLevel */)); + const externalHelpersModuleName = currentSourceFile && getExternalHelpersModuleName(currentSourceFile); + if (externalHelpersModuleName) { + noSubstitution.add(getNodeId(node)); + return factory2.createPropertyAccessExpression(externalHelpersModuleName, node); } - return substitution; + if (helperNameSubstitutions) { + const name = idText(node); + let substitution = helperNameSubstitutions.get(name); + if (!substitution) { + helperNameSubstitutions.set(name, substitution = factory2.createUniqueName(name, 16 /* Optimistic */ | 32 /* FileLevel */)); + } + return substitution; + } + return node; } } @@ -116404,8 +117130,8 @@ function createGetIsolatedDeclarationErrors(resolver) { [219 /* ArrowFunction */]: Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, [174 /* MethodDeclaration */]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, [180 /* ConstructSignature */]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, - [177 /* GetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, - [178 /* SetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations, + [177 /* GetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations, + [178 /* SetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations, [169 /* Parameter */]: Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations, [260 /* VariableDeclaration */]: Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations, [172 /* PropertyDeclaration */]: Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations, @@ -116534,7 +117260,7 @@ function createGetIsolatedDeclarationErrors(resolver) { if (!addUndefined && node.initializer) { return createExpressionError(node.initializer); } - const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind]; + const message = addUndefined ? Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations : errorByDeclarationKind[node.kind]; const diag2 = createDiagnosticForNode(node, message); const targetStr = getTextOfNode( node.name, @@ -116612,6 +117338,7 @@ function transformDeclarations(context) { let suppressNewDiagnosticContexts; const { factory: factory2 } = context; const host = context.getEmitHost(); + let restoreFallbackNode = () => void 0; const symbolTracker = { trackSymbol, reportInaccessibleThisError, @@ -116623,7 +117350,19 @@ function transformDeclarations(context) { moduleResolverHost: host, reportNonlocalAugmentation, reportNonSerializableProperty, - reportInferenceFallback + reportInferenceFallback, + pushErrorFallbackNode(node) { + const currentFallback = errorFallbackNode; + const currentRestore = restoreFallbackNode; + restoreFallbackNode = () => { + restoreFallbackNode = currentRestore; + errorFallbackNode = currentFallback; + }; + errorFallbackNode = node; + }, + popErrorFallbackNode() { + restoreFallbackNode(); + } }; let errorNameNode; let errorFallbackNode; @@ -116960,7 +117699,7 @@ function transformDeclarations(context) { ); } } - function ensureParameter(p, modifierMask, type) { + function ensureParameter(p, modifierMask) { let oldDiag; if (!suppressNewDiagnosticContexts) { oldDiag = getSymbolAccessibilityDiagnostic; @@ -116974,7 +117713,6 @@ function transformDeclarations(context) { resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(58 /* QuestionToken */) : void 0, ensureType( p, - type || p.type, /*ignorePrivate*/ true ), @@ -116999,44 +117737,34 @@ function transformDeclarations(context) { } return void 0; } - function ensureType(node, type, ignorePrivate) { + function ensureType(node, ignorePrivate) { if (!ignorePrivate && hasEffectiveModifier(node, 2 /* Private */)) { return; } if (shouldPrintWithInitializer(node)) { return; } - const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node, enclosingDeclaration); - if (type && !shouldAddImplicitUndefined) { - return visitNode(type, visitDeclarationSubtree, isTypeNode); + if (!isExportAssignment(node) && !isBindingElement(node) && node.type && (!isParameter(node) || !resolver.requiresAddingImplicitUndefined(node, enclosingDeclaration))) { + return visitNode(node.type, visitDeclarationSubtree, isTypeNode); } + const oldErrorNameNode = errorNameNode; errorNameNode = node.name; let oldDiag; if (!suppressNewDiagnosticContexts) { oldDiag = getSymbolAccessibilityDiagnostic; - getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node); + if (canProduceDiagnostics(node)) { + getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node); + } } let typeNode; - switch (node.kind) { - case 169 /* Parameter */: - case 171 /* PropertySignature */: - case 172 /* PropertyDeclaration */: - case 208 /* BindingElement */: - case 260 /* VariableDeclaration */: - typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker); - break; - case 262 /* FunctionDeclaration */: - case 180 /* ConstructSignature */: - case 173 /* MethodSignature */: - case 174 /* MethodDeclaration */: - case 177 /* GetAccessor */: - case 179 /* CallSignature */: - typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker); - break; - default: - Debug.assertNever(node); + if (hasInferredType(node)) { + typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker); + } else if (isFunctionLike(node)) { + typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker); + } else { + Debug.assertNever(node); } - errorNameNode = void 0; + errorNameNode = oldErrorNameNode; if (!suppressNewDiagnosticContexts) { getSymbolAccessibilityDiagnostic = oldDiag; } @@ -117052,6 +117780,7 @@ function transformDeclarations(context) { case 265 /* TypeAliasDeclaration */: case 266 /* EnumDeclaration */: return !resolver.isDeclarationVisible(node); + // The following should be doing their own visibility checks based on filtering their members case 260 /* VariableDeclaration */: return !getBindingNameVisible(node); case 271 /* ImportEqualsDeclaration */: @@ -117105,13 +117834,7 @@ function transformDeclarations(context) { if (!isPrivate) { const valueParameter = getSetAccessorValueParameter(input); if (valueParameter) { - const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input)); - newValueParameter = ensureParameter( - valueParameter, - /*modifierMask*/ - void 0, - accessorType - ); + newValueParameter = ensureParameter(valueParameter); } } if (!newValueParameter) { @@ -117143,7 +117866,7 @@ function transformDeclarations(context) { } return setCommentRange(updated, getCommentRange(original)); } - function rewriteModuleSpecifier(parent2, input) { + function rewriteModuleSpecifier2(parent2, input) { if (!input) return void 0; resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent2.kind !== 267 /* ModuleDeclaration */ && parent2.kind !== 205 /* ImportType */; if (isStringLiteralLike(input)) { @@ -117165,7 +117888,7 @@ function transformDeclarations(context) { decl.modifiers, decl.isTypeOnly, decl.name, - factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier)) + factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier2(decl, specifier)) ); } else { const oldDiag = getSymbolAccessibilityDiagnostic; @@ -117181,7 +117904,7 @@ function transformDeclarations(context) { decl, decl.modifiers, decl.importClause, - rewriteModuleSpecifier(decl, decl.moduleSpecifier), + rewriteModuleSpecifier2(decl, decl.moduleSpecifier), tryGetResolutionModeOverride(decl.attributes) ); } @@ -117197,7 +117920,7 @@ function transformDeclarations(context) { /*namedBindings*/ void 0 ), - rewriteModuleSpecifier(decl, decl.moduleSpecifier), + rewriteModuleSpecifier2(decl, decl.moduleSpecifier), tryGetResolutionModeOverride(decl.attributes) ); } @@ -117215,7 +117938,7 @@ function transformDeclarations(context) { visibleDefaultBinding, namedBindings ), - rewriteModuleSpecifier(decl, decl.moduleSpecifier), + rewriteModuleSpecifier2(decl, decl.moduleSpecifier), tryGetResolutionModeOverride(decl.attributes) ) : void 0; } @@ -117230,7 +117953,7 @@ function transformDeclarations(context) { visibleDefaultBinding, bindingList && bindingList.length ? factory2.updateNamedImports(decl.importClause.namedBindings, bindingList) : void 0 ), - rewriteModuleSpecifier(decl, decl.moduleSpecifier), + rewriteModuleSpecifier2(decl, decl.moduleSpecifier), tryGetResolutionModeOverride(decl.attributes) ); } @@ -117243,7 +117966,7 @@ function transformDeclarations(context) { decl.modifiers, /*importClause*/ void 0, - rewriteModuleSpecifier(decl, decl.moduleSpecifier), + rewriteModuleSpecifier2(decl, decl.moduleSpecifier), tryGetResolutionModeOverride(decl.attributes) ); } @@ -117362,7 +118085,7 @@ function transformDeclarations(context) { input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), - ensureType(input, input.type) + ensureType(input) )); case 176 /* Constructor */: { const ctor = factory2.createConstructorDeclaration( @@ -117389,7 +118112,7 @@ function transformDeclarations(context) { input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), - ensureType(input, input.type), + ensureType(input), /*body*/ void 0 ); @@ -117402,13 +118125,12 @@ function transformDeclarations(context) { void 0 ); } - const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input)); return cleanup(factory2.updateGetAccessorDeclaration( input, ensureModifiers(input), input.name, updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)), - ensureType(input, accessorType), + ensureType(input), /*body*/ void 0 )); @@ -117441,7 +118163,7 @@ function transformDeclarations(context) { ensureModifiers(input), input.name, input.questionToken, - ensureType(input, input.type), + ensureType(input), ensureNoInitializer(input) )); case 171 /* PropertySignature */: @@ -117456,7 +118178,7 @@ function transformDeclarations(context) { ensureModifiers(input), input.name, input.questionToken, - ensureType(input, input.type) + ensureType(input) )); case 173 /* MethodSignature */: { if (isPrivateIdentifier(input.name)) { @@ -117472,7 +118194,7 @@ function transformDeclarations(context) { input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), - ensureType(input, input.type) + ensureType(input) )); } case 179 /* CallSignature */: { @@ -117481,7 +118203,7 @@ function transformDeclarations(context) { input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), - ensureType(input, input.type) + ensureType(input) ) ); } @@ -117504,7 +118226,7 @@ function transformDeclarations(context) { input.name, /*exclamationToken*/ void 0, - ensureType(input, input.type), + ensureType(input), ensureNoInitializer(input) )); } @@ -117557,7 +118279,7 @@ function transformDeclarations(context) { if (!isLiteralImportTypeNode(input)) return cleanup(input); return cleanup(factory2.updateImportTypeNode( input, - factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), + factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier2(input, input.argument.literal)), input.attributes, input.qualifier, visitNodes2(input.typeArguments, visitDeclarationSubtree, isTypeNode), @@ -117610,7 +118332,7 @@ function transformDeclarations(context) { input.modifiers, input.isTypeOnly, input.exportClause, - rewriteModuleSpecifier(input, input.moduleSpecifier), + rewriteModuleSpecifier2(input, input.moduleSpecifier), tryGetResolutionModeOverride(input.attributes) ); } @@ -117628,11 +118350,12 @@ function transformDeclarations(context) { errorNode: input }); errorFallbackNode = input; + const type = ensureType(input); const varDecl = factory2.createVariableDeclaration( newId, /*exclamationToken*/ void 0, - resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker), + type, /*initializer*/ void 0 ); @@ -117729,7 +118452,7 @@ function transformDeclarations(context) { input.name, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), - ensureType(input, input.type), + ensureType(input), /*body*/ void 0 )); @@ -117860,7 +118583,7 @@ function transformDeclarations(context) { return cleanup(updateModuleDeclarationAndKeyword( input, mods, - isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name, + isExternalModuleAugmentation(input) ? rewriteModuleSpecifier2(input, input.name) : input.name, body )); } else { @@ -117897,7 +118620,7 @@ function transformDeclarations(context) { ensureModifiers(param), param.name, param.questionToken, - ensureType(param, param.type), + ensureType(param), ensureNoInitializer(param) ), param @@ -117918,11 +118641,7 @@ function transformDeclarations(context) { elem.name, /*questionOrExclamationToken*/ void 0, - ensureType( - elem, - /*type*/ - void 0 - ), + ensureType(elem), /*initializer*/ void 0 )); @@ -117946,7 +118665,8 @@ function transformDeclarations(context) { void 0 ) ] : void 0; - const memberNodes = concatenate(concatenate(privateIdentifier, parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement)); + const lateIndexes = resolver.createLateBoundIndexSignatures(input, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker); + const memberNodes = concatenate(concatenate(concatenate(privateIdentifier, lateIndexes), parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement)); const members = factory2.createNodeArray(memberNodes); const extendsClause = getEffectiveBaseTypeNode(input); if (extendsClause && !isEntityNameExpression(extendsClause.expression) && extendsClause.expression.kind !== 106 /* NullKeyword */) { @@ -118072,11 +118792,7 @@ function transformDeclarations(context) { e.name, /*exclamationToken*/ void 0, - ensureType( - e, - /*type*/ - void 0 - ), + ensureType(e), /*initializer*/ void 0 ); @@ -118126,18 +118842,6 @@ function transformDeclarations(context) { } return maskModifierFlags(node, mask2, additions); } - function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) { - let accessorType = getTypeAnnotationFromAccessor(node); - if (!accessorType && node !== accessors.firstAccessor) { - accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor); - getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor); - } - if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) { - accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor); - getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor); - } - return accessorType; - } function transformHeritageClauses(nodes) { return factory2.createNodeArray(filter( map(nodes, (clause) => factory2.updateHeritageClause( @@ -118173,11 +118877,6 @@ function maskModifierFlags(node, modifierMask = 131071 /* All */ ^ 1 /* Public * } return flags; } -function getTypeAnnotationFromAccessor(accessor) { - if (accessor) { - return accessor.kind === 177 /* GetAccessor */ ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : void 0; - } -} function canHaveLiteralInitializer(node) { switch (node.kind) { case 172 /* PropertyDeclaration */: @@ -118333,7 +119032,7 @@ function noEmitNotification(hint, node, callback) { } function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) { var _a, _b; - const enabledSyntaxKindFeatures = new Array(357 /* Count */); + const enabledSyntaxKindFeatures = new Array(358 /* Count */); let lexicalEnvironmentVariableDeclarations; let lexicalEnvironmentFunctionDeclarations; let lexicalEnvironmentStatements; @@ -119262,7 +119961,8 @@ var notImplementedResolver = { isBindingCapturedByNode: notImplemented, getDeclarationStatementsForSourceFile: notImplemented, isImportRequiredByAugmentation: notImplemented, - isDefinitelyReferenceToGlobalSymbolObject: notImplemented + isDefinitelyReferenceToGlobalSymbolObject: notImplemented, + createLateBoundIndexSignatures: notImplemented }; var createPrinterWithDefaults = /* @__PURE__ */ memoize(() => createPrinter({})); var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true })); @@ -119547,6 +120247,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) { return pipelineEmitWithNotification; } + // falls through case 1 /* Substitution */: if (substituteNode !== noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) { if (currentParenthesizerRule) { @@ -119554,14 +120255,17 @@ function createPrinter(printerOptions = {}, handlers = {}) { } return pipelineEmitWithSubstitution; } + // falls through case 2 /* Comments */: if (shouldEmitComments(node)) { return pipelineEmitWithComments; } + // falls through case 3 /* SourceMaps */: if (shouldEmitSourceMaps(node)) { return pipelineEmitWithSourceMaps; } + // falls through case 4 /* Emit */: return pipelineEmitWithHint; default: @@ -119613,6 +120317,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { } if (hint === 4 /* Unspecified */) { switch (node.kind) { + // Pseudo-literals case 16 /* TemplateHead */: case 17 /* TemplateMiddle */: case 18 /* TemplateTail */: @@ -119621,20 +120326,26 @@ function createPrinter(printerOptions = {}, handlers = {}) { /*jsxAttributeEscape*/ false ); + // Identifiers case 80 /* Identifier */: return emitIdentifier(node); + // PrivateIdentifiers case 81 /* PrivateIdentifier */: return emitPrivateIdentifier(node); + // Parse tree nodes + // Names case 166 /* QualifiedName */: return emitQualifiedName(node); case 167 /* ComputedPropertyName */: return emitComputedPropertyName(node); + // Signature elements case 168 /* TypeParameter */: return emitTypeParameter(node); case 169 /* Parameter */: return emitParameter(node); case 170 /* Decorator */: return emitDecorator(node); + // Type members case 171 /* PropertySignature */: return emitPropertySignature(node); case 172 /* PropertyDeclaration */: @@ -119656,6 +120367,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitConstructSignature(node); case 181 /* IndexSignature */: return emitIndexSignature(node); + // Types case 182 /* TypePredicate */: return emitTypePredicate(node); case 183 /* TypeReference */: @@ -119674,6 +120386,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitTupleType(node); case 190 /* OptionalType */: return emitOptionalType(node); + // SyntaxKind.RestType is handled below case 192 /* UnionType */: return emitUnionType(node); case 193 /* IntersectionType */: @@ -119704,16 +120417,19 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitTemplateTypeSpan(node); case 205 /* ImportType */: return emitImportTypeNode(node); + // Binding patterns case 206 /* ObjectBindingPattern */: return emitObjectBindingPattern(node); case 207 /* ArrayBindingPattern */: return emitArrayBindingPattern(node); case 208 /* BindingElement */: return emitBindingElement(node); + // Misc case 239 /* TemplateSpan */: return emitTemplateSpan(node); case 240 /* SemicolonClassElement */: return emitSemicolonClassElement(); + // Statements case 241 /* Block */: return emitBlock(node); case 243 /* VariableStatement */: @@ -119755,6 +120471,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitTryStatement(node); case 259 /* DebuggerStatement */: return emitDebuggerStatement(node); + // Declarations case 260 /* VariableDeclaration */: return emitVariableDeclaration(node); case 261 /* VariableDeclarationList */: @@ -119805,8 +120522,10 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitImportAttribute(node); case 282 /* MissingDeclaration */: return; + // Module references case 283 /* ExternalModuleReference */: return emitExternalModuleReference(node); + // JSX (non-expression) case 12 /* JsxText */: return emitJsxText(node); case 286 /* JsxOpeningElement */: @@ -119825,6 +120544,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitJsxExpression(node); case 295 /* JsxNamespacedName */: return emitJsxNamespacedName(node); + // Clauses case 296 /* CaseClause */: return emitCaseClause(node); case 297 /* DefaultClause */: @@ -119833,18 +120553,22 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitHeritageClause(node); case 299 /* CatchClause */: return emitCatchClause(node); + // Property assignments case 303 /* PropertyAssignment */: return emitPropertyAssignment(node); case 304 /* ShorthandPropertyAssignment */: return emitShorthandPropertyAssignment(node); case 305 /* SpreadAssignment */: return emitSpreadAssignment(node); + // Enum case 306 /* EnumMember */: return emitEnumMember(node); + // Top-level nodes case 307 /* SourceFile */: return emitSourceFile(node); case 308 /* Bundle */: return Debug.fail("Bundles should be printed using printBundle"); + // JSDoc nodes (only used in codefixes currently) case 309 /* JSDocTypeExpression */: return emitJSDocTypeExpression(node); case 310 /* JSDocNameReference */: @@ -119882,6 +120606,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { case 330 /* JSDocAuthorTag */: case 331 /* JSDocDeprecatedTag */: return; + // SyntaxKind.JSDocClassTag (see JSDocTag, above) case 333 /* JSDocPublicTag */: case 334 /* JSDocPrivateTag */: case 335 /* JSDocProtectedTag */: @@ -119891,6 +120616,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitJSDocCallbackTag(node); case 339 /* JSDocOverloadTag */: return emitJSDocOverloadTag(node); + // SyntaxKind.JSDocEnumTag (see below) case 341 /* JSDocParameterTag */: case 348 /* JSDocPropertyTag */: return emitJSDocPropertyLikeTag(node); @@ -119909,7 +120635,10 @@ function createPrinter(printerOptions = {}, handlers = {}) { return emitJSDocSeeTag(node); case 351 /* JSDocImportTag */: return emitJSDocImportTag(node); + // SyntaxKind.JSDocPropertyTag (see JSDocParameterTag, above) + // Transformation nodes case 353 /* NotEmittedStatement */: + case 354 /* NotEmittedTypeElement */: return; } if (isExpression(node)) { @@ -119927,6 +120656,7 @@ function createPrinter(printerOptions = {}, handlers = {}) { } if (hint === 1 /* Expression */) { switch (node.kind) { + // Literals case 9 /* NumericLiteral */: case 10 /* BigIntLiteral */: return emitNumericOrBigIntLiteral(node); @@ -119938,10 +120668,12 @@ function createPrinter(printerOptions = {}, handlers = {}) { /*jsxAttributeEscape*/ false ); + // Identifiers case 80 /* Identifier */: return emitIdentifier(node); case 81 /* PrivateIdentifier */: return emitPrivateIdentifier(node); + // Expressions case 209 /* ArrayLiteralExpression */: return emitArrayLiteralExpression(node); case 210 /* ObjectLiteralExpression */: @@ -120004,21 +120736,24 @@ function createPrinter(printerOptions = {}, handlers = {}) { return Debug.fail("SyntheticExpression should never be printed."); case 282 /* MissingDeclaration */: return; + // JSX case 284 /* JsxElement */: return emitJsxElement(node); case 285 /* JsxSelfClosingElement */: return emitJsxSelfClosingElement(node); case 288 /* JsxFragment */: return emitJsxFragment(node); + // Synthesized list case 352 /* SyntaxList */: return Debug.fail("SyntaxList should not be printed"); + // Transformation nodes case 353 /* NotEmittedStatement */: return; - case 354 /* PartiallyEmittedExpression */: + case 355 /* PartiallyEmittedExpression */: return emitPartiallyEmittedExpression(node); - case 355 /* CommaListExpression */: + case 356 /* CommaListExpression */: return emitCommaList(node); - case 356 /* SyntheticReferenceExpression */: + case 357 /* SyntheticReferenceExpression */: return Debug.fail("SyntheticReferenceExpression should not be printed"); } } @@ -121109,15 +121844,88 @@ function createPrinter(printerOptions = {}, handlers = {}) { return false; } function parenthesizeExpressionForNoAsi(node) { - if (!commentsDisabled && isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) { - const parseNode = getParseTreeNode(node); - if (parseNode && isParenthesizedExpression(parseNode)) { - const parens = factory.createParenthesizedExpression(node.expression); - setOriginalNode(parens, node); - setTextRange(parens, parseNode); - return parens; + if (!commentsDisabled) { + switch (node.kind) { + case 355 /* PartiallyEmittedExpression */: + if (willEmitLeadingNewLine(node)) { + const parseNode = getParseTreeNode(node); + if (parseNode && isParenthesizedExpression(parseNode)) { + const parens = factory.createParenthesizedExpression(node.expression); + setOriginalNode(parens, node); + setTextRange(parens, parseNode); + return parens; + } + return factory.createParenthesizedExpression(node); + } + return factory.updatePartiallyEmittedExpression( + node, + parenthesizeExpressionForNoAsi(node.expression) + ); + case 211 /* PropertyAccessExpression */: + return factory.updatePropertyAccessExpression( + node, + parenthesizeExpressionForNoAsi(node.expression), + node.name + ); + case 212 /* ElementAccessExpression */: + return factory.updateElementAccessExpression( + node, + parenthesizeExpressionForNoAsi(node.expression), + node.argumentExpression + ); + case 213 /* CallExpression */: + return factory.updateCallExpression( + node, + parenthesizeExpressionForNoAsi(node.expression), + node.typeArguments, + node.arguments + ); + case 215 /* TaggedTemplateExpression */: + return factory.updateTaggedTemplateExpression( + node, + parenthesizeExpressionForNoAsi(node.tag), + node.typeArguments, + node.template + ); + case 225 /* PostfixUnaryExpression */: + return factory.updatePostfixUnaryExpression( + node, + parenthesizeExpressionForNoAsi(node.operand) + ); + case 226 /* BinaryExpression */: + return factory.updateBinaryExpression( + node, + parenthesizeExpressionForNoAsi(node.left), + node.operatorToken, + node.right + ); + case 227 /* ConditionalExpression */: + return factory.updateConditionalExpression( + node, + parenthesizeExpressionForNoAsi(node.condition), + node.questionToken, + node.whenTrue, + node.colonToken, + node.whenFalse + ); + case 234 /* AsExpression */: + return factory.updateAsExpression( + node, + parenthesizeExpressionForNoAsi(node.expression), + node.type + ); + case 238 /* SatisfiesExpression */: + return factory.updateSatisfiesExpression( + node, + parenthesizeExpressionForNoAsi(node.expression), + node.type + ); + case 235 /* NonNullExpression */: + return factory.updateNonNullExpression( + node, + parenthesizeExpressionForNoAsi(node.expression) + ); } - return factory.createParenthesizedExpression(node); } return node; } @@ -124053,7 +124861,7 @@ var WatchLogLevel = /* @__PURE__ */ ((WatchLogLevel2) => { WatchLogLevel2[WatchLogLevel2["Verbose"] = 2] = "Verbose"; return WatchLogLevel2; })(WatchLogLevel || {}); -function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) { +function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo) { setSysLog(watchLogLevel === 2 /* Verbose */ ? log : noop); const plainInvokeFactory = { watchFile: (file, callback, pollingInterval, options) => host.watchFile(file, callback, pollingInterval, options), @@ -124091,23 +124899,23 @@ function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) { return typeof host.useCaseSensitiveFileNames === "boolean" ? host.useCaseSensitiveFileNames : host.useCaseSensitiveFileNames(); } function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) { - log(`ExcludeWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`); + log(`ExcludeWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`); return { - close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`) + close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`) }; } function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { - log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`); + log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`); const watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2); return { close: () => { - log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`); + log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`); watcher.close(); } }; } function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { - const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`; + const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`; log(watchInfo); const start = timestamp(); const watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2); @@ -124115,7 +124923,7 @@ function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) { log(`Elapsed:: ${elapsed}ms ${watchInfo}`); return { close: () => { - const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`; + const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`; log(watchInfo2); const start2 = timestamp(); watcher.close(); @@ -124130,7 +124938,7 @@ function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) { void 0, file, (...args) => { - const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`; + const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`; log(triggerredInfo); const start = timestamp(); cb.call( @@ -124147,8 +124955,8 @@ function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) { detailInfo2 ); } - function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3) { - return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo3 ? getDetailWatchInfo3(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`; + function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2) { + return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo2 ? getDetailWatchInfo2(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`; } } function getFallbackOptions(options) { @@ -124175,7 +124983,7 @@ function resolveTripleslashReference(moduleName, containingFile) { } function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) { let commonPathComponents; - const failed = forEach(fileNames, (sourceFile) => { + const failed2 = forEach(fileNames, (sourceFile) => { const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory); sourcePathComponents.pop(); if (!commonPathComponents) { @@ -124196,7 +125004,7 @@ function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, ge commonPathComponents.length = sourcePathComponents.length; } }); - if (failed) { + if (failed2) { return ""; } if (!commonPathComponents) { @@ -124712,15 +125520,22 @@ function forEachProjectReference(projectReferences, resolvedProjectReferences, c const result = cbRef(projectReferences2, parent2); if (result) return result; } - return forEach(resolvedProjectReferences2, (resolvedRef, index) => { - if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) { - return void 0; + let skipChildren; + return forEach( + resolvedProjectReferences2, + (resolvedRef, index) => { + if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) { + (skipChildren ?? (skipChildren = /* @__PURE__ */ new Set())).add(resolvedRef); + return void 0; + } + const result = cbResolvedRef(resolvedRef, parent2, index); + if (result || !resolvedRef) return result; + (seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path); } - const result = cbResolvedRef(resolvedRef, parent2, index); - if (result || !resolvedRef) return result; - (seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path); - return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef); - }); + ) || forEach( + resolvedProjectReferences2, + (resolvedRef) => resolvedRef && !(skipChildren == null ? void 0 : skipChildren.has(resolvedRef)) ? worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef) : void 0 + ); } } var inferredTypesContainingFile = "__inferred type names__.ts"; @@ -124818,7 +125633,13 @@ function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, if (oldResolvedRef.commandLine.options.configFile !== newParsedCommandLine.options.configFile) return false; if (!arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newParsedCommandLine.fileNames)) return false; (seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef); - return !forEach(oldResolvedRef.references, (childResolvedRef, index) => !resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences[index])); + return !forEach( + oldResolvedRef.references, + (childResolvedRef, index) => !resolvedProjectReferenceUptoDate( + childResolvedRef, + oldResolvedRef.commandLine.projectReferences[index] + ) + ); } const refPath = resolveProjectReferencePath(oldRef); return !getParsedCommandLine(refPath); @@ -124946,20 +125767,20 @@ function shouldProgramCreateNewSourceFiles(program, newOptions) { if (!program) return false; return optionsHaveChanges(program.getCompilerOptions(), newOptions, sourceFileAffectingCompilerOptions); } -function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics, typeScriptVersion3) { +function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics, typeScriptVersion2) { return { rootNames, options, host, oldProgram, configFileParsingDiagnostics, - typeScriptVersion: typeScriptVersion3 + typeScriptVersion: typeScriptVersion2 }; } function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) { var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p; const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; - const { rootNames, options, configFileParsingDiagnostics, projectReferences, typeScriptVersion: typeScriptVersion3 } = createProgramOptions; + const { rootNames, options, configFileParsingDiagnostics, projectReferences, typeScriptVersion: typeScriptVersion2 } = createProgramOptions; let { oldProgram } = createProgramOptions; for (const option of commandLineOptionOfCustomType) { if (hasProperty(options, option.name)) { @@ -125093,7 +125914,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config const packageIdToSourceFile = /* @__PURE__ */ new Map(); let sourceFileToPackageName = /* @__PURE__ */ new Map(); let redirectTargetsMap = createMultiMap(); - let usesUriStyleNodeCoreModules = false; + let usesUriStyleNodeCoreModules; const filesByName = /* @__PURE__ */ new Map(); let missingFileNames = /* @__PURE__ */ new Map(); const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? /* @__PURE__ */ new Map() : void 0; @@ -125338,7 +126159,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config getCanonicalFileName, getFileIncludeReasons: () => fileReasons, structureIsReused, - writeFile: writeFile2 + writeFile: writeFile2, + getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation) }; onProgramCreateComplete(); verifyCompilerOptions(); @@ -125413,7 +126235,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config return (_a2 = resolvedTypeReferenceDirectiveNames == null ? void 0 : resolvedTypeReferenceDirectiveNames.get(file.path)) == null ? void 0 : _a2.get(typeDirectiveName, mode); } function getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(typeRef, sourceFile) { - return getResolvedTypeReferenceDirective(sourceFile, typeRef.fileName, typeRef.resolutionMode || sourceFile.impliedNodeFormat); + return getResolvedTypeReferenceDirective( + sourceFile, + typeRef.fileName, + getModeForTypeReferenceDirectiveInFile(typeRef, sourceFile) + ); } function forEachResolvedModule(callback, file) { forEachResolution(resolvedModules, callback, file); @@ -125800,10 +126626,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config const moduleNames = getModuleNames(newSourceFile); const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile); (resolvedModulesProcessing ?? (resolvedModulesProcessing = /* @__PURE__ */ new Map())).set(newSourceFile.path, resolutions); + const optionsForFile = getCompilerOptionsForFile(newSourceFile); const resolutionsChanged = hasChangesInResolutions( moduleNames, resolutions, - (name) => oldProgram.getResolvedModule(newSourceFile, name.text, getModeForUsageLocation2(newSourceFile, name)), + (name) => oldProgram.getResolvedModule(newSourceFile, name.text, getModeForUsageLocationWorker(newSourceFile, name, optionsForFile)), moduleResolutionIsEqualTo ); if (resolutionsChanged) structureIsReused = 1 /* SafeModules */; @@ -125813,7 +126640,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config const typeReferenceResolutionsChanged = hasChangesInResolutions( typesReferenceDirectives, typeReferenceResolutions, - (name) => oldProgram.getResolvedTypeReferenceDirective(newSourceFile, getTypeReferenceResolutionName(name), getModeForFileReference(name, newSourceFile.impliedNodeFormat)), + (name) => oldProgram.getResolvedTypeReferenceDirective( + newSourceFile, + getTypeReferenceResolutionName(name), + getModeForTypeReferenceDirectiveInFile(name, newSourceFile) + ), typeDirectiveIsEqualTo ); if (typeReferenceResolutionsChanged) structureIsReused = 1 /* SafeModules */; @@ -125904,7 +126735,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config getFileIncludeReasons: program.getFileIncludeReasons, createHash: maybeBind(host, host.createHash), getModuleResolutionCache: () => program.getModuleResolutionCache(), - trace: maybeBind(host, host.trace) + trace: maybeBind(host, host.trace), + getGlobalTypingsCacheLocation: program.getGlobalTypingsCacheLocation }; } function writeFile2(fileName, text, writeByteOrderMark, onError, sourceFiles, data) { @@ -126201,6 +127033,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config diagnostics.push(createDiagnosticForNode2(node, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")); return "skip"; } + // falls through case 173 /* MethodSignature */: case 176 /* Constructor */: case 177 /* GetAccessor */: @@ -126332,6 +127165,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)); return "skip"; } + // falls through case 243 /* VariableStatement */: if (nodes === parent2.modifiers) { checkModifiers(parent2.modifiers, parent2.kind === 243 /* VariableStatement */); @@ -126374,6 +127208,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config if (isConstValid) { continue; } + // to report error, + // falls through case 125 /* PublicKeyword */: case 123 /* PrivateKeyword */: case 124 /* ProtectedKeyword */: @@ -126385,6 +127221,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config case 147 /* OutKeyword */: diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind))); break; + // These are all legal modifiers. case 126 /* StaticKeyword */: case 95 /* ExportKeyword */: case 90 /* DefaultKeyword */: @@ -126498,7 +127335,21 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config ); } if (file.flags & 4194304 /* PossiblyContainsDynamicImport */ || isJavaScriptFile) { - collectDynamicImportOrRequireOrJsDocImportCalls(file); + forEachDynamicImportOrRequireCall( + file, + /*includeTypeSpaceImports*/ + true, + /*requireStringLiteralLikeArgument*/ + true, + (node, moduleSpecifier) => { + setParentRecursive( + node, + /*incremental*/ + false + ); + imports = append(imports, moduleSpecifier); + } + ); } file.imports = imports || emptyArray; file.moduleAugmentations = moduleAugmentations || emptyArray; @@ -126515,7 +127366,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config ); imports = append(imports, moduleNameExpr); if (!usesUriStyleNodeCoreModules && currentNodeModulesDepth === 0 && !file.isDeclarationFile) { - usesUriStyleNodeCoreModules = startsWith(moduleNameExpr.text, "node:"); + if (startsWith(moduleNameExpr.text, "node:") && !exclusivelyPrefixedNodeCoreModules.has(moduleNameExpr.text)) { + usesUriStyleNodeCoreModules = true; + } else if (usesUriStyleNodeCoreModules === void 0 && unprefixedNodeCoreModules.has(moduleNameExpr.text)) { + usesUriStyleNodeCoreModules = false; + } } } } else if (isModuleDeclaration(node)) { @@ -126542,63 +127397,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config } } } - function collectDynamicImportOrRequireOrJsDocImportCalls(file2) { - const r = /import|require/g; - while (r.exec(file2.text) !== null) { - const node = getNodeAtPosition(file2, r.lastIndex); - if (isJavaScriptFile && isRequireCall( - node, - /*requireStringLiteralLikeArgument*/ - true - )) { - setParentRecursive( - node, - /*incremental*/ - false - ); - imports = append(imports, node.arguments[0]); - } else if (isImportCall(node) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) { - setParentRecursive( - node, - /*incremental*/ - false - ); - imports = append(imports, node.arguments[0]); - } else if (isLiteralImportTypeNode(node)) { - setParentRecursive( - node, - /*incremental*/ - false - ); - imports = append(imports, node.argument.literal); - } else if (isJavaScriptFile && isJSDocImportTag(node)) { - const moduleNameExpr = getExternalModuleName(node); - if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text) { - setParentRecursive( - node, - /*incremental*/ - false - ); - imports = append(imports, moduleNameExpr); - } - } - } - } - function getNodeAtPosition(sourceFile, position) { - let current = sourceFile; - const getContainingChild = (child) => { - if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) { - return child; - } - }; - while (true) { - const child = isJavaScriptFile && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild); - if (!child) { - return current; - } - current = child; - } - } } function getLibFileFromReference(ref) { var _a2; @@ -126964,8 +127762,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config const ref = file.typeReferenceDirectives[index]; const resolvedTypeReferenceDirective = resolutions[index]; const fileName = ref.fileName; - resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective); - const mode = ref.resolutionMode || getDefaultResolutionModeForFile2(file); + const mode = getModeForTypeReferenceDirectiveInFile(ref, file); + resolutionsInFile.set(fileName, mode, resolvedTypeReferenceDirective); processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index }); } } @@ -127242,11 +128040,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config } } const outputFile = options.outFile; - if (options.tsBuildInfoFile) { - if (!canEmitTsBuildInfo(options)) { - createDiagnosticForOptionName(Diagnostics.Option_tsBuildInfoFile_cannot_be_specified_without_specifying_option_incremental_or_composite_or_if_not_running_tsc_b, "tsBuildInfoFile"); - } - } else if (options.incremental && !outputFile && !options.configFilePath) { + if (!options.tsBuildInfoFile && options.incremental && !outputFile && !options.configFilePath) { programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified)); } verifyDeprecatedCompilerOptions(); @@ -127427,7 +128221,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config createDiagnosticForOptionName(Diagnostics.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax"); } } - if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly)) { + if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly || options.rewriteRelativeImportExtensions)) { createOptionValueDiagnostic("allowImportingTsExtensions", Diagnostics.Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set); } const moduleResolution = getEmitModuleResolutionKind(options); @@ -127497,7 +128291,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config function checkDeprecations(deprecatedIn, removedIn, createDiagnostic, fn) { const deprecatedInVersion = new Version(deprecatedIn); const removedInVersion = new Version(removedIn); - const typescriptVersion = new Version(typeScriptVersion3 || versionMajorMinor); + const typescriptVersion = new Version(typeScriptVersion2 || versionMajorMinor); const ignoreDeprecationsVersion = getIgnoreDeprecationsVersion(); const mustBeRemoved = !(removedInVersion.compareTo(typescriptVersion) === 1 /* GreaterThan */); const canBeSilenced = !mustBeRemoved && ignoreDeprecationsVersion.compareTo(deprecatedInVersion) === -1 /* LessThan */; @@ -127754,7 +128548,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config case 1 /* SourceFromProjectReference */: case 2 /* OutputFromProjectReference */: const referencedResolvedRef = Debug.checkDefined(resolvedProjectReferences == null ? void 0 : resolvedProjectReferences[reason.index]); - const referenceInfo = forEachProjectReference(projectReferences, resolvedProjectReferences, (resolvedRef, parent2, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent2 == null ? void 0 : parent2.sourceFile) || options.configFile, index: index2 } : void 0); + const referenceInfo = forEachProjectReference( + projectReferences, + resolvedProjectReferences, + (resolvedRef, parent2, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent2 == null ? void 0 : parent2.sourceFile) || options.configFile, index: index2 } : void 0 + ); if (!referenceInfo) return void 0; const { sourceFile, index } = referenceInfo; const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0); @@ -127789,27 +128587,31 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config } function verifyProjectReferences() { const buildInfoPath = !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : void 0; - forEachProjectReference(projectReferences, resolvedProjectReferences, (resolvedRef, parent2, index) => { - const ref = (parent2 ? parent2.commandLine.projectReferences : projectReferences)[index]; - const parentFile = parent2 && parent2.sourceFile; - verifyDeprecatedProjectReference(ref, parentFile, index); - if (!resolvedRef) { - createDiagnosticForReference(parentFile, index, Diagnostics.File_0_not_found, ref.path); - return; - } - const options2 = resolvedRef.commandLine.options; - if (!options2.composite || options2.noEmit) { - const inputs = parent2 ? parent2.commandLine.fileNames : rootNames; - if (inputs.length) { - if (!options2.composite) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path); - if (options2.noEmit) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path); + forEachProjectReference( + projectReferences, + resolvedProjectReferences, + (resolvedRef, parent2, index) => { + const ref = (parent2 ? parent2.commandLine.projectReferences : projectReferences)[index]; + const parentFile = parent2 && parent2.sourceFile; + verifyDeprecatedProjectReference(ref, parentFile, index); + if (!resolvedRef) { + createDiagnosticForReference(parentFile, index, Diagnostics.File_0_not_found, ref.path); + return; + } + const options2 = resolvedRef.commandLine.options; + if (!options2.composite || options2.noEmit) { + const inputs = parent2 ? parent2.commandLine.fileNames : rootNames; + if (inputs.length) { + if (!options2.composite) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path); + if (options2.noEmit) createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path); + } + } + if (!parent2 && buildInfoPath && buildInfoPath === getTsBuildInfoEmitOutputFilePath(options2)) { + createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path); + hasEmitBlockingDiagnostics.set(toPath3(buildInfoPath), true); } } - if (!parent2 && buildInfoPath && buildInfoPath === getTsBuildInfoEmitOutputFilePath(options2)) { - createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path); - hasEmitBlockingDiagnostics.set(toPath3(buildInfoPath), true); - } - }); + ); } function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, ...args) { let needCompilerDiagnostic = true; @@ -128005,6 +128807,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config function shouldTransformImportCall(sourceFile) { return shouldTransformImportCallWorker(sourceFile, getCompilerOptionsForFile(sourceFile)); } + function getModeForTypeReferenceDirectiveInFile(ref, sourceFile) { + return ref.resolutionMode || getDefaultResolutionModeForFile2(sourceFile); + } } function shouldTransformImportCallWorker(sourceFile, options) { const moduleKind = getEmitModuleKind(options); @@ -130262,6 +131067,9 @@ function canWatchDirectoryOrFile(pathComponents2, length2) { const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2); return length2 > perceivedOsRootLength + 1; } +function canWatchDirectoryOrFilePath(path) { + return canWatchDirectoryOrFile(getPathComponents(path)); +} function canWatchAtTypes(atTypes) { return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes)); } @@ -130273,12 +131081,12 @@ function isInDirectoryPath(dirComponents, fileOrDirComponents) { return true; } function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath) { - return canWatchDirectoryOrFile(getPathComponents(fileOrDirPath)); + return canWatchDirectoryOrFilePath(fileOrDirPath); } function canWatchAffectingLocation(filePath) { return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(filePath); } -function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, getCurrentDirectory, preferNonRecursiveWatch) { +function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, isRootWatchable, getCurrentDirectory, preferNonRecursiveWatch) { const failedLookupPathComponents = getPathComponents(failedLookupLocationPath); failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory()); const failedLookupComponents = getPathComponents(failedLookupLocation); @@ -130287,7 +131095,7 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo const nodeModulesIndex = failedLookupPathComponents.indexOf("node_modules"); if (nodeModulesIndex !== -1 && nodeModulesIndex + 1 <= perceivedOsRootLength + 1) return void 0; const lastNodeModulesIndex = failedLookupPathComponents.lastIndexOf("node_modules"); - if (isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) { + if (isRootWatchable && isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) { if (failedLookupPathComponents.length > rootPathComponents.length + 1) { return getDirectoryOfFailedLookupWatch( failedLookupComponents, @@ -130359,9 +131167,9 @@ function getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, lengt packageDirPath: packageDirLength !== void 0 ? getPathFromPathComponents(dirPathComponents, packageDirLength) : void 0 }; } -function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, getCurrentDirectory, preferNonRecursiveWatch, filterCustomPath) { +function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, isRootWatchable, getCurrentDirectory, preferNonRecursiveWatch, filterCustomPath) { const typeRootPathComponents = getPathComponents(typeRootPath); - if (isInDirectoryPath(rootPathComponents, typeRootPathComponents)) { + if (isRootWatchable && isInDirectoryPath(rootPathComponents, typeRootPathComponents)) { return rootPath; } typeRoot = isRootedDiskPath(typeRoot) ? normalizePath(typeRoot) : getNormalizedAbsolutePath(typeRoot, getCurrentDirectory()); @@ -130402,10 +131210,10 @@ function createModuleResolutionLoaderUsingGlobalCache(containingFile, redirected function resolveModuleNameUsingGlobalCache(resolutionHost, moduleResolutionCache, moduleName, containingFile, compilerOptions, redirectedReference, mode) { const host = getModuleResolutionHost(resolutionHost); const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode); - if (!resolutionHost.getGlobalCache) { + if (!resolutionHost.getGlobalTypingsCacheLocation) { return primaryResult; } - const globalCache = resolutionHost.getGlobalCache(); + const globalCache = resolutionHost.getGlobalTypingsCacheLocation(); if (globalCache !== void 0 && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) { const { resolvedModule, failedLookupLocations, affectingLocations, resolutionDiagnostics } = loadModuleFromGlobalCache( Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), @@ -130469,6 +131277,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory); const rootPath = resolutionHost.toPath(rootDir); const rootPathComponents = getPathComponents(rootPath); + const isRootWatchable = canWatchDirectoryOrFile(rootPathComponents); const isSymlinkCache = /* @__PURE__ */ new Map(); const packageDirWatchers = /* @__PURE__ */ new Map(); const dirPathToSymlinkPackageRefCount = /* @__PURE__ */ new Map(); @@ -130880,6 +131689,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW rootDir, rootPath, rootPathComponents, + isRootWatchable, getCurrentDirectory, resolutionHost.preferNonRecursiveWatch ); @@ -131068,6 +131878,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW rootDir, rootPath, rootPathComponents, + isRootWatchable, getCurrentDirectory, resolutionHost.preferNonRecursiveWatch ); @@ -131211,6 +132022,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW return false; } (failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath); + (startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath); const packagePath = parseNodeModuleFromPath( fileOrDirectoryPath, /*isFolder*/ @@ -131292,6 +132104,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW resolutionHost.toPath(typeRoot), rootPath, rootPathComponents, + isRootWatchable, getCurrentDirectory, resolutionHost.preferNonRecursiveWatch, (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2) || dirPathToSymlinkPackageRefCount.has(dirPath2) @@ -131847,6 +132660,7 @@ function getSourceFileVersionAsHashFromText(host, text) { if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) { pos--; } + // falls through case 13 /* carriageReturn */: break; default: @@ -132048,6 +132862,7 @@ function createWatchProgram(host) { let updateLevel; let missingFilesMap; let watchedWildcardDirectories; + let staleWatches = /* @__PURE__ */ new Map([[void 0, void 0]]); let timerToUpdateProgram; let timerToInvalidateFailedLookupResolutions; let parsedConfigs; @@ -132136,8 +132951,6 @@ function createWatchProgram(host) { const customHasInvalidLibResolutions = host.resolveLibrary ? maybeBind(host, host.hasInvalidatedLibResolutions) || returnTrue : returnFalse; builderProgram = readBuilderProgram(compilerOptions, compilerHost); synchronizeProgram(); - watchConfigFileWildCardDirectories(); - if (configFileName) updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile); return configFileName ? { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close, getResolutionCache } : { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames, close, getResolutionCache }; function close() { clearInvalidateResolutionsOfFailedLookupLocations(); @@ -132240,6 +133053,16 @@ function createWatchProgram(host) { compilerHost.directoryExists = originalDirectoryExists; compilerHost.createDirectory = originalCreateDirectory; compilerHost.writeFile = originalWriteFile; + staleWatches == null ? void 0 : staleWatches.forEach((configFile, configPath) => { + if (!configPath) { + watchConfigFileWildCardDirectories(); + if (configFileName) updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile); + } else { + const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath); + if (config) watchReferencedProject(configFile, configPath, config); + } + }); + staleWatches = void 0; return builderProgram; } function createNewProgram(hasInvalidatedResolutions, hasInvalidatedLibResolutions) { @@ -132432,7 +133255,13 @@ function createWatchProgram(host) { Debug.assert(configFileName); updateLevel = 0 /* Update */; rootFileNames = getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions); - if (updateErrorForNoInputFiles(rootFileNames, getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) { + if (updateErrorForNoInputFiles( + rootFileNames, + getNormalizedAbsolutePath(configFileName, currentDirectory), + compilerOptions.configFile.configFileSpecs, + configFileParsingDiagnostics, + canConfigFileJsonReportNoInputFiles + )) { hasChangedConfigFileParsingErrors = true; } synchronizeProgram(); @@ -132446,9 +133275,8 @@ function createWatchProgram(host) { } parseConfigFile2(); hasChangedCompilerOptions = true; + (staleWatches ?? (staleWatches = /* @__PURE__ */ new Map())).set(void 0, void 0); synchronizeProgram(); - watchConfigFileWildCardDirectories(); - updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile); } function parseConfigFile2() { Debug.assert(configFileName); @@ -132500,7 +133328,7 @@ function createWatchProgram(host) { } else { (parsedConfigs || (parsedConfigs = /* @__PURE__ */ new Map())).set(configPath, config = { parsedCommandLine }); } - watchReferencedProject(configFileName2, configPath, config); + (staleWatches ?? (staleWatches = /* @__PURE__ */ new Map())).set(configPath, configFileName2); return parsedCommandLine; } function getParsedCommandLineFromConfigFileHost(configFileName2) { @@ -133384,6 +134212,7 @@ function createBuildOrUpdateInvalidedProject(state, project, projectPath, projec queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult)); step++; break; + // Should never be done case 3 /* Done */: default: assertType(step); @@ -133419,7 +134248,13 @@ function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) { watchPackageJsonFiles(state, project, projectPath, config); } else if (updateLevel === 1 /* RootNamesAndUpdate */) { config.fileNames = getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, getDirectoryPath(project), config.options, state.parseConfigFileHost); - updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, canJsonReportNoInputFiles(config.raw)); + updateErrorForNoInputFiles( + config.fileNames, + project, + config.options.configFile.configFileSpecs, + config.errors, + canJsonReportNoInputFiles(config.raw) + ); watchInputFiles(state, project, projectPath, config); watchPackageJsonFiles(state, project, projectPath, config); } @@ -133600,11 +134435,7 @@ function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, } function getUpToDateStatusWorker(state, project, resolvedPath) { var _a, _b, _c, _d, _e; - if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) { - return { - type: 16 /* ContainerOnly */ - }; - } + if (isSolutionConfig(project)) return { type: 16 /* ContainerOnly */ }; let referenceStatuses; const force = !!state.options.force; if (project.projectReferences) { @@ -133924,6 +134755,7 @@ function queueReferencingProjects(state, project, projectPath, projectIndex, con status.type = 2 /* UpToDateWithUpstreamTypes */; break; } + // falls through case 15 /* UpToDateWithInputFileText */: case 2 /* UpToDateWithUpstreamTypes */: if (!(buildResult & 2 /* DeclarationOutputUnchanged */)) { @@ -134441,6 +135273,8 @@ function reportUpToDateStatus(state, configFileName, status) { relName(state, configFileName) ); case 16 /* ContainerOnly */: + // Don't report status on "solution" projects + // falls through case 13 /* ComputingUpstream */: break; default: @@ -134513,7 +135347,7 @@ function shouldBePretty(sys2, options) { return options.pretty; } function getOptionsForHelp(commandLine) { - return !!commandLine.options.all ? toSorted(optionDeclarations, (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.slice(), (v) => !!v.showInSimplifiedHelpView); + return !!commandLine.options.all ? toSorted(optionDeclarations.concat(tscBuildOption), (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.concat(tscBuildOption), (v) => !!v.showInSimplifiedHelpView); } function printVersion(sys2) { sys2.write(getDiagnosticText(Diagnostics.Version_0, version) + sys2.newLine); @@ -134837,7 +135671,7 @@ function printAllHelp(sys2, compilerOptions, buildOptions, watchOptions) { output = [...output, ...generateSectionOptionsOutput( sys2, getDiagnosticText(Diagnostics.BUILD_OPTIONS), - buildOptions, + filter(buildOptions, (option) => option !== tscBuildOption), /*subCategory*/ false, formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds") @@ -134851,7 +135685,7 @@ function printBuildHelp(sys2, buildOptions) { output = [...output, ...generateSectionOptionsOutput( sys2, getDiagnosticText(Diagnostics.BUILD_OPTIONS), - buildOptions, + filter(buildOptions, (option) => option !== tscBuildOption), /*subCategory*/ false, formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds") @@ -134888,10 +135722,6 @@ function printHelp(sys2, commandLine) { } function executeCommandLineWorker(sys2, cb, commandLine) { let reportDiagnostic = createDiagnosticReporter(sys2); - if (commandLine.options.build) { - reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_build_must_be_the_first_command_line_argument)); - return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */); - } let configFileName; if (commandLine.options.locale) { validateLocaleAndSetLanguage(commandLine.options.locale, sys2, commandLine.errors); @@ -135037,16 +135867,16 @@ function executeCommandLineWorker(sys2, cb, commandLine) { } } } -function isBuild(commandLineArgs) { +function isBuildCommand(commandLineArgs) { if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === 45 /* minus */) { const firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase(); - return firstOption === "build" || firstOption === "b"; + return firstOption === tscBuildOption.name || firstOption === tscBuildOption.shortName; } return false; } function executeCommandLine(system, cb, commandLineArgs) { - if (isBuild(commandLineArgs)) { - const { buildOptions, watchOptions, projects, errors } = parseBuildCommand(commandLineArgs.slice(1)); + if (isBuildCommand(commandLineArgs)) { + const { buildOptions, watchOptions, projects, errors } = parseBuildCommand(commandLineArgs); if (buildOptions.generateCpuProfile && system.enableCPUProfiler) { system.enableCPUProfiler(buildOptions.generateCpuProfile, () => performBuild( system, @@ -135558,39 +136388,518 @@ function writeConfigFile(sys2, reportDiagnostic, options, fileNames) { } // src/compiler/expressionToTypeNode.ts +function syntacticResult(type, reportFallback = true) { + return { type, reportFallback }; +} +var notImplemented2 = syntacticResult( + /*type*/ + void 0, + /*reportFallback*/ + false +); +var alreadyReported = syntacticResult( + /*type*/ + void 0, + /*reportFallback*/ + false +); +var failed = syntacticResult( + /*type*/ + void 0, + /*reportFallback*/ + true +); function createSyntacticTypeNodeBuilder(options, resolver) { const strictNullChecks = getStrictOptionValue(options, "strictNullChecks"); return { - typeFromExpression, serializeTypeOfDeclaration, serializeReturnTypeForSignature, - serializeTypeOfExpression + serializeTypeOfExpression, + serializeTypeOfAccessor, + tryReuseExistingTypeNode(context, existing) { + if (!resolver.canReuseTypeNode(context, existing)) { + return void 0; + } + return tryReuseExistingTypeNode(context, existing); + } }; - function serializeExistingTypeAnnotation(type, addUndefined) { - return type !== void 0 && (!addUndefined || type && canAddUndefined(type)) ? true : void 0; + function reuseNode(context, node, range = node) { + return node === void 0 ? void 0 : resolver.markNodeReuse(context, node.flags & 16 /* Synthesized */ ? node : factory.cloneNode(node), range ?? node); + } + function tryReuseExistingTypeNode(context, existing) { + const { finalizeBoundary, startRecoveryScope, hadError, markError } = resolver.createRecoveryBoundary(context); + const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode); + if (!finalizeBoundary()) { + return void 0; + } + context.approximateLength += existing.end - existing.pos; + return transformed; + function visitExistingNodeTreeSymbols(node) { + if (hadError()) return node; + const recover = startRecoveryScope(); + const onExitNewScope = isNewScopeNode(node) ? resolver.enterNewScope(context, node) : void 0; + const result = visitExistingNodeTreeSymbolsWorker(node); + onExitNewScope == null ? void 0 : onExitNewScope(); + if (hadError()) { + if (isTypeNode(node) && !isTypePredicateNode(node)) { + recover(); + return resolver.serializeExistingTypeNode(context, node); + } + return node; + } + return result ? resolver.markNodeReuse(context, result, node) : void 0; + } + function tryVisitSimpleTypeNode(node) { + const innerNode = skipTypeParentheses(node); + switch (innerNode.kind) { + case 183 /* TypeReference */: + return tryVisitTypeReference(innerNode); + case 186 /* TypeQuery */: + return tryVisitTypeQuery(innerNode); + case 199 /* IndexedAccessType */: + return tryVisitIndexedAccess(innerNode); + case 198 /* TypeOperator */: + const typeOperatorNode = innerNode; + if (typeOperatorNode.operator === 143 /* KeyOfKeyword */) { + return tryVisitKeyOf(typeOperatorNode); + } + } + return visitNode(node, visitExistingNodeTreeSymbols, isTypeNode); + } + function tryVisitIndexedAccess(node) { + const resultObjectType = tryVisitSimpleTypeNode(node.objectType); + if (resultObjectType === void 0) { + return void 0; + } + return factory.updateIndexedAccessTypeNode(node, resultObjectType, visitNode(node.indexType, visitExistingNodeTreeSymbols, isTypeNode)); + } + function tryVisitKeyOf(node) { + Debug.assertEqual(node.operator, 143 /* KeyOfKeyword */); + const type = tryVisitSimpleTypeNode(node.type); + if (type === void 0) { + return void 0; + } + return factory.updateTypeOperatorNode(node, type); + } + function tryVisitTypeQuery(node) { + const { introducesError, node: exprName } = resolver.trackExistingEntityName(context, node.exprName); + if (!introducesError) { + return factory.updateTypeQueryNode( + node, + exprName, + visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode) + ); + } + const serializedName = resolver.serializeTypeName( + context, + node.exprName, + /*isTypeOf*/ + true + ); + if (serializedName) { + return resolver.markNodeReuse(context, serializedName, node.exprName); + } + } + function tryVisitTypeReference(node) { + if (resolver.canReuseTypeNode(context, node)) { + const { introducesError, node: newName } = resolver.trackExistingEntityName(context, node.typeName); + const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode); + if (!introducesError) { + const updated = factory.updateTypeReferenceNode( + node, + newName, + typeArguments + ); + return resolver.markNodeReuse(context, updated, node); + } else { + const serializedName = resolver.serializeTypeName( + context, + node.typeName, + /*isTypeOf*/ + false, + typeArguments + ); + if (serializedName) { + return resolver.markNodeReuse(context, serializedName, node.typeName); + } + } + } + } + function visitExistingNodeTreeSymbolsWorker(node) { + var _a; + if (isJSDocTypeExpression(node)) { + return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode); + } + if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) { + return factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + if (isJSDocUnknownType(node)) { + return factory.createKeywordTypeNode(159 /* UnknownKeyword */); + } + if (isJSDocNullableType(node)) { + return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createLiteralTypeNode(factory.createNull())]); + } + if (isJSDocOptionalType(node)) { + return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); + } + if (isJSDocNonNullableType(node)) { + return visitNode(node.type, visitExistingNodeTreeSymbols); + } + if (isJSDocVariadicType(node)) { + return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode)); + } + if (isJSDocTypeLiteral(node)) { + return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => { + const name = visitNode(isIdentifier(t.name) ? t.name : t.name.right, visitExistingNodeTreeSymbols, isIdentifier); + const overrideTypeNode = resolver.getJsDocPropertyOverride(context, node, t); + return factory.createPropertySignature( + /*modifiers*/ + void 0, + name, + t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(58 /* QuestionToken */) : void 0, + overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) + ); + })); + } + if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") { + return setOriginalNode(factory.createKeywordTypeNode(133 /* AnyKeyword */), node); + } + if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) { + return factory.createTypeLiteralNode([factory.createIndexSignature( + /*modifiers*/ + void 0, + [factory.createParameterDeclaration( + /*modifiers*/ + void 0, + /*dotDotDotToken*/ + void 0, + "x", + /*questionToken*/ + void 0, + visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols, isTypeNode) + )], + visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols, isTypeNode) + )]); + } + if (isJSDocFunctionType(node)) { + if (isJSDocConstructSignature(node)) { + let newTypeNode; + return factory.createConstructorTypeNode( + /*modifiers*/ + void 0, + visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration), + mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration( + /*modifiers*/ + void 0, + getEffectiveDotDotDotForParameter(p), + resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p), + factory.cloneNode(p.questionToken), + visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode), + /*initializer*/ + void 0 + )), + visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) + ); + } else { + return factory.createFunctionTypeNode( + visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration), + map(node.parameters, (p, i) => factory.createParameterDeclaration( + /*modifiers*/ + void 0, + getEffectiveDotDotDotForParameter(p), + resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p), + factory.cloneNode(p.questionToken), + visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode), + /*initializer*/ + void 0 + )), + visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */) + ); + } + } + if (isThisTypeNode(node)) { + if (resolver.canReuseTypeNode(context, node)) { + return node; + } + markError(); + return node; + } + if (isTypeParameterDeclaration(node)) { + const { node: newName } = resolver.trackExistingEntityName(context, node.name); + return factory.updateTypeParameterDeclaration( + node, + visitNodes2(node.modifiers, visitExistingNodeTreeSymbols, isModifier), + // resolver.markNodeReuse(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node), + newName, + visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode), + visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode) + ); + } + if (isIndexedAccessTypeNode(node)) { + const result = tryVisitIndexedAccess(node); + if (!result) { + markError(); + return node; + } + return result; + } + if (isTypeReferenceNode(node)) { + const result = tryVisitTypeReference(node); + if (result) { + return result; + } + markError(); + return node; + } + if (isLiteralImportTypeNode(node)) { + if (((_a = node.attributes) == null ? void 0 : _a.token) === 132 /* AssertKeyword */) { + markError(); + return node; + } + if (!resolver.canReuseTypeNode(context, node)) { + return resolver.serializeExistingTypeNode(context, node); + } + return factory.updateImportTypeNode( + node, + factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)), + visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes), + visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName), + visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode), + node.isTypeOf + ); + } + if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !resolver.hasLateBindableName(node)) { + if (!hasDynamicName(node)) { + return visitEachChild2(node, visitExistingNodeTreeSymbols); + } + if (resolver.shouldRemoveDeclaration(context, node)) { + return void 0; + } + } + if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) { + let visited = visitEachChild2(node, visitExistingNodeTreeSymbols); + if (visited === node) { + visited = resolver.markNodeReuse(context, factory.cloneNode(node), node); + } + visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */); + if (isParameter(node)) { + visited.modifiers = void 0; + } + return visited; + } + if (isTypeQueryNode(node)) { + const result = tryVisitTypeQuery(node); + if (!result) { + markError(); + return node; + } + return result; + } + if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) { + const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.expression); + if (!introducesError) { + return factory.updateComputedPropertyName(node, result); + } else { + const computedPropertyNameType = resolver.serializeTypeOfExpression(context, node.expression); + let literal; + if (isLiteralTypeNode(computedPropertyNameType)) { + literal = computedPropertyNameType.literal; + } else { + const evaluated = resolver.evaluateEntityNameExpression(node.expression); + const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral( + evaluated.value, + /*isSingleQuote*/ + void 0 + ) : typeof evaluated.value === "number" ? factory.createNumericLiteral( + evaluated.value, + /*numericLiteralFlags*/ + 0 + ) : void 0; + if (!literalNode) { + if (isImportTypeNode(computedPropertyNameType)) { + resolver.trackComputedName(context, node.expression); + } + return node; + } + literal = literalNode; + } + if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(options))) { + return factory.createIdentifier(literal.text); + } + if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) { + return literal; + } + return factory.updateComputedPropertyName(node, literal); + } + } + if (isTypePredicateNode(node)) { + let parameterName; + if (isIdentifier(node.parameterName)) { + const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.parameterName); + if (introducesError) markError(); + parameterName = result; + } else { + parameterName = factory.cloneNode(node.parameterName); + } + return factory.updateTypePredicateNode(node, factory.cloneNode(node.assertsModifier), parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode)); + } + if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) { + const visited = visitEachChild2(node, visitExistingNodeTreeSymbols); + const clone2 = resolver.markNodeReuse(context, visited === node ? factory.cloneNode(node) : visited, node); + const flags = getEmitFlags(clone2); + setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */)); + return clone2; + } + if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) { + const clone2 = factory.cloneNode(node); + clone2.singleQuote = true; + return clone2; + } + if (isConditionalTypeNode(node)) { + const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode); + const disposeScope = resolver.enterNewScope(context, node); + const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode); + const trueType = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode); + disposeScope(); + const falseType = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode); + return factory.updateConditionalTypeNode( + node, + checkType, + extendType, + trueType, + falseType + ); + } + if (isTypeOperatorNode(node)) { + if (node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) { + if (!resolver.canReuseTypeNode(context, node)) { + markError(); + return node; + } + } else if (node.operator === 143 /* KeyOfKeyword */) { + const result = tryVisitKeyOf(node); + if (!result) { + markError(); + return node; + } + return result; + } + } + return visitEachChild2(node, visitExistingNodeTreeSymbols); + function visitEachChild2(node2, visitor) { + const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node2); + return visitEachChild( + node2, + visitor, + /*context*/ + void 0, + nonlocalNode ? visitNodesWithoutCopyingPositions : void 0 + ); + } + function visitNodesWithoutCopyingPositions(nodes, visitor, test, start, count) { + let result = visitNodes2(nodes, visitor, test, start, count); + if (result) { + if (result.pos !== -1 || result.end !== -1) { + if (result === nodes) { + result = factory.createNodeArray(nodes.slice(), nodes.hasTrailingComma); + } + setTextRangePosEnd(result, -1, -1); + } + } + return result; + } + function getEffectiveDotDotDotForParameter(p) { + return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0); + } + function getNameForJSDocFunctionParameter(p, index) { + return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`; + } + function rewriteModuleSpecifier2(parent2, lit) { + const newName = resolver.getModuleSpecifierOverride(context, parent2, lit); + if (newName) { + return setOriginalNode(factory.createStringLiteral(newName), lit); + } + return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral); + } + } + } + function serializeExistingTypeNode(typeNode, context, addUndefined) { + if (!typeNode) return void 0; + let result; + if ((!addUndefined || canAddUndefined(typeNode)) && resolver.canReuseTypeNode(context, typeNode)) { + result = tryReuseExistingTypeNode(context, typeNode); + if (result !== void 0) { + result = addUndefinedIfNeeded( + result, + addUndefined, + /*owner*/ + void 0, + context + ); + } + } + return result; + } + function serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined, useFallback = requiresAddingUndefined !== void 0) { + if (!declaredType) return void 0; + if (!resolver.canReuseTypeNodeAnnotation(context, node, declaredType, symbol, requiresAddingUndefined)) { + if (!requiresAddingUndefined || !resolver.canReuseTypeNodeAnnotation( + context, + node, + declaredType, + symbol, + /*requiresAddingUndefined*/ + false + )) { + return void 0; + } + } + let result; + if (!requiresAddingUndefined || canAddUndefined(declaredType)) { + result = serializeExistingTypeNode(declaredType, context, requiresAddingUndefined); + } + if (result !== void 0 || !useFallback) { + return result; + } + context.tracker.reportInferenceFallback(node); + return resolver.serializeExistingTypeNode(context, declaredType, requiresAddingUndefined) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + function serializeExistingTypeNodeWithFallback(typeNode, context, addUndefined, targetNode) { + if (!typeNode) return void 0; + const result = serializeExistingTypeNode(typeNode, context, addUndefined); + if (result !== void 0) { + return result; + } + context.tracker.reportInferenceFallback(targetNode ?? typeNode); + return resolver.serializeExistingTypeNode(context, typeNode, addUndefined) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + function serializeTypeOfAccessor(accessor, symbol, context) { + return typeFromAccessor(accessor, symbol, context) ?? inferAccessorType(accessor, resolver.getAllAccessorDeclarations(accessor), context, symbol); } function serializeTypeOfExpression(expr, context, addUndefined, preserveLiterals) { - return typeFromExpression( + const result = typeFromExpression( expr, context, /*isConstContext*/ false, addUndefined, preserveLiterals - ) ?? inferExpressionType(expr, context); + ); + return result.type !== void 0 ? result.type : inferExpressionType(expr, context, result.reportFallback); } - function serializeTypeOfDeclaration(node, context) { + function serializeTypeOfDeclaration(node, symbol, context) { switch (node.kind) { - case 171 /* PropertySignature */: - return serializeExistingTypeAnnotation(getEffectiveTypeAnnotationNode(node)); case 169 /* Parameter */: - return typeFromParameter(node, context); + case 341 /* JSDocParameterTag */: + return typeFromParameter(node, symbol, context); case 260 /* VariableDeclaration */: - return typeFromVariable(node, context); + return typeFromVariable(node, symbol, context); + case 171 /* PropertySignature */: + case 348 /* JSDocPropertyTag */: case 172 /* PropertyDeclaration */: - return typeFromProperty(node, context); + return typeFromProperty(node, symbol, context); case 208 /* BindingElement */: - return inferTypeOfDeclaration(node, context); + return inferTypeOfDeclaration(node, symbol, context); case 277 /* ExportAssignment */: return serializeTypeOfExpression( node.expression, @@ -135603,17 +136912,39 @@ function createSyntacticTypeNodeBuilder(options, resolver) { case 211 /* PropertyAccessExpression */: case 212 /* ElementAccessExpression */: case 226 /* BinaryExpression */: - return serializeExistingTypeAnnotation(getEffectiveTypeAnnotationNode(node)) || inferTypeOfDeclaration(node, context); + return typeFromExpandoProperty(node, symbol, context); case 303 /* PropertyAssignment */: - return typeFromExpression(node.initializer, context) || inferTypeOfDeclaration(node, context); + case 304 /* ShorthandPropertyAssignment */: + return typeFromPropertyAssignment(node, symbol, context); default: Debug.assertNever(node, `Node needs to be an inferrable node, found ${Debug.formatSyntaxKind(node.kind)}`); } } - function serializeReturnTypeForSignature(node, context) { + function typeFromPropertyAssignment(node, symbol, context) { + const typeAnnotation = getEffectiveTypeAnnotationNode(node); + let result; + if (typeAnnotation && resolver.canReuseTypeNodeAnnotation(context, node, typeAnnotation, symbol)) { + result = serializeExistingTypeNode(typeAnnotation, context); + } + if (!result && node.kind === 303 /* PropertyAssignment */) { + const initializer = node.initializer; + const assertionNode = isJSDocTypeAssertion(initializer) ? getJSDocTypeAssertionType(initializer) : initializer.kind === 234 /* AsExpression */ || initializer.kind === 216 /* TypeAssertionExpression */ ? initializer.type : void 0; + if (assertionNode && !isConstTypeReference(assertionNode) && resolver.canReuseTypeNodeAnnotation(context, node, assertionNode, symbol)) { + result = serializeExistingTypeNode(assertionNode, context); + } + } + return result ?? inferTypeOfDeclaration( + node, + symbol, + context, + /*reportFallback*/ + false + ); + } + function serializeReturnTypeForSignature(node, symbol, context) { switch (node.kind) { case 177 /* GetAccessor */: - return typeFromAccessor(node, context); + return serializeTypeOfAccessor(node, symbol, context); case 174 /* MethodDeclaration */: case 262 /* FunctionDeclaration */: case 180 /* ConstructSignature */: @@ -135628,45 +136959,50 @@ function createSyntacticTypeNodeBuilder(options, resolver) { case 219 /* ArrowFunction */: case 317 /* JSDocFunctionType */: case 323 /* JSDocSignature */: - return createReturnFromSignature(node, context); + return createReturnFromSignature(node, symbol, context); default: Debug.assertNever(node, `Node needs to be an inferrable node, found ${Debug.formatSyntaxKind(node.kind)}`); } } - function getTypeAnnotationFromAccessor2(accessor) { + function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 177 /* GetAccessor */ ? getEffectiveReturnTypeNode(accessor) : accessor.parameters.length > 0 ? getEffectiveTypeAnnotationNode(accessor.parameters[0]) : void 0; + return accessor.kind === 177 /* GetAccessor */ ? isInJSFile(accessor) && getJSDocType(accessor) || getEffectiveReturnTypeNode(accessor) : getEffectiveSetAccessorTypeAnnotationNode(accessor); } } function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) { - let accessorType = getTypeAnnotationFromAccessor2(node); + let accessorType = getTypeAnnotationFromAccessor(node); if (!accessorType && node !== accessors.firstAccessor) { - accessorType = getTypeAnnotationFromAccessor2(accessors.firstAccessor); + accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor); } if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) { - accessorType = getTypeAnnotationFromAccessor2(accessors.secondAccessor); + accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor); } return accessorType; } - function typeFromAccessor(node, context) { + function typeFromAccessor(node, symbol, context) { const accessorDeclarations = resolver.getAllAccessorDeclarations(node); const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node, accessorDeclarations); - if (accessorType) { - return serializeExistingTypeAnnotation(accessorType); + if (accessorType && !isTypePredicateNode(accessorType)) { + return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context)); } if (accessorDeclarations.getAccessor) { - return createReturnFromSignature(accessorDeclarations.getAccessor, context); + return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature( + accessorDeclarations.getAccessor, + /*symbol*/ + void 0, + context + )); } - return false; + return void 0; } - function typeFromVariable(node, context) { + function typeFromVariable(node, symbol, context) { + var _a; const declaredType = getEffectiveTypeAnnotationNode(node); + let resultType = failed; if (declaredType) { - return serializeExistingTypeAnnotation(declaredType); - } - let resultType; - if (node.initializer) { - if (!resolver.isExpandoFunctionDeclaration(node)) { + resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol)); + } else if (node.initializer && (((_a = symbol.declarations) == null ? void 0 : _a.length) === 1 || countWhere(symbol.declarations, isVariableDeclaration) === 1)) { + if (!resolver.isExpandoFunctionDeclaration(node) && !isContextuallyTyped(node)) { resultType = typeFromExpression( node.initializer, context, @@ -135678,70 +137014,118 @@ function createSyntacticTypeNodeBuilder(options, resolver) { ); } } - return resultType ?? inferTypeOfDeclaration(node, context); + return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback); } - function typeFromParameter(node, context) { + function typeFromParameter(node, symbol, context) { const parent2 = node.parent; if (parent2.kind === 178 /* SetAccessor */) { - return typeFromAccessor(parent2, context); + return serializeTypeOfAccessor( + parent2, + /*symbol*/ + void 0, + context + ); } const declaredType = getEffectiveTypeAnnotationNode(node); - const addUndefined = resolver.requiresAddingImplicitUndefined(node, context.enclosingDeclaration); - let resultType; + const addUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration); + let resultType = failed; if (declaredType) { - resultType = serializeExistingTypeAnnotation(declaredType, addUndefined); - } else { - if (node.initializer && isIdentifier(node.name)) { - resultType = typeFromExpression( - node.initializer, - context, - /*isConstContext*/ - void 0, - addUndefined - ); - } - } - return resultType ?? inferTypeOfDeclaration(node, context); - } - function typeFromProperty(node, context) { - const declaredType = getEffectiveTypeAnnotationNode(node); - if (declaredType) { - return serializeExistingTypeAnnotation(declaredType); - } - let resultType; - if (node.initializer) { - const isReadonly = isDeclarationReadonly(node); + resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, addUndefined)); + } else if (isParameter(node) && node.initializer && isIdentifier(node.name) && !isContextuallyTyped(node)) { resultType = typeFromExpression( node.initializer, context, /*isConstContext*/ void 0, - /*requiresAddingUndefined*/ - void 0, - isReadonly + addUndefined ); } - return resultType ?? inferTypeOfDeclaration(node, context); + return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback); } - function inferTypeOfDeclaration(node, context) { - context.tracker.reportInferenceFallback(node); - return false; - } - function inferExpressionType(node, context) { - context.tracker.reportInferenceFallback(node); - return false; - } - function inferReturnTypeOfSignatureSignature(node, context) { - context.tracker.reportInferenceFallback(node); - return false; - } - function inferAccessorType(node, allAccessors, context) { - if (node.kind === 177 /* GetAccessor */) { - return createReturnFromSignature(node, context); - } else { - context.tracker.reportInferenceFallback(node); - return false; + function typeFromExpandoProperty(node, symbol, context) { + const declaredType = getEffectiveTypeAnnotationNode(node); + let result; + if (declaredType) { + result = serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol); } + const oldSuppressReportInferenceFallback = context.suppressReportInferenceFallback; + context.suppressReportInferenceFallback = true; + const resultType = result ?? inferTypeOfDeclaration( + node, + symbol, + context, + /*reportFallback*/ + false + ); + context.suppressReportInferenceFallback = oldSuppressReportInferenceFallback; + return resultType; + } + function typeFromProperty(node, symbol, context) { + const declaredType = getEffectiveTypeAnnotationNode(node); + const requiresAddingUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration); + let resultType = failed; + if (declaredType) { + resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined)); + } else { + const initializer = isPropertyDeclaration(node) ? node.initializer : void 0; + if (initializer && !isContextuallyTyped(node)) { + const isReadonly = isDeclarationReadonly(node); + resultType = typeFromExpression( + initializer, + context, + /*isConstContext*/ + void 0, + requiresAddingUndefined, + isReadonly + ); + } + } + return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback); + } + function inferTypeOfDeclaration(node, symbol, context, reportFallback = true) { + if (reportFallback) { + context.tracker.reportInferenceFallback(node); + } + if (context.noInferenceFallback === true) { + return factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + return resolver.serializeTypeOfDeclaration(context, node, symbol); + } + function inferExpressionType(node, context, reportFallback = true, requiresAddingUndefined) { + Debug.assert(!requiresAddingUndefined); + if (reportFallback) { + context.tracker.reportInferenceFallback(node); + } + if (context.noInferenceFallback === true) { + return factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + return resolver.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + function inferReturnTypeOfSignatureSignature(node, context, reportFallback) { + if (reportFallback) { + context.tracker.reportInferenceFallback(node); + } + if (context.noInferenceFallback === true) { + return factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + function inferAccessorType(node, allAccessors, context, symbol, reportFallback = true) { + if (node.kind === 177 /* GetAccessor */) { + return createReturnFromSignature(node, symbol, context, reportFallback); + } else { + if (reportFallback) { + context.tracker.reportInferenceFallback(node); + } + const result = allAccessors.getAccessor && createReturnFromSignature(allAccessors.getAccessor, symbol, context, reportFallback); + return result ?? resolver.serializeTypeOfDeclaration(context, node, symbol) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + } + function withNewScope(context, node, fn) { + const cleanup = resolver.enterNewScope(context, node); + const result = fn(); + cleanup(); + return result; } function typeFromTypeAssertion(expression, type, context, requiresAddingUndefined) { if (isConstTypeReference(type)) { @@ -135753,10 +137137,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) { requiresAddingUndefined ); } - if (requiresAddingUndefined && !canAddUndefined(type)) { - context.tracker.reportInferenceFallback(type); - } - return serializeExistingTypeAnnotation(type); + return syntacticResult(serializeExistingTypeNodeWithFallback(type, context, requiresAddingUndefined)); } function typeFromExpression(node, context, isConstContext = false, requiresAddingUndefined = false, preserveLiterals = false) { switch (node.kind) { @@ -135767,14 +137148,19 @@ function createSyntacticTypeNodeBuilder(options, resolver) { return typeFromExpression(node.expression, context, isConstContext, requiresAddingUndefined); case 80 /* Identifier */: if (resolver.isUndefinedIdentifierExpression(node)) { - return true; + return syntacticResult(createUndefinedTypeNode()); } break; case 106 /* NullKeyword */: - return true; + if (strictNullChecks) { + return syntacticResult(addUndefinedIfNeeded(factory.createLiteralTypeNode(factory.createNull()), requiresAddingUndefined, node, context)); + } else { + return syntacticResult(factory.createKeywordTypeNode(133 /* AnyKeyword */)); + } case 219 /* ArrowFunction */: case 218 /* FunctionExpression */: - return typeFromFunctionLikeExpression(node, context); + Debug.type(node); + return withNewScope(context, node, () => typeFromFunctionLikeExpression(node, context)); case 216 /* TypeAssertionExpression */: case 234 /* AsExpression */: const asExpression = node; @@ -135782,43 +137168,73 @@ function createSyntacticTypeNodeBuilder(options, resolver) { case 224 /* PrefixUnaryExpression */: const unaryExpression = node; if (isPrimitiveLiteralValue(unaryExpression)) { - if (unaryExpression.operand.kind === 10 /* BigIntLiteral */) { - return typeFromPrimitiveLiteral(); - } - if (unaryExpression.operand.kind === 9 /* NumericLiteral */) { - return typeFromPrimitiveLiteral(); - } + return typeFromPrimitiveLiteral( + unaryExpression.operator === 40 /* PlusToken */ ? unaryExpression.operand : unaryExpression, + unaryExpression.operand.kind === 10 /* BigIntLiteral */ ? 163 /* BigIntKeyword */ : 150 /* NumberKeyword */, + context, + isConstContext || preserveLiterals, + requiresAddingUndefined + ); } break; - case 9 /* NumericLiteral */: - return typeFromPrimitiveLiteral(); + case 209 /* ArrayLiteralExpression */: + return typeFromArrayLiteral(node, context, isConstContext, requiresAddingUndefined); + case 210 /* ObjectLiteralExpression */: + return typeFromObjectLiteral(node, context, isConstContext, requiresAddingUndefined); + case 231 /* ClassExpression */: + return syntacticResult(inferExpressionType( + node, + context, + /*reportFallback*/ + true, + requiresAddingUndefined + )); case 228 /* TemplateExpression */: if (!isConstContext && !preserveLiterals) { - return true; + return syntacticResult(factory.createKeywordTypeNode(154 /* StringKeyword */)); } break; - case 15 /* NoSubstitutionTemplateLiteral */: - case 11 /* StringLiteral */: - return typeFromPrimitiveLiteral(); - case 10 /* BigIntLiteral */: - return typeFromPrimitiveLiteral(); - case 112 /* TrueKeyword */: - case 97 /* FalseKeyword */: - return typeFromPrimitiveLiteral(); - case 209 /* ArrayLiteralExpression */: - return typeFromArrayLiteral(node, context, isConstContext); - case 210 /* ObjectLiteralExpression */: - return typeFromObjectLiteral(node, context, isConstContext); - case 231 /* ClassExpression */: - return inferExpressionType(node, context); + default: + let typeKind; + let primitiveNode = node; + switch (node.kind) { + case 9 /* NumericLiteral */: + typeKind = 150 /* NumberKeyword */; + break; + case 15 /* NoSubstitutionTemplateLiteral */: + primitiveNode = factory.createStringLiteral(node.text); + typeKind = 154 /* StringKeyword */; + break; + case 11 /* StringLiteral */: + typeKind = 154 /* StringKeyword */; + break; + case 10 /* BigIntLiteral */: + typeKind = 163 /* BigIntKeyword */; + break; + case 112 /* TrueKeyword */: + case 97 /* FalseKeyword */: + typeKind = 136 /* BooleanKeyword */; + break; + } + if (typeKind) { + return typeFromPrimitiveLiteral(primitiveNode, typeKind, context, isConstContext || preserveLiterals, requiresAddingUndefined); + } } - return void 0; + return failed; } function typeFromFunctionLikeExpression(fnNode, context) { - const returnType = serializeExistingTypeAnnotation(fnNode.type) ?? createReturnFromSignature(fnNode, context); - const typeParameters = reuseTypeParameters(fnNode.typeParameters); - const parameters = fnNode.parameters.every((p) => ensureParameter(p, context)); - return returnType && typeParameters && parameters; + const oldNoInferenceFallback = context.noInferenceFallback; + context.noInferenceFallback = true; + createReturnFromSignature( + fnNode, + /*symbol*/ + void 0, + context + ); + reuseTypeParameters(fnNode.typeParameters, context); + fnNode.parameters.map((p) => ensureParameter(p, context)); + context.noInferenceFallback = oldNoInferenceFallback; + return notImplemented2; } function canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext) { if (!isConstContext) { @@ -135833,18 +137249,38 @@ function createSyntacticTypeNodeBuilder(options, resolver) { } return true; } - function typeFromArrayLiteral(arrayLiteral, context, isConstContext) { + function typeFromArrayLiteral(arrayLiteral, context, isConstContext, requiresAddingUndefined) { if (!canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext)) { - return false; + if (requiresAddingUndefined || isDeclaration(walkUpParenthesizedExpressions(arrayLiteral).parent)) { + return alreadyReported; + } + return syntacticResult(inferExpressionType( + arrayLiteral, + context, + /*reportFallback*/ + false, + requiresAddingUndefined + )); } - let canInferArray = true; + const oldNoInferenceFallback = context.noInferenceFallback; + context.noInferenceFallback = true; + const elementTypesInfo = []; for (const element of arrayLiteral.elements) { Debug.assert(element.kind !== 230 /* SpreadElement */); - if (element.kind !== 232 /* OmittedExpression */) { - canInferArray = (typeFromExpression(element, context, isConstContext) ?? inferExpressionType(element, context)) && canInferArray; + if (element.kind === 232 /* OmittedExpression */) { + elementTypesInfo.push( + createUndefinedTypeNode() + ); + } else { + const expressionType = typeFromExpression(element, context, isConstContext); + const elementType = expressionType.type !== void 0 ? expressionType.type : inferExpressionType(element, context, expressionType.reportFallback); + elementTypesInfo.push(elementType); } } - return true; + const tupleType = factory.createTupleTypeNode(elementTypesInfo); + tupleType.emitNode = { flags: 1, autoGenerate: void 0, internalFlags: 0 }; + context.noInferenceFallback = oldNoInferenceFallback; + return notImplemented2; } function canGetTypeFromObjectLiteral(objectLiteral, context) { let result = true; @@ -135875,64 +137311,214 @@ function createSyntacticTypeNodeBuilder(options, resolver) { } return result; } - function typeFromObjectLiteral(objectLiteral, context, isConstContext) { - if (!canGetTypeFromObjectLiteral(objectLiteral, context)) return false; - let canInferObjectLiteral = true; + function typeFromObjectLiteral(objectLiteral, context, isConstContext, requiresAddingUndefined) { + if (!canGetTypeFromObjectLiteral(objectLiteral, context)) { + if (requiresAddingUndefined || isDeclaration(walkUpParenthesizedExpressions(objectLiteral).parent)) { + return alreadyReported; + } + return syntacticResult(inferExpressionType( + objectLiteral, + context, + /*reportFallback*/ + false, + requiresAddingUndefined + )); + } + const oldNoInferenceFallback = context.noInferenceFallback; + context.noInferenceFallback = true; + const properties = []; + const oldFlags = context.flags; + context.flags |= 4194304 /* InObjectTypeLiteral */; for (const prop of objectLiteral.properties) { Debug.assert(!isShorthandPropertyAssignment(prop) && !isSpreadAssignment(prop)); const name = prop.name; + let newProp; switch (prop.kind) { case 174 /* MethodDeclaration */: - canInferObjectLiteral = !!typeFromObjectLiteralMethod(prop, name, context) && canInferObjectLiteral; + newProp = withNewScope(context, prop, () => typeFromObjectLiteralMethod(prop, name, context, isConstContext)); break; case 303 /* PropertyAssignment */: - canInferObjectLiteral = !!typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext) && canInferObjectLiteral; + newProp = typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext); break; case 178 /* SetAccessor */: case 177 /* GetAccessor */: - canInferObjectLiteral = !!typeFromObjectLiteralAccessor(prop, name, context) && canInferObjectLiteral; + newProp = typeFromObjectLiteralAccessor(prop, name, context); break; } + if (newProp) { + setCommentRange(newProp, prop); + properties.push(newProp); + } } - return canInferObjectLiteral; + context.flags = oldFlags; + const typeNode = factory.createTypeLiteralNode(properties); + if (!(context.flags & 1024 /* MultilineObjectLiterals */)) { + setEmitFlags(typeNode, 1 /* SingleLine */); + } + context.noInferenceFallback = oldNoInferenceFallback; + return notImplemented2; } function typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext) { - return typeFromExpression(prop.initializer, context, isConstContext) ?? inferTypeOfDeclaration(prop, context); + const modifiers = isConstContext ? [factory.createModifier(148 /* ReadonlyKeyword */)] : []; + const expressionResult = typeFromExpression(prop.initializer, context, isConstContext); + const typeNode = expressionResult.type !== void 0 ? expressionResult.type : inferTypeOfDeclaration( + prop, + /*symbol*/ + void 0, + context, + expressionResult.reportFallback + ); + return factory.createPropertySignature( + modifiers, + reuseNode(context, name), + /*questionToken*/ + void 0, + typeNode + ); } function ensureParameter(p, context) { - return typeFromParameter(p, context); + return factory.updateParameterDeclaration( + p, + [], + reuseNode(context, p.dotDotDotToken), + resolver.serializeNameOfParameter(context, p), + resolver.isOptionalParameter(p) ? factory.createToken(58 /* QuestionToken */) : void 0, + typeFromParameter( + p, + /*symbol*/ + void 0, + context + ), + // Ignore private param props, since this type is going straight back into a param + /*initializer*/ + void 0 + ); } - function reuseTypeParameters(typeParameters) { - return (typeParameters == null ? void 0 : typeParameters.every( - (tp) => serializeExistingTypeAnnotation(tp.constraint) && serializeExistingTypeAnnotation(tp.default) - )) ?? true; + function reuseTypeParameters(typeParameters, context) { + return typeParameters == null ? void 0 : typeParameters.map( + (tp) => { + var _a; + return factory.updateTypeParameterDeclaration( + tp, + (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)), + reuseNode(context, tp.name), + serializeExistingTypeNodeWithFallback(tp.constraint, context), + serializeExistingTypeNodeWithFallback(tp.default, context) + ); + } + ); } - function typeFromObjectLiteralMethod(method, name, context) { - const returnType = createReturnFromSignature(method, context); - const typeParameters = reuseTypeParameters(method.typeParameters); - const parameters = method.parameters.every((p) => ensureParameter(p, context)); - return returnType && typeParameters && parameters; + function typeFromObjectLiteralMethod(method, name, context, isConstContext) { + const returnType = createReturnFromSignature( + method, + /*symbol*/ + void 0, + context + ); + const typeParameters = reuseTypeParameters(method.typeParameters, context); + const parameters = method.parameters.map((p) => ensureParameter(p, context)); + if (isConstContext) { + return factory.createPropertySignature( + [factory.createModifier(148 /* ReadonlyKeyword */)], + reuseNode(context, name), + reuseNode(context, method.questionToken), + factory.createFunctionTypeNode( + typeParameters, + parameters, + returnType + ) + ); + } else { + if (isIdentifier(name) && name.escapedText === "new") { + name = factory.createStringLiteral("new"); + } + return factory.createMethodSignature( + [], + reuseNode(context, name), + reuseNode(context, method.questionToken), + typeParameters, + parameters, + returnType + ); + } } function typeFromObjectLiteralAccessor(accessor, name, context) { const allAccessors = resolver.getAllAccessorDeclarations(accessor); - const getAccessorType = allAccessors.getAccessor && getTypeAnnotationFromAccessor2(allAccessors.getAccessor); - const setAccessorType = allAccessors.setAccessor && getTypeAnnotationFromAccessor2(allAccessors.setAccessor); + const getAccessorType = allAccessors.getAccessor && getTypeAnnotationFromAccessor(allAccessors.getAccessor); + const setAccessorType = allAccessors.setAccessor && getTypeAnnotationFromAccessor(allAccessors.setAccessor); if (getAccessorType !== void 0 && setAccessorType !== void 0) { - const parameters = accessor.parameters.every((p) => ensureParameter(p, context)); - if (isGetAccessor(accessor)) { - return parameters && serializeExistingTypeAnnotation(getAccessorType); - } else { - return parameters; - } + return withNewScope(context, accessor, () => { + const parameters = accessor.parameters.map((p) => ensureParameter(p, context)); + if (isGetAccessor(accessor)) { + return factory.updateGetAccessorDeclaration( + accessor, + [], + reuseNode(context, name), + parameters, + serializeExistingTypeNodeWithFallback(getAccessorType, context), + /*body*/ + void 0 + ); + } else { + return factory.updateSetAccessorDeclaration( + accessor, + [], + reuseNode(context, name), + parameters, + /*body*/ + void 0 + ); + } + }); } else if (allAccessors.firstAccessor === accessor) { - const foundType = getAccessorType ?? setAccessorType; - const propertyType = foundType ? serializeExistingTypeAnnotation(foundType) : inferAccessorType(accessor, allAccessors, context); - return propertyType; + const foundType = getAccessorType ? withNewScope(context, allAccessors.getAccessor, () => serializeExistingTypeNodeWithFallback(getAccessorType, context)) : setAccessorType ? withNewScope(context, allAccessors.setAccessor, () => serializeExistingTypeNodeWithFallback(setAccessorType, context)) : void 0; + const propertyType = foundType ?? inferAccessorType( + accessor, + allAccessors, + context, + /*symbol*/ + void 0 + ); + const propertySignature = factory.createPropertySignature( + allAccessors.setAccessor === void 0 ? [factory.createModifier(148 /* ReadonlyKeyword */)] : [], + reuseNode(context, name), + /*questionToken*/ + void 0, + propertyType + ); + return propertySignature; } - return false; } - function typeFromPrimitiveLiteral() { - return true; + function createUndefinedTypeNode() { + if (strictNullChecks) { + return factory.createKeywordTypeNode(157 /* UndefinedKeyword */); + } else { + return factory.createKeywordTypeNode(133 /* AnyKeyword */); + } + } + function typeFromPrimitiveLiteral(node, baseType, context, preserveLiterals, requiresAddingUndefined) { + let result; + if (preserveLiterals) { + if (node.kind === 224 /* PrefixUnaryExpression */ && node.operator === 40 /* PlusToken */) { + result = factory.createLiteralTypeNode(reuseNode(context, node.operand)); + } + result = factory.createLiteralTypeNode(reuseNode(context, node)); + } else { + result = factory.createKeywordTypeNode(baseType); + } + return syntacticResult(addUndefinedIfNeeded(result, requiresAddingUndefined, node, context)); + } + function addUndefinedIfNeeded(node, addUndefined, owner, context) { + const parentDeclaration = owner && walkUpParenthesizedExpressions(owner).parent; + const optionalDeclaration = parentDeclaration && isDeclaration(parentDeclaration) && isOptionalDeclaration(parentDeclaration); + if (!strictNullChecks || !(addUndefined || optionalDeclaration)) return node; + if (!canAddUndefined(node)) { + context.tracker.reportInferenceFallback(node); + } + if (isUnionTypeNode(node)) { + return factory.createUnionTypeNode([...node.types, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); + } + return factory.createUnionTypeNode([node, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]); } function canAddUndefined(node) { if (!strictNullChecks) return true; @@ -135947,24 +137533,28 @@ function createSyntacticTypeNodeBuilder(options, resolver) { } return false; } - function createReturnFromSignature(fn, context) { - let returnType; - const returnTypeNode = getEffectiveReturnTypeNode(fn); + function createReturnFromSignature(fn, symbol, context, reportFallback = true) { + let returnType = failed; + const returnTypeNode = isJSDocConstructSignature(fn) ? getEffectiveTypeAnnotationNode(fn.parameters[0]) : getEffectiveReturnTypeNode(fn); if (returnTypeNode) { - returnType = serializeExistingTypeAnnotation(returnTypeNode); - } - if (!returnType && isValueSignatureDeclaration(fn)) { + returnType = syntacticResult(serializeTypeAnnotationOfDeclaration(returnTypeNode, context, fn, symbol)); + } else if (isValueSignatureDeclaration(fn)) { returnType = typeFromSingleReturnExpression(fn, context); } - return returnType ?? inferReturnTypeOfSignatureSignature(fn, context); + return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode); } function typeFromSingleReturnExpression(declaration, context) { let candidateExpr; if (declaration && !nodeIsMissing(declaration.body)) { - if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0; + const flags = getFunctionFlags(declaration); + if (flags & 3 /* AsyncGenerator */) return failed; const body = declaration.body; if (body && isBlock(body)) { forEachReturnStatement(body, (s) => { + if (s.parent !== body) { + candidateExpr = void 0; + return true; + } if (!candidateExpr) { candidateExpr = s.expression; } else { @@ -135977,9 +137567,21 @@ function createSyntacticTypeNodeBuilder(options, resolver) { } } if (candidateExpr) { - return typeFromExpression(candidateExpr, context); + if (isContextuallyTyped(candidateExpr)) { + const type = isJSDocTypeAssertion(candidateExpr) ? getJSDocTypeAssertionType(candidateExpr) : isAsExpression(candidateExpr) || isTypeAssertionExpression(candidateExpr) ? candidateExpr.type : void 0; + if (type && !isConstTypeReference(type)) { + return syntacticResult(serializeExistingTypeNode(type, context)); + } + } else { + return typeFromExpression(candidateExpr, context); + } } - return void 0; + return failed; + } + function isContextuallyTyped(node) { + return findAncestor(node.parent, (n) => { + return isCallExpression(n) || !isFunctionLikeDeclaration(n) && !!getEffectiveTypeAnnotationNode(n) || isJsxElement(n) || isJsxExpression(n); + }); } } @@ -135991,13 +137593,30 @@ __export(ts_JsTyping_exports, { isTypingUpToDate: () => isTypingUpToDate, loadSafeList: () => loadSafeList, loadTypesMap: () => loadTypesMap, - nodeCoreModuleList: () => nodeCoreModuleList, - nodeCoreModules: () => nodeCoreModules, nonRelativeModuleNameForTypingCache: () => nonRelativeModuleNameForTypingCache, renderPackageNameValidationFailure: () => renderPackageNameValidationFailure, validatePackageName: () => validatePackageName }); +// src/jsTyping/_namespaces/ts.server.ts +var ts_server_exports = {}; +__export(ts_server_exports, { + ActionInvalidate: () => ActionInvalidate, + ActionPackageInstalled: () => ActionPackageInstalled, + ActionSet: () => ActionSet, + ActionWatchTypingLocations: () => ActionWatchTypingLocations, + Arguments: () => Arguments, + EventBeginInstallTypes: () => EventBeginInstallTypes, + EventEndInstallTypes: () => EventEndInstallTypes, + EventInitializationFailed: () => EventInitializationFailed, + EventTypesRegistry: () => EventTypesRegistry, + findArgument: () => findArgument, + hasArgument: () => hasArgument, + indent: () => indent2, + nowString: () => nowString, + stringifyIndented: () => stringifyIndented +}); + // src/jsTyping/shared.ts var ActionSet = "action::set"; var ActionInvalidate = "action::invalidate"; @@ -136041,59 +137660,6 @@ function isTypingUpToDate(cachedTyping, availableTypingVersions) { const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest")); return availableVersion.compareTo(cachedTyping.version) <= 0; } -var unprefixedNodeCoreModuleList = [ - "assert", - "assert/strict", - "async_hooks", - "buffer", - "child_process", - "cluster", - "console", - "constants", - "crypto", - "dgram", - "diagnostics_channel", - "dns", - "dns/promises", - "domain", - "events", - "fs", - "fs/promises", - "http", - "https", - "http2", - "inspector", - "inspector/promises", - "module", - "net", - "os", - "path", - "perf_hooks", - "process", - "punycode", - "querystring", - "readline", - "repl", - "stream", - "stream/promises", - "string_decoder", - "timers", - "timers/promises", - "tls", - "trace_events", - "tty", - "url", - "util", - "util/types", - "v8", - "vm", - "wasi", - "worker_threads", - "zlib" -]; -var prefixedNodeCoreModuleList = unprefixedNodeCoreModuleList.map((name) => `node:${name}`); -var nodeCoreModuleList = [...unprefixedNodeCoreModuleList, ...prefixedNodeCoreModuleList]; -var nodeCoreModules = new Set(nodeCoreModuleList); function nonRelativeModuleNameForTypingCache(moduleName) { return nodeCoreModules.has(moduleName) ? "node" : moduleName; } @@ -136328,6 +137894,7 @@ function renderPackageNameValidationFailureWorker(typing, result, name, isScopeN return `'${typing}':: ${kind} name '${name}' contains non URI safe characters`; case 0 /* Ok */: return Debug.fail(); + // Shouldn't have called this. default: Debug.assertNever(result); } @@ -136393,12 +137960,12 @@ var CompletionTriggerKind = /* @__PURE__ */ ((CompletionTriggerKind2) => { CompletionTriggerKind2[CompletionTriggerKind2["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions"; return CompletionTriggerKind2; })(CompletionTriggerKind || {}); -var InlayHintKind2 = /* @__PURE__ */ ((InlayHintKind3) => { - InlayHintKind3["Type"] = "Type"; - InlayHintKind3["Parameter"] = "Parameter"; - InlayHintKind3["Enum"] = "Enum"; - return InlayHintKind3; -})(InlayHintKind2 || {}); +var InlayHintKind = /* @__PURE__ */ ((InlayHintKind2) => { + InlayHintKind2["Type"] = "Type"; + InlayHintKind2["Parameter"] = "Parameter"; + InlayHintKind2["Enum"] = "Enum"; + return InlayHintKind2; +})(InlayHintKind || {}); var HighlightSpanKind = /* @__PURE__ */ ((HighlightSpanKind2) => { HighlightSpanKind2["none"] = "none"; HighlightSpanKind2["definition"] = "definition"; @@ -136406,11 +137973,11 @@ var HighlightSpanKind = /* @__PURE__ */ ((HighlightSpanKind2) => { HighlightSpanKind2["writtenReference"] = "writtenReference"; return HighlightSpanKind2; })(HighlightSpanKind || {}); -var IndentStyle = /* @__PURE__ */ ((IndentStyle3) => { - IndentStyle3[IndentStyle3["None"] = 0] = "None"; - IndentStyle3[IndentStyle3["Block"] = 1] = "Block"; - IndentStyle3[IndentStyle3["Smart"] = 2] = "Smart"; - return IndentStyle3; +var IndentStyle = /* @__PURE__ */ ((IndentStyle2) => { + IndentStyle2[IndentStyle2["None"] = 0] = "None"; + IndentStyle2[IndentStyle2["Block"] = 1] = "Block"; + IndentStyle2[IndentStyle2["Smart"] = 2] = "Smart"; + return IndentStyle2; })(IndentStyle || {}); var SemicolonPreference = /* @__PURE__ */ ((SemicolonPreference2) => { SemicolonPreference2["Ignore"] = "ignore"; @@ -136704,6 +138271,7 @@ function getMeaningFromDeclaration(node) { case 277 /* ExportAssignment */: case 278 /* ExportDeclaration */: return 7 /* All */; + // An external module can be a Value case 307 /* SourceFile */: return 4 /* Namespace */ | 1 /* Value */; } @@ -137012,6 +138580,7 @@ function getNodeKind(node) { return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */; case 4 /* ThisProperty */: return "property" /* memberVariableElement */; + // property case 5 /* Property */: return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */; case 6 /* Prototype */: @@ -137049,9 +138618,6 @@ function getLineStartPositionForPosition(position, sourceFile) { const line = sourceFile.getLineAndCharacterOfPosition(position).line; return lineStarts[line]; } -function rangeContainsRange(r1, r2) { - return startEndContainsRange(r1.pos, r1.end, r2); -} function rangeContainsRangeExclusive(r1, r2) { return rangeContainsPositionExclusive(r1, r2.pos) && rangeContainsPositionExclusive(r1, r2.end); } @@ -137061,9 +138627,6 @@ function rangeContainsPosition(r, pos) { function rangeContainsPositionExclusive(r, pos) { return r.pos < pos && pos < r.end; } -function startEndContainsRange(start, end, range) { - return start <= range.pos && end >= range.end; -} function rangeContainsStartEnd(range, start, end) { return range.pos <= start && range.end >= end; } @@ -137105,6 +138668,7 @@ function isCompletedNode(n, sourceFile) { if (!n.arguments) { return true; } + // falls through case 213 /* CallExpression */: case 217 /* ParenthesizedExpression */: case 196 /* ParenthesizedType */: @@ -137833,16 +139397,19 @@ function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) { token = findPrecedingMatchingToken(token, 23 /* OpenBracketToken */, sourceFile); if (!token) return void 0; break; + // Valid tokens in a type name. Skip. case 28 /* CommaToken */: nTypeArguments++; break; case 39 /* EqualsGreaterThanToken */: + // falls through case 80 /* Identifier */: case 11 /* StringLiteral */: case 9 /* NumericLiteral */: case 10 /* BigIntLiteral */: case 112 /* TrueKeyword */: case 97 /* FalseKeyword */: + // falls through case 114 /* TypeOfKeyword */: case 96 /* ExtendsKeyword */: case 143 /* KeyOfKeyword */: @@ -138079,7 +139646,7 @@ function createModuleSpecifierResolutionHost(program, host) { fileExists: (fileName) => program.fileExists(fileName), getCurrentDirectory: () => host.getCurrentDirectory(), readFile: maybeBind(host, host.readFile), - useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames), + useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames) || program.useCaseSensitiveFileNames, getSymlinkCache: maybeBind(host, host.getSymlinkCache) || program.getSymlinkCache, getModuleSpecifierCache: maybeBind(host, host.getModuleSpecifierCache), getPackageJsonInfoCache: () => { @@ -138931,28 +140498,33 @@ function tryAndIgnoreErrors(cb) { function tryIOAndConsumeErrors(host, toApply, ...args) { return tryAndIgnoreErrors(() => toApply && toApply.apply(host, args)); } -function findPackageJsons(startDirectory, host, stopDirectory) { +function findPackageJsons(startDirectory, host) { const paths = []; - forEachAncestorDirectory(startDirectory, (ancestor) => { - if (ancestor === stopDirectory) { - return true; + forEachAncestorDirectoryStoppingAtGlobalCache( + host, + startDirectory, + (ancestor) => { + const currentConfigPath = combinePaths(ancestor, "package.json"); + if (tryFileExists(host, currentConfigPath)) { + paths.push(currentConfigPath); + } } - const currentConfigPath = combinePaths(ancestor, "package.json"); - if (tryFileExists(host, currentConfigPath)) { - paths.push(currentConfigPath); - } - }); + ); return paths; } function findPackageJson(directory, host) { let packageJson; - forEachAncestorDirectory(directory, (ancestor) => { - if (ancestor === "node_modules") return true; - packageJson = findConfigFile(ancestor, (f) => tryFileExists(host, f), "package.json"); - if (packageJson) { - return true; + forEachAncestorDirectoryStoppingAtGlobalCache( + host, + directory, + (ancestor) => { + if (ancestor === "node_modules") return true; + packageJson = findConfigFile(ancestor, (f) => tryFileExists(host, f), "package.json"); + if (packageJson) { + return true; + } } - }); + ); return packageJson; } function getPackageJsonsVisibleToFile(fileName, host) { @@ -138960,15 +140532,19 @@ function getPackageJsonsVisibleToFile(fileName, host) { return []; } const packageJsons = []; - forEachAncestorDirectory(getDirectoryPath(fileName), (ancestor) => { - const packageJsonFileName = combinePaths(ancestor, "package.json"); - if (host.fileExists(packageJsonFileName)) { - const info = createPackageJsonInfo(packageJsonFileName, host); - if (info) { - packageJsons.push(info); + forEachAncestorDirectoryStoppingAtGlobalCache( + host, + getDirectoryPath(fileName), + (ancestor) => { + const packageJsonFileName = combinePaths(ancestor, "package.json"); + if (host.fileExists(packageJsonFileName)) { + const info = createPackageJsonInfo(packageJsonFileName, host); + if (info) { + packageJsons.push(info); + } } } - }); + ); return packageJsons; } function createPackageJsonInfo(fileName, host) { @@ -139097,7 +140673,7 @@ function createPackageJsonImportFilter(fromFile, preferences, host) { return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier); } function isAllowedCoreNodeModulesImport(moduleSpecifier) { - if (isFullSourceFile(fromFile) && isSourceFileJS(fromFile) && ts_JsTyping_exports.nodeCoreModules.has(moduleSpecifier)) { + if (isFullSourceFile(fromFile) && isSourceFileJS(fromFile) && nodeCoreModules.has(moduleSpecifier)) { if (usesNodeCoreModules === void 0) { usesNodeCoreModules = consumesNodeCoreModules(fromFile); } @@ -139134,7 +140710,7 @@ function createPackageJsonImportFilter(fromFile, preferences, host) { } } function consumesNodeCoreModules(sourceFile) { - return some(sourceFile.imports, ({ text }) => ts_JsTyping_exports.nodeCoreModules.has(text)); + return some(sourceFile.imports, ({ text }) => nodeCoreModules.has(text)); } function isInsideNodeModules(fileOrDirectory) { return contains(getPathComponents(fileOrDirectory), "node_modules"); @@ -139208,7 +140784,13 @@ function getDefaultLikeExportNameFromDeclaration(symbol) { if (isExportSpecifier(d) && d.symbol.flags === 2097152 /* Alias */) { return (_b = tryCast(d.propertyName, isIdentifier)) == null ? void 0 : _b.text; } - return (_c = tryCast(getNameOfDeclaration(d), isIdentifier)) == null ? void 0 : _c.text; + const name = (_c = tryCast(getNameOfDeclaration(d), isIdentifier)) == null ? void 0 : _c.text; + if (name) { + return name; + } + if (symbol.parent && !isExternalModuleSymbol(symbol.parent)) { + return symbol.parent.getName(); + } }); } function getSymbolParentOrFail(symbol) { @@ -139270,11 +140852,16 @@ function isDeprecatedDeclaration(decl) { return !!(getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 65536 /* Deprecated */); } function shouldUseUriStyleNodeCoreModules(file, program) { - const decisionFromFile = firstDefined(file.imports, (node) => { - if (ts_JsTyping_exports.nodeCoreModules.has(node.text)) { - return startsWith(node.text, "node:"); + let decisionFromFile; + for (const node of file.imports) { + if (nodeCoreModules.has(node.text) && !exclusivelyPrefixedNodeCoreModules.has(node.text)) { + if (startsWith(node.text, "node:")) { + return true; + } else { + decisionFromFile = false; + } } - }); + } return decisionFromFile ?? program.usesUriStyleNodeCoreModules; } function getNewLineKind(newLineCharacter) { @@ -139434,6 +141021,7 @@ var ExportKind = /* @__PURE__ */ ((ExportKind3) => { ExportKind3[ExportKind3["Default"] = 1] = "Default"; ExportKind3[ExportKind3["ExportEquals"] = 2] = "ExportEquals"; ExportKind3[ExportKind3["UMD"] = 3] = "UMD"; + ExportKind3[ExportKind3["Module"] = 4] = "Module"; return ExportKind3; })(ExportKind || {}); function createCacheableExportInfoMap(host) { @@ -139624,38 +141212,57 @@ function createCacheableExportInfoMap(host) { return !packageDeepestNodeModulesPath || startsWith(info.moduleFileName, packageDeepestNodeModulesPath); } } -function isImportableFile(program, from, to, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) { +function isImportable(program, fromFile, toFile, toModule, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) { var _a; - if (from === to) return false; - const cachedResult = moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.get(from.path, to.path, preferences, {}); + if (!toFile) { + let useNodePrefix; + const moduleName = stripQuotes(toModule.name); + if (nodeCoreModules.has(moduleName) && (useNodePrefix = shouldUseUriStyleNodeCoreModules(fromFile, program)) !== void 0) { + return useNodePrefix === startsWith(moduleName, "node:"); + } + return !packageJsonFilter || packageJsonFilter.allowsImportingAmbientModule(toModule, moduleSpecifierResolutionHost) || fileContainsPackageImport(fromFile, moduleName); + } + Debug.assertIsDefined(toFile); + if (fromFile === toFile) return false; + const cachedResult = moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.get(fromFile.path, toFile.path, preferences, {}); if ((cachedResult == null ? void 0 : cachedResult.isBlockedByPackageJsonDependencies) !== void 0) { - return !cachedResult.isBlockedByPackageJsonDependencies || !!cachedResult.packageName && fileContainsPackageImport(from, cachedResult.packageName); + return !cachedResult.isBlockedByPackageJsonDependencies || !!cachedResult.packageName && fileContainsPackageImport(fromFile, cachedResult.packageName); } const getCanonicalFileName = hostGetCanonicalFileName(moduleSpecifierResolutionHost); const globalTypingsCache = (_a = moduleSpecifierResolutionHost.getGlobalTypingsCacheLocation) == null ? void 0 : _a.call(moduleSpecifierResolutionHost); const hasImportablePath = !!ts_moduleSpecifiers_exports.forEachFileNameOfModule( - from.fileName, - to.fileName, + fromFile.fileName, + toFile.fileName, moduleSpecifierResolutionHost, /*preferSymlinks*/ false, (toPath3) => { - const toFile = program.getSourceFile(toPath3); - return (toFile === to || !toFile) && isImportablePath(from.fileName, toPath3, getCanonicalFileName, globalTypingsCache); + const file = program.getSourceFile(toPath3); + return (file === toFile || !file) && isImportablePath( + fromFile.fileName, + toPath3, + getCanonicalFileName, + globalTypingsCache, + moduleSpecifierResolutionHost + ); } ); if (packageJsonFilter) { - const importInfo = hasImportablePath ? packageJsonFilter.getSourceFileInfo(to, moduleSpecifierResolutionHost) : void 0; - moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(from.path, to.path, preferences, {}, importInfo == null ? void 0 : importInfo.packageName, !(importInfo == null ? void 0 : importInfo.importable)); - return !!(importInfo == null ? void 0 : importInfo.importable) || !!(importInfo == null ? void 0 : importInfo.packageName) && fileContainsPackageImport(from, importInfo.packageName); + const importInfo = hasImportablePath ? packageJsonFilter.getSourceFileInfo(toFile, moduleSpecifierResolutionHost) : void 0; + moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(fromFile.path, toFile.path, preferences, {}, importInfo == null ? void 0 : importInfo.packageName, !(importInfo == null ? void 0 : importInfo.importable)); + return !!(importInfo == null ? void 0 : importInfo.importable) || hasImportablePath && !!(importInfo == null ? void 0 : importInfo.packageName) && fileContainsPackageImport(fromFile, importInfo.packageName); } return hasImportablePath; } function fileContainsPackageImport(sourceFile, packageName) { return sourceFile.imports && sourceFile.imports.some((i) => i.text === packageName || i.text.startsWith(packageName + "/")); } -function isImportablePath(fromPath, toPath3, getCanonicalFileName, globalCachePath) { - const toNodeModules = forEachAncestorDirectory(toPath3, (ancestor) => getBaseFileName(ancestor) === "node_modules" ? ancestor : void 0); +function isImportablePath(fromPath, toPath3, getCanonicalFileName, globalCachePath, host) { + const toNodeModules = forEachAncestorDirectoryStoppingAtGlobalCache( + host, + toPath3, + (ancestor) => getBaseFileName(ancestor) === "node_modules" ? ancestor : void 0 + ); const toNodeModulesParent = toNodeModules && getDirectoryPath(getCanonicalFileName(toNodeModules)); return toNodeModulesParent === void 0 || startsWith(getCanonicalFileName(fromPath), toNodeModulesParent) || !!globalCachePath && startsWith(getCanonicalFileName(globalCachePath), toNodeModulesParent); } @@ -139726,13 +141333,17 @@ function getIsExcluded(excludePatterns, host) { if (excludePatterns.some((p) => p.test(fileName))) return true; if ((realpathsWithSymlinks == null ? void 0 : realpathsWithSymlinks.size) && pathContainsNodeModules(fileName)) { let dir = getDirectoryPath(fileName); - return forEachAncestorDirectory(getDirectoryPath(path), (dirPath) => { - const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath)); - if (symlinks) { - return symlinks.some((s) => excludePatterns.some((p) => p.test(fileName.replace(dir, s)))); + return forEachAncestorDirectoryStoppingAtGlobalCache( + host, + getDirectoryPath(path), + (dirPath) => { + const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath)); + if (symlinks) { + return symlinks.some((s) => excludePatterns.some((p) => p.test(fileName.replace(dir, s)))); + } + dir = getDirectoryPath(dir); } - dir = getDirectoryPath(dir); - }) ?? false; + ) ?? false; } return false; }; @@ -139771,7 +141382,7 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio true, (moduleSymbol, moduleFile, program2, isFromPackageJson) => { if (++moduleCount % 100 === 0) cancellationToken == null ? void 0 : cancellationToken.throwIfCancellationRequested(); - const seenExports = /* @__PURE__ */ new Map(); + const seenExports = /* @__PURE__ */ new Set(); const checker = program2.getTypeChecker(); const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker); if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) { @@ -139811,7 +141422,11 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio } function getDefaultLikeExportInfo(moduleSymbol, checker) { const exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol); - if (exportEquals !== moduleSymbol) return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ }; + if (exportEquals !== moduleSymbol) { + const defaultExport2 = checker.tryGetMemberInModuleExports("default" /* Default */, exportEquals); + if (defaultExport2) return { symbol: defaultExport2, exportKind: 1 /* Default */ }; + return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ }; + } const defaultExport = checker.tryGetMemberInModuleExports("default" /* Default */, moduleSymbol); if (defaultExport) return { symbol: defaultExport, exportKind: 1 /* Default */ }; } @@ -139829,7 +141444,7 @@ function getNamesForExportedSymbol(defaultExport, checker, scriptTarget) { function forEachNameOfDefaultExport(defaultExport, checker, scriptTarget, cb) { let chain; let current = defaultExport; - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); while (current) { const fromDeclaration = getDefaultLikeExportNameFromDeclaration(current); if (fromDeclaration) { @@ -140102,6 +141717,7 @@ function canFollow(keyword1, keyword2) { case 126 /* StaticKeyword */: case 129 /* AccessorKeyword */: return true; + // Allow things like "public get", "public constructor" and "public static". default: return false; } @@ -140749,7 +142365,7 @@ function getEncodedSyntacticClassifications(cancellationToken, sourceFile, span) // src/services/documentHighlights.ts var DocumentHighlights; -((DocumentHighlights3) => { +((DocumentHighlights2) => { function getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch) { const node = getTouchingPropertyName(sourceFile, position); if (node.parent && (isJsxOpeningElement(node.parent) && node.parent.tagName === node || isJsxClosingElement(node.parent))) { @@ -140759,7 +142375,7 @@ var DocumentHighlights; } return getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) || getSyntacticDocumentHighlights(node, sourceFile); } - DocumentHighlights3.getDocumentHighlights = getDocumentHighlights; + DocumentHighlights2.getDocumentHighlights = getDocumentHighlights; function getHighlightSpanForNode(node, sourceFile) { return { fileName: sourceFile.fileName, @@ -140912,6 +142528,7 @@ var DocumentHighlights; if (statement.kind === 251 /* ContinueStatement */) { return false; } + // falls through case 248 /* ForStatement */: case 249 /* ForInStatement */: case 250 /* ForOfStatement */: @@ -140957,6 +142574,7 @@ var DocumentHighlights; return [...nodes, container]; } return nodes; + // Syntactically invalid positions that the parser might produce anyway default: return void 0; } @@ -142536,8 +144154,10 @@ function isFixablePromiseArgument(arg, checker) { if (functionFlags & 1 /* Generator */) { return false; } + // falls through case 219 /* ArrowFunction */: visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true); + // falls through case 106 /* NullKeyword */: return true; case 80 /* Identifier */: @@ -143210,6 +144830,7 @@ function addChildrenRecursively(node) { Debug.assertNever(special); } } + // falls through default: if (hasJSDocNodes(node)) { forEach(node.jsDoc, (jsDoc) => { @@ -143372,6 +144993,7 @@ function isSynthesized(node) { return !!(node.flags & 16 /* Synthesized */); } function isOwnChild(n, parent2) { + if (n.parent === void 0) return false; const par = isModuleBlock(n.parent) ? n.parent.parent : n.parent; return par === parent2.node || contains(parent2.additionalNodes, par); } @@ -143656,6 +145278,7 @@ __export(ts_refactor_exports, { getStatementsToMove: () => getStatementsToMove, getUsageInfo: () => getUsageInfo, inferFunctionReturnType: () => ts_refactor_inferFunctionReturnType_exports, + isInImport: () => isInImport, isRefactorErrorInfo: () => isRefactorErrorInfo, refactorKindBeginsWith: () => refactorKindBeginsWith, registerRefactor: () => registerRefactor @@ -143802,6 +145425,7 @@ function changeExport(exportingSourceFile, { wasDefault, exportNode, exportName changes.replaceNode(exportingSourceFile, exportNode, factory.createExportDefault(Debug.checkDefined(decl.initializer, "Initializer was previously known to be present"))); break; } + // falls through case 266 /* EnumDeclaration */: case 265 /* TypeAliasDeclaration */: case 267 /* ModuleDeclaration */: @@ -144286,7 +145910,7 @@ function flattenTypeLiteralNodeReference(checker, selection) { } if (isIntersectionTypeNode(selection)) { const result = []; - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); for (const type of selection.types) { const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type); if (!flattenedTypeMembers || !flattenedTypeMembers.every((type2) => type2.name && addToSeen(seen, getNameFromPropertyName(type2.name)))) { @@ -144908,6 +146532,7 @@ function getNamesToExportInCommonJS(decl) { case 262 /* FunctionDeclaration */: case 263 /* ClassDeclaration */: return [decl.name.text]; + // TODO: GH#18217 case 243 /* VariableStatement */: return mapDefined(decl.declarationList.declarations, (d) => isIdentifier(d.name) ? d.name.text : void 0); case 267 /* ModuleDeclaration */: @@ -145089,23 +146714,22 @@ function getUsageInfo(oldFile, toMove, checker, existingTargetLocals = /* @__PUR const unusedImportsFromOldFile = /* @__PURE__ */ new Set(); for (const statement of toMove) { forEachReference(statement, checker, enclosingRange, (symbol, isValidTypeOnlyUseSite) => { - if (!symbol.declarations || isGlobalType(checker, symbol)) { + if (!symbol.declarations) { return; } if (existingTargetLocals.has(skipAlias(symbol, checker))) { unusedImportsFromOldFile.add(symbol); return; } - for (const decl of symbol.declarations) { - if (isInImport(decl)) { - const prevIsTypeOnly = oldImportsNeededByTargetFile.get(symbol); - oldImportsNeededByTargetFile.set(symbol, [ - prevIsTypeOnly === void 0 ? isValidTypeOnlyUseSite : prevIsTypeOnly && isValidTypeOnlyUseSite, - tryCast(decl, (d) => isImportSpecifier(d) || isImportClause(d) || isNamespaceImport(d) || isImportEqualsDeclaration(d) || isBindingElement(d) || isVariableDeclaration(d)) - ]); - } else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) { - targetFileImportsFromOldFile.set(symbol, isValidTypeOnlyUseSite); - } + const importedDeclaration = find(symbol.declarations, isInImport); + if (importedDeclaration) { + const prevIsTypeOnly = oldImportsNeededByTargetFile.get(symbol); + oldImportsNeededByTargetFile.set(symbol, [ + prevIsTypeOnly === void 0 ? isValidTypeOnlyUseSite : prevIsTypeOnly && isValidTypeOnlyUseSite, + tryCast(importedDeclaration, (d) => isImportSpecifier(d) || isImportClause(d) || isNamespaceImport(d) || isImportEqualsDeclaration(d) || isBindingElement(d) || isVariableDeclaration(d)) + ]); + } else if (!movedSymbols.has(symbol) && every(symbol.declarations, (decl) => isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile)) { + targetFileImportsFromOldFile.set(symbol, isValidTypeOnlyUseSite); } }); } @@ -145139,16 +146763,6 @@ function getUsageInfo(oldFile, toMove, checker, existingTargetLocals = /* @__PUR return !!jsxNamespaceSymbol2 && some(jsxNamespaceSymbol2.declarations, isInImport) ? jsxNamespaceSymbol2 : void 0; } } -function isGlobalType(checker, symbol) { - return !!checker.resolveName( - symbol.name, - /*location*/ - void 0, - 788968 /* Type */, - /*excludeGlobals*/ - false - ); -} function makeUniqueFilename(proposedFilename, extension, inDirectory, host) { let newFilename = proposedFilename; for (let i = 1; ; i++) { @@ -145367,6 +146981,9 @@ function addTargetFileImports(oldFile, importsToCopy, targetFileImportsFromOldFi const targetSymbol = skipAlias(symbol, checker); if (checker.isUnknownSymbol(targetSymbol)) { importAdder.addVerbatimImport(Debug.checkDefined(declaration ?? findAncestor((_a = symbol.declarations) == null ? void 0 : _a[0], isAnyImportOrRequireStatement))); + } else if (targetSymbol.parent === void 0) { + Debug.assert(declaration !== void 0, "expected module symbol to have a declaration"); + importAdder.addImportForModuleSymbol(symbol, isValidTypeOnlyUseSite, declaration); } else { importAdder.addImportFromExportedSymbol(targetSymbol, isValidTypeOnlyUseSite, declaration); } @@ -146370,6 +147987,7 @@ function entryToFunctionCall(entry) { const functionReference = entry.node; const parent2 = functionReference.parent; switch (parent2.kind) { + // foo(...) or super(...) or new Foo(...) case 213 /* CallExpression */: case 214 /* NewExpression */: const callOrNewExpression = tryCast(parent2, isCallOrNewExpression); @@ -146377,6 +147995,7 @@ function entryToFunctionCall(entry) { return callOrNewExpression; } break; + // x.foo(...) case 211 /* PropertyAccessExpression */: const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression); if (propertyAccessExpression && propertyAccessExpression.parent && propertyAccessExpression.name === functionReference) { @@ -146386,6 +148005,7 @@ function entryToFunctionCall(entry) { } } break; + // x["foo"](...) case 212 /* ElementAccessExpression */: const elementAccessExpression = tryCast(parent2, isElementAccessExpression); if (elementAccessExpression && elementAccessExpression.parent && elementAccessExpression.argumentExpression === functionReference) { @@ -146404,12 +148024,14 @@ function entryToAccessExpression(entry) { const reference = entry.node; const parent2 = reference.parent; switch (parent2.kind) { + // `C.foo` case 211 /* PropertyAccessExpression */: const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression); if (propertyAccessExpression && propertyAccessExpression.expression === reference) { return propertyAccessExpression; } break; + // `C["foo"]` case 212 /* ElementAccessExpression */: const elementAccessExpression = tryCast(parent2, isElementAccessExpression); if (elementAccessExpression && elementAccessExpression.expression === reference) { @@ -147502,11 +149124,13 @@ function getRangeToExtract2(sourceFile, span, invoked = true) { forEachChild(n, check); } }); + // falls through case 263 /* ClassDeclaration */: case 262 /* FunctionDeclaration */: if (isSourceFile(node2.parent) && node2.parent.externalModuleIndicator === void 0) { (errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.functionWillNotBeVisibleInTheNewScope)); } + // falls through case 231 /* ClassExpression */: case 218 /* FunctionExpression */: case 174 /* MethodDeclaration */: @@ -149333,6 +150957,7 @@ var SymbolObject = class { if (context) { if (isGetAccessor(context)) { if (!this.contextualGetAccessorDocumentationComment) { + this.contextualGetAccessorDocumentationComment = emptyArray; this.contextualGetAccessorDocumentationComment = getDocumentationComment(filter(this.declarations, isGetAccessor), checker); } if (length(this.contextualGetAccessorDocumentationComment)) { @@ -149341,6 +150966,7 @@ var SymbolObject = class { } if (isSetAccessor(context)) { if (!this.contextualSetAccessorDocumentationComment) { + this.contextualSetAccessorDocumentationComment = emptyArray; this.contextualSetAccessorDocumentationComment = getDocumentationComment(filter(this.declarations, isSetAccessor), checker); } if (length(this.contextualSetAccessorDocumentationComment)) { @@ -149361,6 +150987,7 @@ var SymbolObject = class { if (context) { if (isGetAccessor(context)) { if (!this.contextualGetAccessorTags) { + this.contextualGetAccessorTags = emptyArray; this.contextualGetAccessorTags = getJsDocTagsOfDeclarations(filter(this.declarations, isGetAccessor), checker); } if (length(this.contextualGetAccessorTags)) { @@ -149369,6 +150996,7 @@ var SymbolObject = class { } if (isSetAccessor(context)) { if (!this.contextualSetAccessorTags) { + this.contextualSetAccessorTags = emptyArray; this.contextualSetAccessorTags = getJsDocTagsOfDeclarations(filter(this.declarations, isSetAccessor), checker); } if (length(this.contextualSetAccessorTags)) { @@ -149681,6 +151309,7 @@ var SourceFileObject = class extends NodeObject { if (!hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) { break; } + // falls through case 260 /* VariableDeclaration */: case 208 /* BindingElement */: { const decl = node; @@ -149692,6 +151321,7 @@ var SourceFileObject = class extends NodeObject { visit(decl.initializer); } } + // falls through case 306 /* EnumMember */: case 172 /* PropertyDeclaration */: case 171 /* PropertySignature */: @@ -149726,6 +151356,7 @@ var SourceFileObject = class extends NodeObject { if (getAssignmentDeclarationKind(node) !== 0 /* None */) { addDeclaration(node); } + // falls through default: forEachChild(node, visit); } @@ -149973,7 +151604,8 @@ var invalidOperationsInSyntacticMode = [ "getNavigateToItems", "getRenameInfo", "findRenameLocations", - "getApplicableRefactors" + "getApplicableRefactors", + "preparePasteEditsForFile" ]; function createLanguageService(host, documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory(), host.jsDocParsingMode), syntaxOnlyOrLanguageServiceMode) { var _a; @@ -150089,7 +151721,8 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h resolveLibrary: maybeBind(host, host.resolveLibrary), useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect), getParsedCommandLine, - jsDocParsingMode: host.jsDocParsingMode + jsDocParsingMode: host.jsDocParsingMode, + getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation) }; const originalGetSourceFile = compilerHost.getSourceFile; const { getSourceFileWithCache } = changeCompilerHostLikeToUseCache( @@ -150465,6 +152098,14 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h tags }; } + function preparePasteEditsForFile(fileName, copiedTextRange) { + synchronizeHostData(); + return ts_preparePasteEdits_exports.preparePasteEdits( + getValidSourceFile(fileName), + copiedTextRange, + program.getTypeChecker() + ); + } function getPasteEdits(args, formatOptions) { synchronizeHostData(); return ts_PasteEdits_exports.pasteEditsProvider( @@ -150556,14 +152197,14 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h } else { const quotePreference = getQuotePreference(sourceFile, preferences ?? emptyOptions); const providePrefixAndSuffixTextForRename = typeof preferences === "boolean" ? preferences : preferences == null ? void 0 : preferences.providePrefixAndSuffixTextForRename; - return getReferencesWorker2(node, position, { findInStrings, findInComments, providePrefixAndSuffixTextForRename, use: ts_FindAllReferences_exports.FindReferencesUse.Rename }, (entry, originalNode, checker) => ts_FindAllReferences_exports.toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixTextForRename || false, quotePreference)); + return getReferencesWorker(node, position, { findInStrings, findInComments, providePrefixAndSuffixTextForRename, use: ts_FindAllReferences_exports.FindReferencesUse.Rename }, (entry, originalNode, checker) => ts_FindAllReferences_exports.toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixTextForRename || false, quotePreference)); } } function getReferencesAtPosition(fileName, position) { synchronizeHostData(); - return getReferencesWorker2(getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: ts_FindAllReferences_exports.FindReferencesUse.References }, ts_FindAllReferences_exports.toReferenceEntry); + return getReferencesWorker(getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: ts_FindAllReferences_exports.FindReferencesUse.References }, ts_FindAllReferences_exports.toReferenceEntry); } - function getReferencesWorker2(node, position, options, cb) { + function getReferencesWorker(node, position, options, cb) { synchronizeHostData(); const sourceFiles = options && options.use === ts_FindAllReferences_exports.FindReferencesUse.Rename ? program.getSourceFiles().filter((sourceFile) => !program.isSourceFileDefaultLibrary(sourceFile)) : program.getSourceFiles(); return ts_FindAllReferences_exports.findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, cb); @@ -150613,6 +152254,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h case 197 /* ThisType */: case 80 /* Identifier */: break; + // Cant create the text span default: return void 0; } @@ -150718,22 +152360,22 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h } return []; } - function getCodeFixesAtPosition(fileName, start, end, errorCodes67, formatOptions, preferences = emptyOptions) { + function getCodeFixesAtPosition(fileName, start, end, errorCodes68, formatOptions, preferences = emptyOptions) { synchronizeHostData(); const sourceFile = getValidSourceFile(fileName); const span = createTextSpanFromBounds(start, end); const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host); - return flatMap(deduplicate(errorCodes67, equateValues, compareValues), (errorCode) => { + return flatMap(deduplicate(errorCodes68, equateValues, compareValues), (errorCode) => { cancellationToken.throwIfCancellationRequested(); return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences }); }); } - function getCombinedCodeFix(scope, fixId55, formatOptions, preferences = emptyOptions) { + function getCombinedCodeFix(scope, fixId56, formatOptions, preferences = emptyOptions) { synchronizeHostData(); Debug.assert(scope.type === "file"); const sourceFile = getValidSourceFile(scope.fileName); const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host); - return ts_codefix_exports.getAllFixes({ fixId: fixId55, sourceFile, program, host, cancellationToken, formatContext, preferences }); + return ts_codefix_exports.getAllFixes({ fixId: fixId56, sourceFile, program, host, cancellationToken, formatContext, preferences }); } function organizeImports2(args, formatOptions, preferences = emptyOptions) { synchronizeHostData(); @@ -151266,6 +152908,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h uncommentSelection, provideInlayHints: provideInlayHints2, getSupportedCodeFixes, + preparePasteEditsForFile, getPasteEdits, mapCode: mapCode2 }; @@ -151330,6 +152973,7 @@ function getContainingObjectLiteralElementWorker(node) { if (node.parent.kind === 167 /* ComputedPropertyName */) { return isObjectLiteralElement(node.parent.parent) ? node.parent.parent : void 0; } + // falls through case 80 /* Identifier */: return isObjectLiteralElement(node.parent) && (node.parent.parent.kind === 210 /* ObjectLiteralExpression */ || node.parent.parent.kind === 292 /* JsxAttributes */) && node.parent.name === node ? node.parent : void 0; } @@ -151484,6 +153128,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { if (isFunctionBlock(node)) { return spanInFunctionBlock(node); } + // falls through case 268 /* ModuleBlock */: return spanInBlock(node); case 299 /* CatchClause */: @@ -151532,6 +153177,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { if (getModuleInstanceState(node) !== 1 /* Instantiated */) { return void 0; } + // falls through case 263 /* ClassDeclaration */: case 266 /* EnumDeclaration */: case 306 /* EnumMember */: @@ -151544,9 +153190,11 @@ function spanInSourceFileAtLocation(sourceFile, position) { case 206 /* ObjectBindingPattern */: case 207 /* ArrayBindingPattern */: return spanInBindingPattern(node); + // No breakpoint in interface, type alias case 264 /* InterfaceDeclaration */: case 265 /* TypeAliasDeclaration */: return void 0; + // Tokens: case 27 /* SemicolonToken */: case 1 /* EndOfFileToken */: return spanInNodeIfStartsOnSameLine(findPrecedingToken(node.pos, sourceFile)); @@ -151567,6 +153215,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { case 32 /* GreaterThanToken */: case 30 /* LessThanToken */: return spanInGreaterThanOrLessThanToken(node); + // Keywords: case 117 /* WhileKeyword */: return spanInWhileKeyword(node); case 93 /* ElseKeyword */: @@ -151717,10 +153366,13 @@ function spanInSourceFileAtLocation(sourceFile, position) { if (getModuleInstanceState(block.parent) !== 1 /* Instantiated */) { return void 0; } + // Set on parent if on same line otherwise on first statement + // falls through case 247 /* WhileStatement */: case 245 /* IfStatement */: case 249 /* ForInStatement */: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); + // Set span on previous token if it starts on same line otherwise on the first statement of the block case 248 /* ForStatement */: case 250 /* ForOfStatement */: return spanInNodeIfStartsOnSameLine(findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); @@ -151786,6 +153438,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { if (getModuleInstanceState(node2.parent.parent) !== 1 /* Instantiated */) { return void 0; } + // falls through case 266 /* EnumDeclaration */: case 263 /* ClassDeclaration */: return textSpan(node2); @@ -151793,6 +153446,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { if (isFunctionBlock(node2.parent)) { return textSpan(node2); } + // falls through case 299 /* CatchClause */: return spanInNode(lastOrUndefined(node2.parent.statements)); case 269 /* CaseBlock */: @@ -151805,6 +153459,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { case 206 /* ObjectBindingPattern */: const bindingPattern = node2.parent; return spanInNode(lastOrUndefined(bindingPattern.elements) || bindingPattern); + // Default to parent node default: if (isArrayLiteralOrObjectLiteralDestructuringPattern(node2.parent)) { const objectLiteral = node2.parent; @@ -151854,6 +153509,7 @@ function spanInSourceFileAtLocation(sourceFile, position) { case 214 /* NewExpression */: case 217 /* ParenthesizedExpression */: return spanInPreviousNode(node2); + // Default to parent node default: return spanInNode(node2.parent); } @@ -152387,8 +154043,10 @@ __export(ts_codefix_exports, { setJsonCompilerOptionValue: () => setJsonCompilerOptionValue, setJsonCompilerOptionValues: () => setJsonCompilerOptionValues, tryGetAutoImportableReferenceFromTypeNode: () => tryGetAutoImportableReferenceFromTypeNode, + typeNodeToAutoImportableTypeNode: () => typeNodeToAutoImportableTypeNode, typePredicateToAutoImportableTypeNode: () => typePredicateToAutoImportableTypeNode, - typeToAutoImportableTypeNode: () => typeToAutoImportableTypeNode + typeToAutoImportableTypeNode: () => typeToAutoImportableTypeNode, + typeToMinimizedReferenceType: () => typeToMinimizedReferenceType }); // src/services/codeFixProvider.ts @@ -152405,14 +154063,14 @@ function createCodeFixActionWithoutFixAll(fixName8, changes, description3) { void 0 ); } -function createCodeFixAction(fixName8, changes, description3, fixId55, fixAllDescription, command) { - return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId55, diagnosticToString(fixAllDescription), command); +function createCodeFixAction(fixName8, changes, description3, fixId56, fixAllDescription, command) { + return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId56, diagnosticToString(fixAllDescription), command); } -function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId55, fixAllDescription, command) { - return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId55, fixAllDescription && diagnosticToString(fixAllDescription), command); +function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId56, fixAllDescription, command) { + return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId56, fixAllDescription && diagnosticToString(fixAllDescription), command); } -function createCodeFixActionWorker(fixName8, description3, changes, fixId55, fixAllDescription, command) { - return { fixName: fixName8, description: description3, changes, fixId: fixId55, fixAllDescription, commands: command ? [command] : void 0 }; +function createCodeFixActionWorker(fixName8, description3, changes, fixId56, fixAllDescription, command) { + return { fixName: fixName8, description: description3, changes, fixId: fixId56, fixAllDescription, commands: command ? [command] : void 0 }; } function registerCodeFix(reg) { for (const error2 of reg.errorCodes) { @@ -152420,9 +154078,9 @@ function registerCodeFix(reg) { errorCodeToFixes.add(String(error2), reg); } if (reg.fixIds) { - for (const fixId55 of reg.fixIds) { - Debug.assert(!fixIdToRegistration.has(fixId55)); - fixIdToRegistration.set(fixId55, reg); + for (const fixId56 of reg.fixIds) { + Debug.assert(!fixIdToRegistration.has(fixId56)); + fixIdToRegistration.set(fixId56, reg); } } } @@ -152431,15 +154089,15 @@ function getSupportedErrorCodes() { return errorCodeToFixesArray ?? (errorCodeToFixesArray = arrayFrom(errorCodeToFixes.keys())); } function removeFixIdIfFixAllUnavailable(registration, diagnostics) { - const { errorCodes: errorCodes67 } = registration; + const { errorCodes: errorCodes68 } = registration; let maybeFixableDiagnostics = 0; for (const diag2 of diagnostics) { - if (contains(errorCodes67, diag2.code)) maybeFixableDiagnostics++; + if (contains(errorCodes68, diag2.code)) maybeFixableDiagnostics++; if (maybeFixableDiagnostics > 1) break; } const fixAllUnavailable = maybeFixableDiagnostics < 2; - return ({ fixId: fixId55, fixAllDescription, ...action }) => { - return fixAllUnavailable ? action : { ...action, fixId: fixId55, fixAllDescription }; + return ({ fixId: fixId56, fixAllDescription, ...action }) => { + return fixAllUnavailable ? action : { ...action, fixId: fixId56, fixAllDescription }; }; } function getFixes(context) { @@ -152456,14 +154114,14 @@ function createCombinedCodeActions(changes, commands) { function createFileTextChanges(fileName, textChanges2) { return { fileName, textChanges: textChanges2 }; } -function codeFixAll(context, errorCodes67, use) { +function codeFixAll(context, errorCodes68, use) { const commands = []; - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes67, (diag2) => use(t, diag2, commands))); + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes68, (diag2) => use(t, diag2, commands))); return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands); } -function eachDiagnostic(context, errorCodes67, cb) { +function eachDiagnostic(context, errorCodes68, cb) { for (const diag2 of getDiagnostics(context)) { - if (contains(errorCodes67, diag2.code)) { + if (contains(errorCodes68, diag2.code)) { cb(diag2); } } @@ -152977,19 +154635,99 @@ function makeChange6(changeTracker, sourceFile, pos) { changeTracker.replaceNode(sourceFile, decorator.expression, replacement); } -// src/services/codefixes/addNameToNamelessParameter.ts -var fixId7 = "addNameToNamelessParameter"; -var errorCodes7 = [Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code]; +// src/services/codefixes/addMissingResolutionModeImportAttribute.ts +var fixId7 = "addMissingResolutionModeImportAttribute"; +var errorCodes7 = [ + Diagnostics.Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute.code, + Diagnostics.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute.code +]; registerCodeFix({ errorCodes: errorCodes7, - getCodeActions: function getCodeActionsToAddNameToNamelessParameter(context) { - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange7(t, context.sourceFile, context.span.start)); - return [createCodeFixAction(fixId7, changes, Diagnostics.Add_parameter_name, fixId7, Diagnostics.Add_names_to_all_parameters_without_names)]; + getCodeActions: function getCodeActionsToAddMissingResolutionModeImportAttribute(context) { + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange7(t, context.sourceFile, context.span.start, context.program, context.host, context.preferences)); + return [createCodeFixAction(fixId7, changes, Diagnostics.Add_resolution_mode_import_attribute, fixId7, Diagnostics.Add_resolution_mode_import_attribute_to_all_type_only_imports_that_need_it)]; }, fixIds: [fixId7], - getAllCodeActions: (context) => codeFixAll(context, errorCodes7, (changes, diag2) => makeChange7(changes, diag2.file, diag2.start)) + getAllCodeActions: (context) => codeFixAll(context, errorCodes7, (changes, diag2) => makeChange7(changes, diag2.file, diag2.start, context.program, context.host, context.preferences)) }); -function makeChange7(changeTracker, sourceFile, start) { +function makeChange7(changeTracker, sourceFile, pos, program, host, preferences) { + var _a, _b, _c; + const token = getTokenAtPosition(sourceFile, pos); + const importNode = findAncestor(token, or(isImportDeclaration, isImportTypeNode)); + Debug.assert(!!importNode, "Expected position to be owned by an ImportDeclaration or ImportType."); + const useSingleQuotes = getQuotePreference(sourceFile, preferences) === 0 /* Single */; + const moduleSpecifier = tryGetModuleSpecifierFromDeclaration(importNode); + const canUseImportMode = !moduleSpecifier || ((_a = resolveModuleName( + moduleSpecifier.text, + sourceFile.fileName, + program.getCompilerOptions(), + host, + program.getModuleResolutionCache(), + /*redirectedReference*/ + void 0, + 99 /* ESNext */ + ).resolvedModule) == null ? void 0 : _a.resolvedFileName) === ((_c = (_b = program.getResolvedModuleFromModuleSpecifier( + moduleSpecifier, + sourceFile + )) == null ? void 0 : _b.resolvedModule) == null ? void 0 : _c.resolvedFileName); + const attributes = importNode.attributes ? factory.updateImportAttributes( + importNode.attributes, + factory.createNodeArray([ + ...importNode.attributes.elements, + factory.createImportAttribute( + factory.createStringLiteral("resolution-mode", useSingleQuotes), + factory.createStringLiteral(canUseImportMode ? "import" : "require", useSingleQuotes) + ) + ], importNode.attributes.elements.hasTrailingComma), + importNode.attributes.multiLine + ) : factory.createImportAttributes( + factory.createNodeArray([ + factory.createImportAttribute( + factory.createStringLiteral("resolution-mode", useSingleQuotes), + factory.createStringLiteral(canUseImportMode ? "import" : "require", useSingleQuotes) + ) + ]) + ); + if (importNode.kind === 272 /* ImportDeclaration */) { + changeTracker.replaceNode( + sourceFile, + importNode, + factory.updateImportDeclaration( + importNode, + importNode.modifiers, + importNode.importClause, + importNode.moduleSpecifier, + attributes + ) + ); + } else { + changeTracker.replaceNode( + sourceFile, + importNode, + factory.updateImportTypeNode( + importNode, + importNode.argument, + attributes, + importNode.qualifier, + importNode.typeArguments + ) + ); + } +} + +// src/services/codefixes/addNameToNamelessParameter.ts +var fixId8 = "addNameToNamelessParameter"; +var errorCodes8 = [Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code]; +registerCodeFix({ + errorCodes: errorCodes8, + getCodeActions: function getCodeActionsToAddNameToNamelessParameter(context) { + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, context.sourceFile, context.span.start)); + return [createCodeFixAction(fixId8, changes, Diagnostics.Add_parameter_name, fixId8, Diagnostics.Add_names_to_all_parameters_without_names)]; + }, + fixIds: [fixId8], + getAllCodeActions: (context) => codeFixAll(context, errorCodes8, (changes, diag2) => makeChange8(changes, diag2.file, diag2.start)) +}); +function makeChange8(changeTracker, sourceFile, start) { const token = getTokenAtPosition(sourceFile, start); const param = token.parent; if (!isParameter(param)) { @@ -153030,13 +154768,13 @@ function tryGetNextParam(sourceFile, param) { // src/services/codefixes/addOptionalPropertyUndefined.ts var addOptionalPropertyUndefined = "addOptionalPropertyUndefined"; -var errorCodes8 = [ +var errorCodes9 = [ Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target.code, Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code ]; registerCodeFix({ - errorCodes: errorCodes8, + errorCodes: errorCodes9, getCodeActions(context) { const typeChecker = context.program.getTypeChecker(); const toAdd = getPropertiesToAdd(context.sourceFile, context.span, typeChecker); @@ -153107,18 +154845,18 @@ function addUndefinedToOptionalProperty(changes, toAdd) { } // src/services/codefixes/annotateWithTypeFromJSDoc.ts -var fixId8 = "annotateWithTypeFromJSDoc"; -var errorCodes9 = [Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types.code]; +var fixId9 = "annotateWithTypeFromJSDoc"; +var errorCodes10 = [Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types.code]; registerCodeFix({ - errorCodes: errorCodes9, + errorCodes: errorCodes10, getCodeActions(context) { const decl = getDeclaration(context.sourceFile, context.span.start); if (!decl) return; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange8(t, context.sourceFile, decl)); - return [createCodeFixAction(fixId8, changes, Diagnostics.Annotate_with_type_from_JSDoc, fixId8, Diagnostics.Annotate_everything_with_types_from_JSDoc)]; + return [createCodeFixAction(fixId9, changes, Diagnostics.Annotate_with_type_from_JSDoc, fixId9, Diagnostics.Annotate_everything_with_types_from_JSDoc)]; }, - fixIds: [fixId8], - getAllCodeActions: (context) => codeFixAll(context, errorCodes9, (changes, diag2) => { + fixIds: [fixId9], + getAllCodeActions: (context) => codeFixAll(context, errorCodes10, (changes, diag2) => { const decl = getDeclaration(diag2.file, diag2.start); if (decl) doChange8(changes, diag2.file, decl); }) @@ -153275,16 +155013,16 @@ function transformJSDocIndexSignature(node) { } // src/services/codefixes/convertFunctionToEs6Class.ts -var fixId9 = "convertFunctionToEs6Class"; -var errorCodes10 = [Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration.code]; +var fixId10 = "convertFunctionToEs6Class"; +var errorCodes11 = [Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration.code]; registerCodeFix({ - errorCodes: errorCodes10, + errorCodes: errorCodes11, getCodeActions(context) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, context.sourceFile, context.span.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions())); - return [createCodeFixAction(fixId9, changes, Diagnostics.Convert_function_to_an_ES2015_class, fixId9, Diagnostics.Convert_all_constructor_functions_to_classes)]; + return [createCodeFixAction(fixId10, changes, Diagnostics.Convert_function_to_an_ES2015_class, fixId10, Diagnostics.Convert_all_constructor_functions_to_classes)]; }, - fixIds: [fixId9], - getAllCodeActions: (context) => codeFixAll(context, errorCodes10, (changes, err) => doChange9(changes, err.file, err.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions())) + fixIds: [fixId10], + getAllCodeActions: (context) => codeFixAll(context, errorCodes11, (changes, err) => doChange9(changes, err.file, err.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions())) }); function doChange9(changes, sourceFile, position, checker, preferences, compilerOptions) { const ctorSymbol = checker.getSymbolAtLocation(getTokenAtPosition(sourceFile, position)); @@ -153556,18 +155294,18 @@ function tryGetPropertyName(node, compilerOptions, quotePreference) { } // src/services/codefixes/convertToAsyncFunction.ts -var fixId10 = "convertToAsyncFunction"; -var errorCodes11 = [Diagnostics.This_may_be_converted_to_an_async_function.code]; +var fixId11 = "convertToAsyncFunction"; +var errorCodes12 = [Diagnostics.This_may_be_converted_to_an_async_function.code]; var codeActionSucceeded = true; registerCodeFix({ - errorCodes: errorCodes11, + errorCodes: errorCodes12, getCodeActions(context) { codeActionSucceeded = true; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => convertToAsyncFunction(t, context.sourceFile, context.span.start, context.program.getTypeChecker())); - return codeActionSucceeded ? [createCodeFixAction(fixId10, changes, Diagnostics.Convert_to_async_function, fixId10, Diagnostics.Convert_all_to_async_functions)] : []; + return codeActionSucceeded ? [createCodeFixAction(fixId11, changes, Diagnostics.Convert_to_async_function, fixId11, Diagnostics.Convert_all_to_async_functions)] : []; }, - fixIds: [fixId10], - getAllCodeActions: (context) => codeFixAll(context, errorCodes11, (changes, err) => convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker())) + fixIds: [fixId11], + getAllCodeActions: (context) => codeFixAll(context, errorCodes12, (changes, err) => convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker())) }); function convertToAsyncFunction(changes, sourceFile, position, checker) { const tokenAtPosition = getTokenAtPosition(sourceFile, position); @@ -154366,6 +156104,7 @@ function convertStatement(sourceFile, statement, checker, changes, identifiers, } } } + // falls through default: return false; } @@ -154465,6 +156204,8 @@ function tryChangeModuleExportsObject(object, useSitesToUnqualify) { switch (prop.kind) { case 177 /* GetAccessor */: case 178 /* SetAccessor */: + // TODO: Maybe we should handle this? See fourslash test `refactorConvertToEs6Module_export_object_shorthand.ts`. + // falls through case 304 /* ShorthandPropertyAssignment */: case 305 /* SpreadAssignment */: return void 0; @@ -154546,6 +156287,7 @@ function convertExportsDotXEquals_replaceNode(name, exported, useSitesToUnqualif return exportConst(); } } + // falls through case 219 /* ArrowFunction */: return functionExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify); case 231 /* ClassExpression */: @@ -154594,6 +156336,7 @@ function convertSingleImport(name, moduleSpecifier, checker, identifiers, target )]); } } + // falls through -- object destructuring has an interesting pattern and must be a variable declaration case 207 /* ArrayBindingPattern */: { const tmp = makeUniqueName(moduleSpecifierToValidIdentifier(moduleSpecifier.text, target), identifiers); return convertedImports([ @@ -154767,19 +156510,19 @@ function convertedImports(newImports, useSitesToUnqualify) { } // src/services/codefixes/correctQualifiedNameToIndexedAccessType.ts -var fixId11 = "correctQualifiedNameToIndexedAccessType"; -var errorCodes12 = [Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1.code]; +var fixId12 = "correctQualifiedNameToIndexedAccessType"; +var errorCodes13 = [Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1.code]; registerCodeFix({ - errorCodes: errorCodes12, + errorCodes: errorCodes13, getCodeActions(context) { const qualifiedName = getQualifiedName(context.sourceFile, context.span.start); if (!qualifiedName) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, context.sourceFile, qualifiedName)); const newText = `${qualifiedName.left.text}["${qualifiedName.right.text}"]`; - return [createCodeFixAction(fixId11, changes, [Diagnostics.Rewrite_as_the_indexed_access_type_0, newText], fixId11, Diagnostics.Rewrite_all_as_indexed_access_types)]; + return [createCodeFixAction(fixId12, changes, [Diagnostics.Rewrite_as_the_indexed_access_type_0, newText], fixId12, Diagnostics.Rewrite_all_as_indexed_access_types)]; }, - fixIds: [fixId11], - getAllCodeActions: (context) => codeFixAll(context, errorCodes12, (changes, diag2) => { + fixIds: [fixId12], + getAllCodeActions: (context) => codeFixAll(context, errorCodes13, (changes, diag2) => { const q = getQualifiedName(diag2.file, diag2.start); if (q) { doChange10(changes, diag2.file, q); @@ -154805,20 +156548,20 @@ function doChange10(changeTracker, sourceFile, qualifiedName) { } // src/services/codefixes/convertToTypeOnlyExport.ts -var errorCodes13 = [Diagnostics.Re_exporting_a_type_when_0_is_enabled_requires_using_export_type.code]; -var fixId12 = "convertToTypeOnlyExport"; +var errorCodes14 = [Diagnostics.Re_exporting_a_type_when_0_is_enabled_requires_using_export_type.code]; +var fixId13 = "convertToTypeOnlyExport"; registerCodeFix({ - errorCodes: errorCodes13, + errorCodes: errorCodes14, getCodeActions: function getCodeActionsToConvertToTypeOnlyExport(context) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => fixSingleExportDeclaration(t, getExportSpecifierForDiagnosticSpan(context.span, context.sourceFile), context)); if (changes.length) { - return [createCodeFixAction(fixId12, changes, Diagnostics.Convert_to_type_only_export, fixId12, Diagnostics.Convert_all_re_exported_types_to_type_only_exports)]; + return [createCodeFixAction(fixId13, changes, Diagnostics.Convert_to_type_only_export, fixId13, Diagnostics.Convert_all_re_exported_types_to_type_only_exports)]; } }, - fixIds: [fixId12], + fixIds: [fixId13], getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyExport(context) { - const fixedExportDeclarations = /* @__PURE__ */ new Map(); - return codeFixAll(context, errorCodes13, (changes, diag2) => { + const fixedExportDeclarations = /* @__PURE__ */ new Set(); + return codeFixAll(context, errorCodes14, (changes, diag2) => { const exportSpecifier = getExportSpecifierForDiagnosticSpan(diag2, context.sourceFile); if (exportSpecifier && addToSeen(fixedExportDeclarations, getNodeId(exportSpecifier.parent.parent))) { fixSingleExportDeclaration(changes, exportSpecifier, context); @@ -154877,18 +156620,18 @@ function getTypeExportSpecifiers(originExportSpecifier, context) { ); return filter(exportClause.elements, (element) => { var _a; - return element === originExportSpecifier || ((_a = findDiagnosticForNode(element, diagnostics)) == null ? void 0 : _a.code) === errorCodes13[0]; + return element === originExportSpecifier || ((_a = findDiagnosticForNode(element, diagnostics)) == null ? void 0 : _a.code) === errorCodes14[0]; }); } // src/services/codefixes/convertToTypeOnlyImport.ts -var errorCodes14 = [ +var errorCodes15 = [ Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code, Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code ]; -var fixId13 = "convertToTypeOnlyImport"; +var fixId14 = "convertToTypeOnlyImport"; registerCodeFix({ - errorCodes: errorCodes14, + errorCodes: errorCodes15, getCodeActions: function getCodeActionsToConvertToTypeOnlyImport(context) { var _a; const declaration = getDeclaration2(context.sourceFile, context.span.start); @@ -154896,15 +156639,15 @@ registerCodeFix({ const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, context.sourceFile, declaration)); const importDeclarationChanges = declaration.kind === 276 /* ImportSpecifier */ && isImportDeclaration(declaration.parent.parent.parent) && canConvertImportDeclarationForSpecifier(declaration, context.sourceFile, context.program) ? ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, context.sourceFile, declaration.parent.parent.parent)) : void 0; const mainAction = createCodeFixAction( - fixId13, + fixId14, changes, declaration.kind === 276 /* ImportSpecifier */ ? [Diagnostics.Use_type_0, ((_a = declaration.propertyName) == null ? void 0 : _a.text) ?? declaration.name.text] : Diagnostics.Use_import_type, - fixId13, + fixId14, Diagnostics.Fix_all_with_type_only_imports ); if (some(importDeclarationChanges)) { return [ - createCodeFixActionWithoutFixAll(fixId13, importDeclarationChanges, Diagnostics.Use_import_type), + createCodeFixActionWithoutFixAll(fixId14, importDeclarationChanges, Diagnostics.Use_import_type), mainAction ]; } @@ -154912,10 +156655,10 @@ registerCodeFix({ } return void 0; }, - fixIds: [fixId13], + fixIds: [fixId14], getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyImport(context) { const fixedImportDeclarations = /* @__PURE__ */ new Set(); - return codeFixAll(context, errorCodes14, (changes, diag2) => { + return codeFixAll(context, errorCodes15, (changes, diag2) => { const errorDeclaration = getDeclaration2(diag2.file, diag2.start); if ((errorDeclaration == null ? void 0 : errorDeclaration.kind) === 272 /* ImportDeclaration */ && !fixedImportDeclarations.has(errorDeclaration)) { doChange11(changes, diag2.file, errorDeclaration); @@ -155048,11 +156791,11 @@ function doChange11(changes, sourceFile, declaration) { } // src/services/codefixes/convertTypedefToType.ts -var fixId14 = "convertTypedefToType"; -var errorCodes15 = [Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type.code]; +var fixId15 = "convertTypedefToType"; +var errorCodes16 = [Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type.code]; registerCodeFix({ - fixIds: [fixId14], - errorCodes: errorCodes15, + fixIds: [fixId15], + errorCodes: errorCodes16, getCodeActions(context) { const newLineCharacter = getNewLineOrDefaultFromHost(context.host, context.formatContext.options); const node = getTokenAtPosition( @@ -155064,10 +156807,10 @@ registerCodeFix({ if (changes.length > 0) { return [ createCodeFixAction( - fixId14, + fixId15, changes, Diagnostics.Convert_typedef_to_TypeScript_type, - fixId14, + fixId15, Diagnostics.Convert_all_typedef_to_TypeScript_types ) ]; @@ -155075,7 +156818,7 @@ registerCodeFix({ }, getAllCodeActions: (context) => codeFixAll( context, - errorCodes15, + errorCodes16, (changes, diag2) => { const newLineCharacter = getNewLineOrDefaultFromHost(context.host, context.formatContext.options); const node = getTokenAtPosition(diag2.file, diag2.start); @@ -155218,10 +156961,10 @@ function getJSDocTypedefNodes(node) { } // src/services/codefixes/convertLiteralTypeToMappedType.ts -var fixId15 = "convertLiteralTypeToMappedType"; -var errorCodes16 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code]; +var fixId16 = "convertLiteralTypeToMappedType"; +var errorCodes17 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code]; registerCodeFix({ - errorCodes: errorCodes16, + errorCodes: errorCodes17, getCodeActions: function getCodeActionsToConvertLiteralTypeToMappedType(context) { const { sourceFile, span } = context; const info = getInfo5(sourceFile, span.start); @@ -155230,10 +156973,10 @@ registerCodeFix({ } const { name, constraint } = info; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange13(t, sourceFile, info)); - return [createCodeFixAction(fixId15, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId15, Diagnostics.Convert_all_type_literals_to_mapped_type)]; + return [createCodeFixAction(fixId16, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId16, Diagnostics.Convert_all_type_literals_to_mapped_type)]; }, - fixIds: [fixId15], - getAllCodeActions: (context) => codeFixAll(context, errorCodes16, (changes, diag2) => { + fixIds: [fixId16], + getAllCodeActions: (context) => codeFixAll(context, errorCodes17, (changes, diag2) => { const info = getInfo5(diag2.file, diag2.start); if (info) { doChange13(changes, diag2.file, info); @@ -155279,25 +157022,25 @@ function doChange13(changes, sourceFile, { container, typeNode, constraint, name } // src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts -var errorCodes17 = [ +var errorCodes18 = [ Diagnostics.Class_0_incorrectly_implements_interface_1.code, Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code ]; -var fixId16 = "fixClassIncorrectlyImplementsInterface"; +var fixId17 = "fixClassIncorrectlyImplementsInterface"; registerCodeFix({ - errorCodes: errorCodes17, + errorCodes: errorCodes18, getCodeActions(context) { const { sourceFile, span } = context; const classDeclaration = getClass(sourceFile, span.start); return mapDefined(getEffectiveImplementsTypeNodes(classDeclaration), (implementedTypeNode) => { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, t, context.preferences)); - return changes.length === 0 ? void 0 : createCodeFixAction(fixId16, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId16, Diagnostics.Implement_all_unimplemented_interfaces); + return changes.length === 0 ? void 0 : createCodeFixAction(fixId17, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId17, Diagnostics.Implement_all_unimplemented_interfaces); }); }, - fixIds: [fixId16], + fixIds: [fixId17], getAllCodeActions(context) { - const seenClassDeclarations = /* @__PURE__ */ new Map(); - return codeFixAll(context, errorCodes17, (changes, diag2) => { + const seenClassDeclarations = /* @__PURE__ */ new Set(); + return codeFixAll(context, errorCodes18, (changes, diag2) => { const classDeclaration = getClass(diag2.file, diag2.start); if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) { for (const implementedTypeNode of getEffectiveImplementsTypeNodes(classDeclaration)) { @@ -155363,7 +157106,7 @@ function getHeritageClauseSymbolTable(classDeclaration, checker) { // src/services/codefixes/importFixes.ts var importFixName = "import"; var importFixId = "fixMissingImport"; -var errorCodes18 = [ +var errorCodes19 = [ Diagnostics.Cannot_find_name_0.code, Diagnostics.Cannot_find_name_0_Did_you_mean_1.code, Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, @@ -155382,10 +157125,11 @@ var errorCodes18 = [ Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha.code, Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode.code, Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig.code, - Diagnostics.Cannot_find_namespace_0_Did_you_mean_1.code + Diagnostics.Cannot_find_namespace_0_Did_you_mean_1.code, + Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found.code ]; registerCodeFix({ - errorCodes: errorCodes18, + errorCodes: errorCodes19, getCodeActions(context) { const { errorCode, preferences, sourceFile, span, program } = context; const info = getFixInfos( @@ -155421,7 +157165,7 @@ registerCodeFix({ host, cancellationToken ); - eachDiagnostic(context, errorCodes18, (diag2) => importAdder.addImportFromDiagnostic(diag2, context)); + eachDiagnostic(context, errorCodes19, (diag2) => importAdder.addImportFromDiagnostic(diag2, context)); return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, importAdder.writeFixes)); } }); @@ -155444,7 +157188,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre const removeExisting = /* @__PURE__ */ new Set(); const verbatimImports = /* @__PURE__ */ new Set(); const newImports = /* @__PURE__ */ new Map(); - return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes, addImportForUnresolvedIdentifier, addImportForNonExistentExport, removeExistingImport, addVerbatimImport }; + return { addImportFromDiagnostic, addImportFromExportedSymbol, addImportForModuleSymbol, writeFixes, hasFixes, addImportForUnresolvedIdentifier, addImportForNonExistentExport, removeExistingImport, addVerbatimImport }; function addVerbatimImport(declaration) { verbatimImports.add(declaration); } @@ -155460,7 +157204,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre } function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite, referenceImport) { var _a, _b; - const moduleSymbol = Debug.checkDefined(exportedSymbol.parent); + const moduleSymbol = Debug.checkDefined(exportedSymbol.parent, "Expected exported symbol to have module symbol as parent"); const symbolName2 = getNameForExportedSymbol(exportedSymbol, getEmitScriptTarget(compilerOptions)); const checker = program.getTypeChecker(); const symbol = checker.getMergedSymbol(skipAlias(exportedSymbol, checker)); @@ -155494,12 +157238,91 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre ); if (fix) { const localName = ((_b = tryCast(referenceImport == null ? void 0 : referenceImport.name, isIdentifier)) == null ? void 0 : _b.text) ?? symbolName2; + let addAsTypeOnly; + let propertyName; if (referenceImport && isTypeOnlyImportDeclaration(referenceImport) && (fix.kind === 3 /* AddNew */ || fix.kind === 2 /* AddToExisting */) && fix.addAsTypeOnly === 1 /* Allowed */) { - fix = { ...fix, addAsTypeOnly: 2 /* Required */ }; + addAsTypeOnly = 2 /* Required */; } + if (exportedSymbol.name !== localName) { + propertyName = exportedSymbol.name; + } + fix = { + ...fix, + ...addAsTypeOnly === void 0 ? {} : { addAsTypeOnly }, + ...propertyName === void 0 ? {} : { propertyName } + }; addImport({ fix, symbolName: localName ?? symbolName2, errorIdentifierText: void 0 }); } } + function addImportForModuleSymbol(symbolAlias, isValidTypeOnlyUseSite, referenceImport) { + var _a, _b, _c; + const checker = program.getTypeChecker(); + const moduleSymbol = checker.getAliasedSymbol(symbolAlias); + Debug.assert(moduleSymbol.flags & 1536 /* Module */, "Expected symbol to be a module"); + const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host); + const moduleSpecifierResult = ts_moduleSpecifiers_exports.getModuleSpecifiersWithCacheInfo( + moduleSymbol, + checker, + compilerOptions, + sourceFile, + moduleSpecifierResolutionHost, + preferences, + /*options*/ + void 0, + /*forAutoImport*/ + true + ); + const useRequire = shouldUseRequire(sourceFile, program); + let addAsTypeOnly = getAddAsTypeOnly( + isValidTypeOnlyUseSite, + /*isForNewImportDeclaration*/ + true, + /*symbol*/ + void 0, + symbolAlias.flags, + program.getTypeChecker(), + compilerOptions + ); + addAsTypeOnly = addAsTypeOnly === 1 /* Allowed */ && isTypeOnlyImportDeclaration(referenceImport) ? 2 /* Required */ : 1 /* Allowed */; + const importKind = isImportDeclaration(referenceImport) ? isDefaultImport(referenceImport) ? 1 /* Default */ : 2 /* Namespace */ : isImportSpecifier(referenceImport) ? 0 /* Named */ : isImportClause(referenceImport) && !!referenceImport.name ? 1 /* Default */ : 2 /* Namespace */; + const exportInfo = [{ + symbol: symbolAlias, + moduleSymbol, + moduleFileName: (_c = (_b = (_a = moduleSymbol.declarations) == null ? void 0 : _a[0]) == null ? void 0 : _b.getSourceFile()) == null ? void 0 : _c.fileName, + exportKind: 4 /* Module */, + targetFlags: symbolAlias.flags, + isFromPackageJson: false + }]; + const existingFix = getImportFixForSymbol( + sourceFile, + exportInfo, + program, + /*position*/ + void 0, + !!isValidTypeOnlyUseSite, + useRequire, + host, + preferences + ); + let fix; + if (existingFix && importKind !== 2 /* Namespace */) { + fix = { + ...existingFix, + addAsTypeOnly, + importKind + }; + } else { + fix = { + kind: 3 /* AddNew */, + moduleSpecifierKind: existingFix !== void 0 ? existingFix.moduleSpecifierKind : moduleSpecifierResult.kind, + moduleSpecifier: existingFix !== void 0 ? existingFix.moduleSpecifier : first(moduleSpecifierResult.moduleSpecifiers), + importKind, + addAsTypeOnly, + useRequire + }; + } + addImport({ fix, symbolName: symbolAlias.name, errorIdentifierText: void 0 }); + } function addImportForNonExistentExport(exportName, exportingFileName, exportKind, exportedMeanings, isImportUsageValidAsTypeOnly) { const exportingSourceFile = program.getSourceFile(exportingFileName); const useRequire = shouldUseRequire(sourceFile, program); @@ -155562,7 +157385,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre removeExisting.add(declaration); } function addImport(info) { - var _a, _b; + var _a, _b, _c; const { fix, symbolName: symbolName2 } = info; switch (fix.kind) { case 0 /* UseNamespace */: @@ -155572,40 +157395,40 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre importType.push(fix); break; case 2 /* AddToExisting */: { - const { importClauseOrBindingPattern, importKind, addAsTypeOnly } = fix; + const { importClauseOrBindingPattern, importKind, addAsTypeOnly, propertyName } = fix; let entry = addToExisting.get(importClauseOrBindingPattern); if (!entry) { addToExisting.set(importClauseOrBindingPattern, entry = { importClauseOrBindingPattern, defaultImport: void 0, namedImports: /* @__PURE__ */ new Map() }); } if (importKind === 0 /* Named */) { - const prevValue = entry == null ? void 0 : entry.namedImports.get(symbolName2); - entry.namedImports.set(symbolName2, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly)); + const prevTypeOnly = (_a = entry == null ? void 0 : entry.namedImports.get(symbolName2)) == null ? void 0 : _a.addAsTypeOnly; + entry.namedImports.set(symbolName2, { addAsTypeOnly: reduceAddAsTypeOnlyValues(prevTypeOnly, addAsTypeOnly), propertyName }); } else { Debug.assert(entry.defaultImport === void 0 || entry.defaultImport.name === symbolName2, "(Add to Existing) Default import should be missing or match symbolName"); entry.defaultImport = { name: symbolName2, - addAsTypeOnly: reduceAddAsTypeOnlyValues((_a = entry.defaultImport) == null ? void 0 : _a.addAsTypeOnly, addAsTypeOnly) + addAsTypeOnly: reduceAddAsTypeOnlyValues((_b = entry.defaultImport) == null ? void 0 : _b.addAsTypeOnly, addAsTypeOnly) }; } break; } case 3 /* AddNew */: { - const { moduleSpecifier, importKind, useRequire, addAsTypeOnly } = fix; + const { moduleSpecifier, importKind, useRequire, addAsTypeOnly, propertyName } = fix; const entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly); Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module"); switch (importKind) { case 1 /* Default */: Debug.assert(entry.defaultImport === void 0 || entry.defaultImport.name === symbolName2, "(Add new) Default import should be missing or match symbolName"); - entry.defaultImport = { name: symbolName2, addAsTypeOnly: reduceAddAsTypeOnlyValues((_b = entry.defaultImport) == null ? void 0 : _b.addAsTypeOnly, addAsTypeOnly) }; + entry.defaultImport = { name: symbolName2, addAsTypeOnly: reduceAddAsTypeOnlyValues((_c = entry.defaultImport) == null ? void 0 : _c.addAsTypeOnly, addAsTypeOnly) }; break; case 0 /* Named */: const prevValue = (entry.namedImports || (entry.namedImports = /* @__PURE__ */ new Map())).get(symbolName2); - entry.namedImports.set(symbolName2, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly)); + entry.namedImports.set(symbolName2, [reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly), propertyName]); break; case 3 /* CommonJS */: if (compilerOptions.verbatimModuleSyntax) { const prevValue2 = (entry.namedImports || (entry.namedImports = /* @__PURE__ */ new Map())).get(symbolName2); - entry.namedImports.set(symbolName2, reduceAddAsTypeOnlyValues(prevValue2, addAsTypeOnly)); + entry.namedImports.set(symbolName2, [reduceAddAsTypeOnlyValues(prevValue2, addAsTypeOnly), propertyName]); } else { Debug.assert(entry.namespaceLikeImport === void 0 || entry.namespaceLikeImport.name === symbolName2, "Namespacelike import shoudl be missing or match symbolName"); entry.namespaceLikeImport = { importKind, name: symbolName2, addAsTypeOnly }; @@ -155666,7 +157489,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre function writeFixes(changeTracker, oldFileQuotePreference) { var _a, _b; let quotePreference; - if (isFullSourceFile(sourceFile) && sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) { + if (sourceFile.imports !== void 0 && sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) { quotePreference = oldFileQuotePreference; } else { quotePreference = getQuotePreference(sourceFile, preferences); @@ -155759,7 +157582,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre sourceFile, importClauseOrBindingPattern, defaultImport, - arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })), + arrayFrom(namedImports.entries(), ([name, { addAsTypeOnly, propertyName }]) => ({ addAsTypeOnly, propertyName, name })), importSpecifiersToRemoveWhileAdding, preferences ); @@ -155772,7 +157595,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre moduleSpecifier, quotePreference, defaultImport, - namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })), + namedImports && arrayFrom(namedImports.entries(), ([name, [addAsTypeOnly, propertyName]]) => ({ addAsTypeOnly, propertyName, name })), namespaceLikeImport, compilerOptions, preferences @@ -155948,7 +157771,8 @@ function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSym const moduleSourceFile = isFileExcluded && mergedModuleSymbol.declarations && getDeclarationOfKind(mergedModuleSymbol, 307 /* SourceFile */); const moduleSymbolExcluded = moduleSourceFile && isFileExcluded(moduleSourceFile); return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => { - if (getChecker(info[0].isFromPackageJson).getMergedSymbol(skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson))) === symbol && (moduleSymbolExcluded || info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol))) { + const checker = getChecker(info[0].isFromPackageJson); + if (checker.getMergedSymbol(skipAlias(info[0].symbol, checker)) === symbol && (moduleSymbolExcluded || info.some((i) => checker.getMergedSymbol(i.moduleSymbol) === moduleSymbol || i.symbol.parent === moduleSymbol))) { return info; } }); @@ -156377,6 +158201,8 @@ function getImportKind(importingFile, exportKind, program, forceImportKeyword) { return getExportEqualsImportKind(importingFile, program.getCompilerOptions(), !!forceImportKeyword); case 3 /* UMD */: return getUmdImportKind(importingFile, program, !!forceImportKeyword); + case 4 /* Module */: + return 2 /* Namespace */; default: return Debug.assertNever(exportKind); } @@ -156477,7 +158303,7 @@ function getExportInfos(symbolName2, isJsxTagName, currentTokenMeaning, cancella }); function addSymbol(moduleSymbol, toFile, exportedSymbol, exportKind, program2, isFromPackageJson) { const moduleSpecifierResolutionHost = getModuleSpecifierResolutionHost(isFromPackageJson); - if (toFile && isImportableFile(program2, fromFile, toFile, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) || (!toFile && packageJsonFilter.allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost) || fileContainsPackageImport(fromFile, stripQuotes(moduleSymbol.name)))) { + if (isImportable(program2, fromFile, toFile, moduleSymbol, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache)) { const checker = program2.getTypeChecker(); originalSymbolToExportInfos.add(getUniqueSymbolId(exportedSymbol, checker).toString(), { symbol: exportedSymbol, moduleSymbol, moduleFileName: toFile == null ? void 0 : toFile.fileName, exportKind, targetFlags: skipAlias(exportedSymbol, checker).flags, isFromPackageJson }); } @@ -156672,8 +158498,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor ...namedImports.map((i) => factory.createBindingElement( /*dotDotDotToken*/ void 0, - /*propertyName*/ - void 0, + i.propertyName, i.name )) ]) @@ -156684,12 +158509,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor addElementToBindingPattern(clause, defaultImport.name, "default"); } for (const specifier of namedImports) { - addElementToBindingPattern( - clause, - specifier.name, - /*propertyName*/ - void 0 - ); + addElementToBindingPattern(clause, specifier.name, specifier.propertyName); } return; } @@ -156705,8 +158525,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor namedImports.map( (namedImport) => factory.createImportSpecifier( (!clause.isTypeOnly || promoteFromTypeOnly2) && shouldUseTypeOnly(namedImport, preferences), - /*propertyName*/ - void 0, + namedImport.propertyName === void 0 ? void 0 : factory.createIdentifier(namedImport.propertyName), factory.createIdentifier(namedImport.name) ) ), @@ -156801,8 +158620,7 @@ function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImp namedImports == null ? void 0 : namedImports.map( (namedImport) => factory.createImportSpecifier( !topLevelTypeOnly && shouldUseTypeOnly(namedImport, preferences), - /*propertyName*/ - void 0, + namedImport.propertyName === void 0 ? void 0 : factory.createIdentifier(namedImport.propertyName), factory.createIdentifier(namedImport.name) ) ), @@ -156840,11 +158658,10 @@ function getNewRequires(moduleSpecifier, quotePreference, defaultImport, namedIm const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference); let statements; if (defaultImport || (namedImports == null ? void 0 : namedImports.length)) { - const bindingElements = (namedImports == null ? void 0 : namedImports.map(({ name }) => factory.createBindingElement( + const bindingElements = (namedImports == null ? void 0 : namedImports.map(({ name, propertyName }) => factory.createBindingElement( /*dotDotDotToken*/ void 0, - /*propertyName*/ - void 0, + propertyName, name ))) || []; if (defaultImport) { @@ -156896,8 +158713,8 @@ function getEmitModuleFormatOfFile(file, program) { } // src/services/codefixes/fixAddMissingConstraint.ts -var fixId17 = "addMissingConstraint"; -var errorCodes19 = [ +var fixId18 = "addMissingConstraint"; +var errorCodes20 = [ // We want errors this could be attached to: // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint Diagnostics.Type_0_is_not_comparable_to_type_1.code, @@ -156910,20 +158727,20 @@ var errorCodes19 = [ Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code ]; registerCodeFix({ - errorCodes: errorCodes19, + errorCodes: errorCodes20, getCodeActions(context) { const { sourceFile, span, program, preferences, host } = context; const info = getInfo6(program, sourceFile, span); if (info === void 0) return; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingConstraint(t, program, preferences, host, sourceFile, info)); - return [createCodeFixAction(fixId17, changes, Diagnostics.Add_extends_constraint, fixId17, Diagnostics.Add_extends_constraint_to_all_type_parameters)]; + return [createCodeFixAction(fixId18, changes, Diagnostics.Add_extends_constraint, fixId18, Diagnostics.Add_extends_constraint_to_all_type_parameters)]; }, - fixIds: [fixId17], + fixIds: [fixId18], getAllCodeActions: (context) => { const { program, preferences, host } = context; - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => { - eachDiagnostic(context, errorCodes19, (diag2) => { + eachDiagnostic(context, errorCodes20, (diag2) => { const info = getInfo6(program, diag2.file, createTextSpan(diag2.start, diag2.length)); if (info) { if (addToSeen(seen, getNodeId(info.declaration))) { @@ -157005,7 +158822,7 @@ function tryGetConstraintType(checker, node) { var fixName = "fixOverrideModifier"; var fixAddOverrideId = "fixAddOverrideModifier"; var fixRemoveOverrideId = "fixRemoveOverrideModifier"; -var errorCodes20 = [ +var errorCodes21 = [ Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code, Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code, Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code, @@ -157069,19 +158886,19 @@ var errorCodeFixIdMap = { } }; registerCodeFix({ - errorCodes: errorCodes20, + errorCodes: errorCodes21, getCodeActions: function getCodeActionsToFixOverrideModifierIssues(context) { const { errorCode, span } = context; const info = errorCodeFixIdMap[errorCode]; if (!info) return emptyArray; - const { descriptions, fixId: fixId55, fixAllDescriptions } = info; + const { descriptions, fixId: fixId56, fixAllDescriptions } = info; const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start)); return [ - createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId55, fixAllDescriptions) + createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId56, fixAllDescriptions) ]; }, fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId], - getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => { const { code, start } = diag2; const info = errorCodeFixIdMap[code]; if (!info || info.fixId !== context.fixId) { @@ -157157,20 +158974,20 @@ function findContainerClassElementLike(sourceFile, pos) { } // src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts -var fixId18 = "fixNoPropertyAccessFromIndexSignature"; -var errorCodes21 = [ +var fixId19 = "fixNoPropertyAccessFromIndexSignature"; +var errorCodes22 = [ Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code ]; registerCodeFix({ - errorCodes: errorCodes21, - fixIds: [fixId18], + errorCodes: errorCodes22, + fixIds: [fixId19], getCodeActions(context) { const { sourceFile, span, preferences } = context; const property = getPropertyAccessExpression(sourceFile, span.start); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property, preferences)); - return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)]; + return [createCodeFixAction(fixId19, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId19, Diagnostics.Use_element_access_for_all_undeclared_properties)]; }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => doChange14(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences)) + getAllCodeActions: (context) => codeFixAll(context, errorCodes22, (changes, diag2) => doChange14(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences)) }); function doChange14(changes, sourceFile, node, preferences) { const quotePreference = getQuotePreference(sourceFile, preferences); @@ -157186,20 +159003,20 @@ function getPropertyAccessExpression(sourceFile, pos) { } // src/services/codefixes/fixImplicitThis.ts -var fixId19 = "fixImplicitThis"; -var errorCodes22 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code]; +var fixId20 = "fixImplicitThis"; +var errorCodes23 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code]; registerCodeFix({ - errorCodes: errorCodes22, + errorCodes: errorCodes23, getCodeActions: function getCodeActionsToFixImplicitThis(context) { const { sourceFile, program, span } = context; let diagnostic; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => { diagnostic = doChange15(t, sourceFile, span.start, program.getTypeChecker()); }); - return diagnostic ? [createCodeFixAction(fixId19, changes, diagnostic, fixId19, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray; + return diagnostic ? [createCodeFixAction(fixId20, changes, diagnostic, fixId20, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray; }, - fixIds: [fixId19], - getAllCodeActions: (context) => codeFixAll(context, errorCodes22, (changes, diag2) => { + fixIds: [fixId20], + getAllCodeActions: (context) => codeFixAll(context, errorCodes23, (changes, diag2) => { doChange15(changes, diag2.file, diag2.start, context.program.getTypeChecker()); }) }); @@ -157244,25 +159061,25 @@ function doChange15(changes, sourceFile, pos, checker) { } // src/services/codefixes/fixImportNonExportedMember.ts -var fixId20 = "fixImportNonExportedMember"; -var errorCodes23 = [ +var fixId21 = "fixImportNonExportedMember"; +var errorCodes24 = [ Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code ]; registerCodeFix({ - errorCodes: errorCodes23, - fixIds: [fixId20], + errorCodes: errorCodes24, + fixIds: [fixId21], getCodeActions(context) { const { sourceFile, span, program } = context; const info = getInfo7(sourceFile, span.start, program); if (info === void 0) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(t, program, info)); - return [createCodeFixAction(fixId20, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId20, Diagnostics.Export_all_referenced_locals)]; + return [createCodeFixAction(fixId21, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId21, Diagnostics.Export_all_referenced_locals)]; }, getAllCodeActions(context) { const { program } = context; return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => { const exports2 = /* @__PURE__ */ new Map(); - eachDiagnostic(context, errorCodes23, (diag2) => { + eachDiagnostic(context, errorCodes24, (diag2) => { const info = getInfo7(diag2.file, diag2.start, program); if (info === void 0) return void 0; const { exportName, node, moduleSourceFile } = info; @@ -157402,20 +159219,20 @@ function getNodeOfSymbol(symbol) { } // src/services/codefixes/fixIncorrectNamedTupleSyntax.ts -var fixId21 = "fixIncorrectNamedTupleSyntax"; -var errorCodes24 = [ +var fixId22 = "fixIncorrectNamedTupleSyntax"; +var errorCodes25 = [ Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code, Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code ]; registerCodeFix({ - errorCodes: errorCodes24, + errorCodes: errorCodes25, getCodeActions: function getCodeActionsToFixIncorrectNamedTupleSyntax(context) { const { sourceFile, span } = context; const namedTupleMember = getNamedTupleMember(sourceFile, span.start); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, sourceFile, namedTupleMember)); - return [createCodeFixAction(fixId21, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId21, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)]; + return [createCodeFixAction(fixId22, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId22, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)]; }, - fixIds: [fixId21] + fixIds: [fixId22] }); function getNamedTupleMember(sourceFile, pos) { const token = getTokenAtPosition(sourceFile, pos); @@ -157450,8 +159267,8 @@ function doChange17(changes, sourceFile, namedTupleMember) { } // src/services/codefixes/fixSpelling.ts -var fixId22 = "fixSpelling"; -var errorCodes25 = [ +var fixId23 = "fixSpelling"; +var errorCodes26 = [ Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, Diagnostics.Cannot_find_name_0_Did_you_mean_1.code, @@ -157468,7 +159285,7 @@ var errorCodes25 = [ Diagnostics.Type_0_is_not_assignable_to_type_1.code ]; registerCodeFix({ - errorCodes: errorCodes25, + errorCodes: errorCodes26, getCodeActions(context) { const { sourceFile, errorCode } = context; const info = getInfo8(sourceFile, context.span.start, context, errorCode); @@ -157476,10 +159293,10 @@ registerCodeFix({ const { node, suggestedSymbol } = info; const target = getEmitScriptTarget(context.host.getCompilationSettings()); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(t, sourceFile, node, suggestedSymbol, target)); - return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId22, Diagnostics.Fix_all_detected_spelling_errors)]; + return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId23, Diagnostics.Fix_all_detected_spelling_errors)]; }, - fixIds: [fixId22], - getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => { + fixIds: [fixId23], + getAllCodeActions: (context) => codeFixAll(context, errorCodes26, (changes, diag2) => { const info = getInfo8(diag2.file, diag2.start, context, diag2.code); const target = getEmitScriptTarget(context.host.getCompilationSettings()); if (info) doChange18(changes, context.sourceFile, info.node, info.suggestedSymbol, target); @@ -157568,17 +159385,17 @@ function getResolvedSourceFileFromImportDeclaration(context, importDeclaration, } // src/services/codefixes/returnValueCorrect.ts -var fixId23 = "returnValueCorrect"; +var fixId24 = "returnValueCorrect"; var fixIdAddReturnStatement = "fixAddReturnStatement"; var fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody"; var fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen"; -var errorCodes26 = [ +var errorCodes27 = [ Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value.code, Diagnostics.Type_0_is_not_assignable_to_type_1.code, Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code ]; registerCodeFix({ - errorCodes: errorCodes26, + errorCodes: errorCodes27, fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen], getCodeActions: function getCodeActionsToCorrectReturnValue(context) { const { program, sourceFile, span: { start }, errorCode } = context; @@ -157593,7 +159410,7 @@ registerCodeFix({ return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)]; } }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes26, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes27, (changes, diag2) => { const info = getInfo9(context.program.getTypeChecker(), diag2.file, diag2.start, diag2.code); if (!info) return void 0; switch (context.fixId) { @@ -157792,7 +159609,7 @@ function wrapBlockWithParen(changes, sourceFile, declaration, expression) { } function getActionForfixAddReturnStatement(context, expression, statement) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addReturnStatement(t, context.sourceFile, expression, statement)); - return createCodeFixAction(fixId23, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement); + return createCodeFixAction(fixId24, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement); } function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, expression, commentSource) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => removeBlockBodyBrace( @@ -157804,11 +159621,11 @@ function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, /*withParen*/ false )); - return createCodeFixAction(fixId23, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues); + return createCodeFixAction(fixId24, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues); } function getActionForfixWrapTheBlockWithParen(context, declaration, expression) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => wrapBlockWithParen(t, context.sourceFile, declaration, expression)); - return createCodeFixAction(fixId23, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses); + return createCodeFixAction(fixId24, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses); } // src/services/codefixes/fixAddMissingMember.ts @@ -157816,7 +159633,7 @@ var fixMissingMember = "fixMissingMember"; var fixMissingProperties = "fixMissingProperties"; var fixMissingAttributes = "fixMissingAttributes"; var fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration"; -var errorCodes27 = [ +var errorCodes28 = [ Diagnostics.Property_0_does_not_exist_on_type_1.code, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code, @@ -157826,7 +159643,7 @@ var errorCodes27 = [ Diagnostics.Cannot_find_name_0.code ]; registerCodeFix({ - errorCodes: errorCodes27, + errorCodes: errorCodes28, getCodeActions(context) { const typeChecker = context.program.getTypeChecker(); const info = getInfo10(context.sourceFile, context.span.start, context.errorCode, typeChecker, context.program); @@ -157853,21 +159670,21 @@ registerCodeFix({ }, fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes], getAllCodeActions: (context) => { - const { program, fixId: fixId55 } = context; + const { program, fixId: fixId56 } = context; const checker = program.getTypeChecker(); - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); const typeDeclToMembers = /* @__PURE__ */ new Map(); return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => { - eachDiagnostic(context, errorCodes27, (diag2) => { + eachDiagnostic(context, errorCodes28, (diag2) => { const info = getInfo10(diag2.file, diag2.start, diag2.code, checker, context.program); if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 /* ObjectLiteral */ ? info.identifier : info.token.text))) { return; } - if (fixId55 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) { + if (fixId56 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) { addFunctionDeclaration(changes, context, info); - } else if (fixId55 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) { + } else if (fixId56 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) { addObjectLiteralProperties(changes, context, info); - } else if (fixId55 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) { + } else if (fixId56 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) { addJsxAttributes(changes, context, info); } else { if (info.kind === 1 /* Enum */) { @@ -157906,7 +159723,7 @@ registerCodeFix({ } }); function getInfo10(sourceFile, tokenPos, errorCode, checker, program) { - var _a; + var _a, _b, _c; const token = getTokenAtPosition(sourceFile, tokenPos); const parent2 = token.parent; if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) { @@ -157919,7 +159736,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) { if (!(param && isParameter(param) && isIdentifier(param.name))) return void 0; const properties = arrayFrom(checker.getUnmatchedProperties( checker.getTypeAtLocation(parent2), - checker.getParameterType(signature, argIndex), + checker.getParameterType(signature, argIndex).getNonNullableType(), /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ @@ -157929,7 +159746,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) { return { kind: 3 /* ObjectLiteral */, token: param.name, identifier: param.name.text, properties, parentDeclaration: parent2 }; } if (token.kind === 19 /* OpenBraceToken */ && isObjectLiteralExpression(parent2)) { - const targetType = checker.getContextualType(parent2) || checker.getTypeAtLocation(parent2); + const targetType = (_a = checker.getContextualType(parent2) || checker.getTypeAtLocation(parent2)) == null ? void 0 : _a.getNonNullableType(); const properties = arrayFrom(checker.getUnmatchedProperties( checker.getTypeAtLocation(parent2), targetType, @@ -157944,7 +159761,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) { } if (!isMemberName(token)) return void 0; if (isIdentifier(token) && hasInitializer(parent2) && parent2.initializer && isObjectLiteralExpression(parent2.initializer)) { - const targetType = checker.getContextualType(token) || checker.getTypeAtLocation(token); + const targetType = (_b = checker.getContextualType(token) || checker.getTypeAtLocation(token)) == null ? void 0 : _b.getNonNullableType(); const properties = arrayFrom(checker.getUnmatchedProperties( checker.getTypeAtLocation(parent2.initializer), targetType, @@ -157963,7 +159780,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) { return { kind: 4 /* JsxAttributes */, token, attributes, parentDeclaration: token.parent }; } if (isIdentifier(token)) { - const type = (_a = checker.getContextualType(token)) == null ? void 0 : _a.getNonNullableType(); + const type = (_c = checker.getContextualType(token)) == null ? void 0 : _c.getNonNullableType(); if (type && getObjectFlags(type) & 16 /* Anonymous */) { const signature = firstOrUndefined(checker.getSignaturesOfType(type, 0 /* Call */)); if (signature === void 0) return void 0; @@ -158284,8 +160101,9 @@ function tryGetValueFromType(context, checker, importAdder, quotePreference, typ } if (type.flags & 1056 /* EnumLike */) { const enumMember = type.symbol.exports ? firstOrUndefinedIterator(type.symbol.exports.values()) : type.symbol; + const symbol = type.symbol.parent && type.symbol.parent.flags & 256 /* RegularEnum */ ? type.symbol.parent : type.symbol; const name = checker.symbolToExpression( - type.symbol.parent ? type.symbol.parent : type.symbol, + symbol, 111551 /* Value */, /*enclosingDeclaration*/ void 0, @@ -158436,17 +160254,17 @@ function findScope(node) { } // src/services/codefixes/fixAddMissingNewOperator.ts -var fixId24 = "addMissingNewOperator"; -var errorCodes28 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code]; +var fixId25 = "addMissingNewOperator"; +var errorCodes29 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code]; registerCodeFix({ - errorCodes: errorCodes28, + errorCodes: errorCodes29, getCodeActions(context) { const { sourceFile, span } = context; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingNewOperator(t, sourceFile, span)); - return [createCodeFixAction(fixId24, changes, Diagnostics.Add_missing_new_operator_to_call, fixId24, Diagnostics.Add_missing_new_operator_to_all_calls)]; + return [createCodeFixAction(fixId25, changes, Diagnostics.Add_missing_new_operator_to_call, fixId25, Diagnostics.Add_missing_new_operator_to_all_calls)]; }, - fixIds: [fixId24], - getAllCodeActions: (context) => codeFixAll(context, errorCodes28, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2)) + fixIds: [fixId25], + getAllCodeActions: (context) => codeFixAll(context, errorCodes29, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2)) }); function addMissingNewOperator(changes, sourceFile, span) { const call = cast(findAncestorMatchingSpan2(sourceFile, span), isCallExpression); @@ -158465,9 +160283,9 @@ function findAncestorMatchingSpan2(sourceFile, span) { // src/services/codefixes/fixAddMissingParam.ts var addMissingParamFixId = "addMissingParam"; var addOptionalParamFixId = "addOptionalParam"; -var errorCodes29 = [Diagnostics.Expected_0_arguments_but_got_1.code]; +var errorCodes30 = [Diagnostics.Expected_0_arguments_but_got_1.code]; registerCodeFix({ - errorCodes: errorCodes29, + errorCodes: errorCodes30, fixIds: [addMissingParamFixId, addOptionalParamFixId], getCodeActions(context) { const info = getInfo11(context.sourceFile, context.program, context.span.start); @@ -158500,7 +160318,7 @@ registerCodeFix({ } return actions2; }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes29, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes30, (changes, diag2) => { const info = getInfo11(context.sourceFile, context.program, diag2.start); if (info) { const { declarations, newParameters, newOptionalParameters } = info; @@ -158703,17 +160521,19 @@ function getParameterType(importAdder, typeNode, scriptTarget) { var fixName2 = "fixCannotFindModule"; var fixIdInstallTypesPackage = "installTypesPackage"; var errorCodeCannotFindModule = Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code; -var errorCodes30 = [ +var errorCannotFindImplicitJsxImport = Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed.code; +var errorCodes31 = [ errorCodeCannotFindModule, - Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code + Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code, + errorCannotFindImplicitJsxImport ]; registerCodeFix({ - errorCodes: errorCodes30, + errorCodes: errorCodes31, getCodeActions: function getCodeActionsToFixNotFoundModule(context) { - const { host, sourceFile, span: { start } } = context; - const packageName = tryGetImportedPackageName(sourceFile, start); + const { host, sourceFile, span: { start }, errorCode } = context; + const packageName = errorCode === errorCannotFindImplicitJsxImport ? getJSXImplicitImportBase(context.program.getCompilerOptions(), sourceFile) : tryGetImportedPackageName(sourceFile, start); if (packageName === void 0) return void 0; - const typesPackageName = getTypesPackageNameToInstall(packageName, host, context.errorCode); + const typesPackageName = getTypesPackageNameToInstall(packageName, host, errorCode); return typesPackageName === void 0 ? [] : [createCodeFixAction( fixName2, /*changes*/ @@ -158726,7 +160546,7 @@ registerCodeFix({ }, fixIds: [fixIdInstallTypesPackage], getAllCodeActions: (context) => { - return codeFixAll(context, errorCodes30, (_changes, diag2, commands) => { + return codeFixAll(context, errorCodes31, (_changes, diag2, commands) => { const packageName = tryGetImportedPackageName(diag2.file, diag2.start); if (packageName === void 0) return void 0; switch (context.fixId) { @@ -158755,11 +160575,11 @@ function tryGetImportedPackageName(sourceFile, pos) { } function getTypesPackageNameToInstall(packageName, host, diagCode) { var _a; - return diagCode === errorCodeCannotFindModule ? ts_JsTyping_exports.nodeCoreModules.has(packageName) ? "@types/node" : void 0 : ((_a = host.isKnownTypesPackageName) == null ? void 0 : _a.call(host, packageName)) ? getTypesPackageName(packageName) : void 0; + return diagCode === errorCodeCannotFindModule ? nodeCoreModules.has(packageName) ? "@types/node" : void 0 : ((_a = host.isKnownTypesPackageName) == null ? void 0 : _a.call(host, packageName)) ? getTypesPackageName(packageName) : void 0; } // src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts -var errorCodes31 = [ +var errorCodes32 = [ Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code, Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2.code, Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more.code, @@ -158767,18 +160587,18 @@ var errorCodes31 = [ Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1.code, Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more.code ]; -var fixId25 = "fixClassDoesntImplementInheritedAbstractMember"; +var fixId26 = "fixClassDoesntImplementInheritedAbstractMember"; registerCodeFix({ - errorCodes: errorCodes31, + errorCodes: errorCodes32, getCodeActions: function getCodeActionsToFixClassNotImplementingInheritedMembers(context) { const { sourceFile, span } = context; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMembers(getClass2(sourceFile, span.start), sourceFile, context, t, context.preferences)); - return changes.length === 0 ? void 0 : [createCodeFixAction(fixId25, changes, Diagnostics.Implement_inherited_abstract_class, fixId25, Diagnostics.Implement_all_inherited_abstract_classes)]; + return changes.length === 0 ? void 0 : [createCodeFixAction(fixId26, changes, Diagnostics.Implement_inherited_abstract_class, fixId26, Diagnostics.Implement_all_inherited_abstract_classes)]; }, - fixIds: [fixId25], + fixIds: [fixId26], getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) { - const seenClassDeclarations = /* @__PURE__ */ new Map(); - return codeFixAll(context, errorCodes31, (changes, diag2) => { + const seenClassDeclarations = /* @__PURE__ */ new Set(); + return codeFixAll(context, errorCodes32, (changes, diag2) => { const classDeclaration = getClass2(diag2.file, diag2.start); if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) { addMissingMembers(classDeclaration, context.sourceFile, context, changes, context.preferences); @@ -158805,23 +160625,23 @@ function symbolPointsToNonPrivateAndAbstractMember(symbol) { } // src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts -var fixId26 = "classSuperMustPrecedeThisAccess"; -var errorCodes32 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code]; +var fixId27 = "classSuperMustPrecedeThisAccess"; +var errorCodes33 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code]; registerCodeFix({ - errorCodes: errorCodes32, + errorCodes: errorCodes33, getCodeActions(context) { const { sourceFile, span } = context; const nodes = getNodes(sourceFile, span.start); if (!nodes) return void 0; const { constructor, superCall } = nodes; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, sourceFile, constructor, superCall)); - return [createCodeFixAction(fixId26, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId26, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)]; + return [createCodeFixAction(fixId27, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId27, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)]; }, - fixIds: [fixId26], + fixIds: [fixId27], getAllCodeActions(context) { const { sourceFile } = context; - const seenClasses = /* @__PURE__ */ new Map(); - return codeFixAll(context, errorCodes32, (changes, diag2) => { + const seenClasses = /* @__PURE__ */ new Set(); + return codeFixAll(context, errorCodes33, (changes, diag2) => { const nodes = getNodes(diag2.file, diag2.start); if (!nodes) return; const { constructor, superCall } = nodes; @@ -158847,18 +160667,18 @@ function findSuperCall(n) { } // src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts -var fixId27 = "constructorForDerivedNeedSuperCall"; -var errorCodes33 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code]; +var fixId28 = "constructorForDerivedNeedSuperCall"; +var errorCodes34 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code]; registerCodeFix({ - errorCodes: errorCodes33, + errorCodes: errorCodes34, getCodeActions(context) { const { sourceFile, span } = context; const ctr = getNode(sourceFile, span.start); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, sourceFile, ctr)); - return [createCodeFixAction(fixId27, changes, Diagnostics.Add_missing_super_call, fixId27, Diagnostics.Add_all_missing_super_calls)]; + return [createCodeFixAction(fixId28, changes, Diagnostics.Add_missing_super_call, fixId28, Diagnostics.Add_all_missing_super_calls)]; }, - fixIds: [fixId27], - getAllCodeActions: (context) => codeFixAll(context, errorCodes33, (changes, diag2) => doChange21(changes, context.sourceFile, getNode(diag2.file, diag2.start))) + fixIds: [fixId28], + getAllCodeActions: (context) => codeFixAll(context, errorCodes34, (changes, diag2) => doChange21(changes, context.sourceFile, getNode(diag2.file, diag2.start))) }); function getNode(sourceFile, pos) { const token = getTokenAtPosition(sourceFile, pos); @@ -158878,9 +160698,9 @@ function doChange21(changes, sourceFile, ctr) { // src/services/codefixes/fixEnableJsxFlag.ts var fixID = "fixEnableJsxFlag"; -var errorCodes34 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code]; +var errorCodes35 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code]; registerCodeFix({ - errorCodes: errorCodes34, + errorCodes: errorCodes35, getCodeActions: function getCodeActionsToFixEnableJsxFlag(context) { const { configFile } = context.program.getCompilerOptions(); if (configFile === void 0) { @@ -158892,7 +160712,7 @@ registerCodeFix({ ]; }, fixIds: [fixID], - getAllCodeActions: (context) => codeFixAll(context, errorCodes34, (changes) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes) => { const { configFile } = context.program.getCompilerOptions(); if (configFile === void 0) { return void 0; @@ -158905,23 +160725,23 @@ function doChange22(changeTracker, configFile) { } // src/services/codefixes/fixNaNEquality.ts -var fixId28 = "fixNaNEquality"; -var errorCodes35 = [ +var fixId29 = "fixNaNEquality"; +var errorCodes36 = [ Diagnostics.This_condition_will_always_return_0.code ]; registerCodeFix({ - errorCodes: errorCodes35, + errorCodes: errorCodes36, getCodeActions(context) { const { sourceFile, span, program } = context; const info = getInfo12(program, sourceFile, span); if (info === void 0) return; const { suggestion, expression, arg } = info; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, sourceFile, arg, expression)); - return [createCodeFixAction(fixId28, changes, [Diagnostics.Use_0, suggestion], fixId28, Diagnostics.Use_Number_isNaN_in_all_conditions)]; + return [createCodeFixAction(fixId29, changes, [Diagnostics.Use_0, suggestion], fixId29, Diagnostics.Use_Number_isNaN_in_all_conditions)]; }, - fixIds: [fixId28], + fixIds: [fixId29], getAllCodeActions: (context) => { - return codeFixAll(context, errorCodes35, (changes, diag2) => { + return codeFixAll(context, errorCodes36, (changes, diag2) => { const info = getInfo12(context.program, diag2.file, createTextSpan(diag2.start, diag2.length)); if (info) { doChange23(changes, diag2.file, info.arg, info.expression); @@ -159001,20 +160821,20 @@ registerCodeFix({ }); // src/services/codefixes/fixPropertyAssignment.ts -var fixId29 = "fixPropertyAssignment"; -var errorCodes36 = [ +var fixId30 = "fixPropertyAssignment"; +var errorCodes37 = [ Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code ]; registerCodeFix({ - errorCodes: errorCodes36, - fixIds: [fixId29], + errorCodes: errorCodes37, + fixIds: [fixId30], getCodeActions(context) { const { sourceFile, span } = context; const property = getProperty2(sourceFile, span.start); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange24(t, context.sourceFile, property)); - return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])]; + return [createCodeFixAction(fixId30, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId30, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])]; }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => doChange24(changes, diag2.file, getProperty2(diag2.file, diag2.start))) + getAllCodeActions: (context) => codeFixAll(context, errorCodes37, (changes, diag2) => doChange24(changes, diag2.file, getProperty2(diag2.file, diag2.start))) }); function doChange24(changes, sourceFile, node) { changes.replaceNode(sourceFile, node, factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer)); @@ -159024,20 +160844,20 @@ function getProperty2(sourceFile, pos) { } // src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts -var fixId30 = "extendsInterfaceBecomesImplements"; -var errorCodes37 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code]; +var fixId31 = "extendsInterfaceBecomesImplements"; +var errorCodes38 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code]; registerCodeFix({ - errorCodes: errorCodes37, + errorCodes: errorCodes38, getCodeActions(context) { const { sourceFile } = context; const nodes = getNodes2(sourceFile, context.span.start); if (!nodes) return void 0; const { extendsToken, heritageClauses } = nodes; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChanges2(t, sourceFile, extendsToken, heritageClauses)); - return [createCodeFixAction(fixId30, changes, Diagnostics.Change_extends_to_implements, fixId30, Diagnostics.Change_all_extended_interfaces_to_implements)]; + return [createCodeFixAction(fixId31, changes, Diagnostics.Change_extends_to_implements, fixId31, Diagnostics.Change_all_extended_interfaces_to_implements)]; }, - fixIds: [fixId30], - getAllCodeActions: (context) => codeFixAll(context, errorCodes37, (changes, diag2) => { + fixIds: [fixId31], + getAllCodeActions: (context) => codeFixAll(context, errorCodes38, (changes, diag2) => { const nodes = getNodes2(diag2.file, diag2.start); if (nodes) doChanges2(changes, diag2.file, nodes.extendsToken, nodes.heritageClauses); }) @@ -159064,15 +160884,15 @@ function doChanges2(changes, sourceFile, extendsToken, heritageClauses) { } // src/services/codefixes/fixForgottenThisPropertyAccess.ts -var fixId31 = "forgottenThisPropertyAccess"; +var fixId32 = "forgottenThisPropertyAccess"; var didYouMeanStaticMemberCode = Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code; -var errorCodes38 = [ +var errorCodes39 = [ Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code, didYouMeanStaticMemberCode ]; registerCodeFix({ - errorCodes: errorCodes38, + errorCodes: errorCodes39, getCodeActions(context) { const { sourceFile } = context; const info = getInfo13(sourceFile, context.span.start, context.errorCode); @@ -159080,10 +160900,10 @@ registerCodeFix({ return void 0; } const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange25(t, sourceFile, info)); - return [createCodeFixAction(fixId31, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId31, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)]; + return [createCodeFixAction(fixId32, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId32, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)]; }, - fixIds: [fixId31], - getAllCodeActions: (context) => codeFixAll(context, errorCodes38, (changes, diag2) => { + fixIds: [fixId32], + getAllCodeActions: (context) => codeFixAll(context, errorCodes39, (changes, diag2) => { const info = getInfo13(diag2.file, diag2.start, diag2.code); if (info) doChange25(changes, context.sourceFile, info); }) @@ -159102,12 +160922,12 @@ function doChange25(changes, sourceFile, { node, className }) { // src/services/codefixes/fixInvalidJsxCharacters.ts var fixIdExpression = "fixInvalidJsxCharacters_expression"; var fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity"; -var errorCodes39 = [ +var errorCodes40 = [ Diagnostics.Unexpected_token_Did_you_mean_or_gt.code, Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code ]; registerCodeFix({ - errorCodes: errorCodes39, + errorCodes: errorCodes40, fixIds: [fixIdExpression, fixIdHtmlEntity], getCodeActions(context) { const { sourceFile, preferences, span } = context; @@ -159133,7 +160953,7 @@ registerCodeFix({ ]; }, getAllCodeActions(context) { - return codeFixAll(context, errorCodes39, (changes, diagnostic) => doChange26(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity)); + return codeFixAll(context, errorCodes40, (changes, diagnostic) => doChange26(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity)); } }); var htmlEntity = { @@ -159155,12 +160975,12 @@ function doChange26(changes, preferences, sourceFile, start, useHtmlEntity) { // src/services/codefixes/fixUnmatchedParameter.ts var deleteUnmatchedParameter = "deleteUnmatchedParameter"; var renameUnmatchedParameter = "renameUnmatchedParameter"; -var errorCodes40 = [ +var errorCodes41 = [ Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code ]; registerCodeFix({ fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter], - errorCodes: errorCodes40, + errorCodes: errorCodes41, getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) { const { sourceFile, span } = context; const actions2 = []; @@ -159175,7 +160995,7 @@ registerCodeFix({ getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) { const tagsToSignature = /* @__PURE__ */ new Map(); return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => { - eachDiagnostic(context, errorCodes40, ({ file, start }) => { + eachDiagnostic(context, errorCodes41, ({ file, start }) => { const info = getInfo14(file, start); if (info) { tagsToSignature.set(info.signature, append(tagsToSignature.get(info.signature), info.jsDocParameterTag)); @@ -159238,10 +161058,10 @@ function getInfo14(sourceFile, pos) { } // src/services/codefixes/fixUnreferenceableDecoratorMetadata.ts -var fixId32 = "fixUnreferenceableDecoratorMetadata"; -var errorCodes41 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code]; +var fixId33 = "fixUnreferenceableDecoratorMetadata"; +var errorCodes42 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code]; registerCodeFix({ - errorCodes: errorCodes41, + errorCodes: errorCodes42, getCodeActions: (context) => { const importDeclaration = getImportDeclaration(context.sourceFile, context.program, context.span.start); if (!importDeclaration) return; @@ -159249,14 +161069,14 @@ registerCodeFix({ const typeOnlyChanges = ts_textChanges_exports.ChangeTracker.with(context, (t) => doTypeOnlyImportChange(t, context.sourceFile, importDeclaration, context.program)); let actions2; if (namespaceChanges.length) { - actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import)); + actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId33, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import)); } if (typeOnlyChanges.length) { - actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, typeOnlyChanges, Diagnostics.Use_import_type)); + actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId33, typeOnlyChanges, Diagnostics.Use_import_type)); } return actions2; }, - fixIds: [fixId32] + fixIds: [fixId33] }); function getImportDeclaration(sourceFile, program, start) { const identifier = tryCast(getTokenAtPosition(sourceFile, start), isIdentifier); @@ -159293,7 +161113,7 @@ var fixIdPrefix = "unusedIdentifier_prefix"; var fixIdDelete = "unusedIdentifier_delete"; var fixIdDeleteImports = "unusedIdentifier_deleteImports"; var fixIdInfer = "unusedIdentifier_infer"; -var errorCodes42 = [ +var errorCodes43 = [ Diagnostics._0_is_declared_but_its_value_is_never_read.code, Diagnostics._0_is_declared_but_never_used.code, Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code, @@ -159303,7 +161123,7 @@ var errorCodes42 = [ Diagnostics.All_type_parameters_are_unused.code ]; registerCodeFix({ - errorCodes: errorCodes42, + errorCodes: errorCodes43, getCodeActions(context) { const { errorCode, sourceFile, program, cancellationToken } = context; const checker = program.getTypeChecker(); @@ -159392,7 +161212,7 @@ registerCodeFix({ const { sourceFile, program, cancellationToken } = context; const checker = program.getTypeChecker(); const sourceFiles = program.getSourceFiles(); - return codeFixAll(context, errorCodes42, (changes, diag2) => { + return codeFixAll(context, errorCodes43, (changes, diag2) => { const token = getTokenAtPosition(sourceFile, diag2.start); switch (context.fixId) { case fixIdPrefix: @@ -159632,18 +161452,18 @@ function deleteFunctionLikeDeclaration(changes, sourceFile, node) { } // src/services/codefixes/fixUnreachableCode.ts -var fixId33 = "fixUnreachableCode"; -var errorCodes43 = [Diagnostics.Unreachable_code_detected.code]; +var fixId34 = "fixUnreachableCode"; +var errorCodes44 = [Diagnostics.Unreachable_code_detected.code]; registerCodeFix({ - errorCodes: errorCodes43, + errorCodes: errorCodes44, getCodeActions(context) { const syntacticDiagnostics = context.program.getSyntacticDiagnostics(context.sourceFile, context.cancellationToken); if (syntacticDiagnostics.length) return; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, context.sourceFile, context.span.start, context.span.length, context.errorCode)); - return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unreachable_code, fixId33, Diagnostics.Remove_all_unreachable_code)]; + return [createCodeFixAction(fixId34, changes, Diagnostics.Remove_unreachable_code, fixId34, Diagnostics.Remove_all_unreachable_code)]; }, - fixIds: [fixId33], - getAllCodeActions: (context) => codeFixAll(context, errorCodes43, (changes, diag2) => doChange27(changes, diag2.file, diag2.start, diag2.length, diag2.code)) + fixIds: [fixId34], + getAllCodeActions: (context) => codeFixAll(context, errorCodes44, (changes, diag2) => doChange27(changes, diag2.file, diag2.start, diag2.length, diag2.code)) }); function doChange27(changes, sourceFile, start, length2, errorCode) { const token = getTokenAtPosition(sourceFile, start); @@ -159670,6 +161490,7 @@ function doChange27(changes, sourceFile, start, length2, errorCode) { } return; } + // falls through case 247 /* WhileStatement */: case 248 /* ForStatement */: changes.delete(sourceFile, container); @@ -159694,16 +161515,16 @@ function lastWhere(a, pred) { } // src/services/codefixes/fixUnusedLabel.ts -var fixId34 = "fixUnusedLabel"; -var errorCodes44 = [Diagnostics.Unused_label.code]; +var fixId35 = "fixUnusedLabel"; +var errorCodes45 = [Diagnostics.Unused_label.code]; registerCodeFix({ - errorCodes: errorCodes44, + errorCodes: errorCodes45, getCodeActions(context) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, context.sourceFile, context.span.start)); - return [createCodeFixAction(fixId34, changes, Diagnostics.Remove_unused_label, fixId34, Diagnostics.Remove_all_unused_labels)]; + return [createCodeFixAction(fixId35, changes, Diagnostics.Remove_unused_label, fixId35, Diagnostics.Remove_all_unused_labels)]; }, - fixIds: [fixId34], - getAllCodeActions: (context) => codeFixAll(context, errorCodes44, (changes, diag2) => doChange28(changes, diag2.file, diag2.start)) + fixIds: [fixId35], + getAllCodeActions: (context) => codeFixAll(context, errorCodes45, (changes, diag2) => doChange28(changes, diag2.file, diag2.start)) }); function doChange28(changes, sourceFile, start) { const token = getTokenAtPosition(sourceFile, start); @@ -159722,13 +161543,13 @@ function doChange28(changes, sourceFile, start) { // src/services/codefixes/fixJSDocTypes.ts var fixIdPlain = "fixJSDocTypes_plain"; var fixIdNullable = "fixJSDocTypes_nullable"; -var errorCodes45 = [ +var errorCodes46 = [ Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments.code, Diagnostics._0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code, Diagnostics._0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code ]; registerCodeFix({ - errorCodes: errorCodes45, + errorCodes: errorCodes46, getCodeActions(context) { const { sourceFile } = context; const checker = context.program.getTypeChecker(); @@ -159741,20 +161562,20 @@ registerCodeFix({ actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types)); } return actions2; - function fix(type2, fixId55, fixAllDescription) { + function fix(type2, fixId56, fixAllDescription) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, typeNode, type2, checker)); - return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId55, fixAllDescription); + return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId56, fixAllDescription); } }, fixIds: [fixIdPlain, fixIdNullable], getAllCodeActions(context) { - const { fixId: fixId55, program, sourceFile } = context; + const { fixId: fixId56, program, sourceFile } = context; const checker = program.getTypeChecker(); - return codeFixAll(context, errorCodes45, (changes, err) => { + return codeFixAll(context, errorCodes46, (changes, err) => { const info = getInfo15(err.file, err.start, checker); if (!info) return; const { typeNode, type } = info; - const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId55 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type; + const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId56 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type; doChange29(changes, sourceFile, typeNode, fixedType, checker); }); } @@ -159810,21 +161631,21 @@ function getType(checker, node) { } // src/services/codefixes/fixMissingCallParentheses.ts -var fixId35 = "fixMissingCallParentheses"; -var errorCodes46 = [ +var fixId36 = "fixMissingCallParentheses"; +var errorCodes47 = [ Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code ]; registerCodeFix({ - errorCodes: errorCodes46, - fixIds: [fixId35], + errorCodes: errorCodes47, + fixIds: [fixId36], getCodeActions(context) { const { sourceFile, span } = context; const callName = getCallName(sourceFile, span.start); if (!callName) return; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, context.sourceFile, callName)); - return [createCodeFixAction(fixId35, changes, Diagnostics.Add_missing_call_parentheses, fixId35, Diagnostics.Add_all_missing_call_parentheses)]; + return [createCodeFixAction(fixId36, changes, Diagnostics.Add_missing_call_parentheses, fixId36, Diagnostics.Add_all_missing_call_parentheses)]; }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes46, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes47, (changes, diag2) => { const callName = getCallName(diag2.file, diag2.start); if (callName) doChange30(changes, diag2.file, callName); }) @@ -159848,14 +161669,14 @@ function getCallName(sourceFile, start) { } // src/services/codefixes/fixMissingTypeAnnotationOnExports.ts -var fixId36 = "fixMissingTypeAnnotationOnExports"; +var fixId37 = "fixMissingTypeAnnotationOnExports"; var addAnnotationFix = "add-annotation"; var addInlineTypeAssertion = "add-type-assertion"; var extractExpression = "extract-expression"; -var errorCodes47 = [ +var errorCodes48 = [ Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code, Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code, - Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code, + Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code, @@ -159871,7 +161692,7 @@ var errorCodes47 = [ Diagnostics.Default_exports_can_t_be_inferred_with_isolatedDeclarations.code, Diagnostics.Only_const_arrays_can_be_inferred_with_isolatedDeclarations.code, Diagnostics.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function.code, - Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations.code, + Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_its_type_This_is_not_supported_with_isolatedDeclarations.code, Diagnostics.Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations.code, Diagnostics.Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit.code ]; @@ -159892,8 +161713,8 @@ var canHaveTypeAnnotation = /* @__PURE__ */ new Set([ var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */; var declarationEmitInternalNodeBuilderFlags2 = 1 /* WriteComputedProps */; registerCodeFix({ - errorCodes: errorCodes47, - fixIds: [fixId36], + errorCodes: errorCodes48, + fixIds: [fixId37], getCodeActions(context) { const fixes = []; addCodeAction(addAnnotationFix, fixes, context, 0 /* Full */, (f) => f.addTypeAnnotation(context.span)); @@ -159907,7 +161728,7 @@ registerCodeFix({ }, getAllCodeActions: (context) => { const changes = withContext(context, 0 /* Full */, (f) => { - eachDiagnostic(context, errorCodes47, (diag2) => { + eachDiagnostic(context, errorCodes48, (diag2) => { f.addTypeAnnotation(diag2); }); }); @@ -159921,7 +161742,7 @@ function addCodeAction(fixName8, fixes, context, typePrintMode, cb) { fixName8, changes.textChanges, changes.result, - fixId36, + fixId37, Diagnostics.Add_all_missing_type_annotations )); } @@ -160677,7 +162498,7 @@ function withContext(context, typePrintMode, cb) { } function typeToTypeNode2(type, enclosingDeclaration, flags = 0 /* None */) { let isTruncated = false; - const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, { + const minimizedTypeNode = typeToMinimizedReferenceType(typeChecker, type, enclosingDeclaration, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, { moduleResolverHost: program, trackSymbol() { return true; @@ -160686,6 +162507,10 @@ function withContext(context, typePrintMode, cb) { isTruncated = true; } }); + if (!minimizedTypeNode) { + return void 0; + } + const result2 = typeNodeToAutoImportableTypeNode(minimizedTypeNode, importAdder, scriptTarget); return isTruncated ? factory.createKeywordTypeNode(133 /* AnyKeyword */) : result2; } function typePredicateToTypeNode(typePredicate, enclosingDeclaration, flags = 0 /* None */) { @@ -160741,26 +162566,26 @@ function withContext(context, typePrintMode, cb) { } // src/services/codefixes/fixAwaitInSyncFunction.ts -var fixId37 = "fixAwaitInSyncFunction"; -var errorCodes48 = [ +var fixId38 = "fixAwaitInSyncFunction"; +var errorCodes49 = [ Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, Diagnostics.await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code ]; registerCodeFix({ - errorCodes: errorCodes48, + errorCodes: errorCodes49, getCodeActions(context) { const { sourceFile, span } = context; const nodes = getNodes3(sourceFile, span.start); if (!nodes) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, nodes)); - return [createCodeFixAction(fixId37, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId37, Diagnostics.Add_all_missing_async_modifiers)]; + return [createCodeFixAction(fixId38, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId38, Diagnostics.Add_all_missing_async_modifiers)]; }, - fixIds: [fixId37], + fixIds: [fixId38], getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) { - const seen = /* @__PURE__ */ new Map(); - return codeFixAll(context, errorCodes48, (changes, diag2) => { + const seen = /* @__PURE__ */ new Set(); + return codeFixAll(context, errorCodes49, (changes, diag2) => { const nodes = getNodes3(diag2.file, diag2.start); if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore))) return; doChange31(changes, context.sourceFile, nodes); @@ -160813,21 +162638,21 @@ function doChange31(changes, sourceFile, { insertBefore, returnType }) { } // src/services/codefixes/fixPropertyOverrideAccessor.ts -var errorCodes49 = [ +var errorCodes50 = [ Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code, Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code ]; -var fixId38 = "fixPropertyOverrideAccessor"; +var fixId39 = "fixPropertyOverrideAccessor"; registerCodeFix({ - errorCodes: errorCodes49, + errorCodes: errorCodes50, getCodeActions(context) { const edits = doChange32(context.sourceFile, context.span.start, context.span.length, context.errorCode, context); if (edits) { - return [createCodeFixAction(fixId38, edits, Diagnostics.Generate_get_and_set_accessors, fixId38, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)]; + return [createCodeFixAction(fixId39, edits, Diagnostics.Generate_get_and_set_accessors, fixId39, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)]; } }, - fixIds: [fixId38], - getAllCodeActions: (context) => codeFixAll(context, errorCodes49, (changes, diag2) => { + fixIds: [fixId39], + getAllCodeActions: (context) => codeFixAll(context, errorCodes50, (changes, diag2) => { const edits = doChange32(diag2.file, diag2.start, diag2.length, diag2.code, context); if (edits) { for (const edit of edits) { @@ -160863,8 +162688,8 @@ function doChange32(file, start, length2, code, context) { } // src/services/codefixes/inferFromUsage.ts -var fixId39 = "inferFromUsage"; -var errorCodes50 = [ +var fixId40 = "inferFromUsage"; +var errorCodes51 = [ // Variable declarations Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code, // Variable uses @@ -160898,7 +162723,7 @@ var errorCodes50 = [ Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code ]; registerCodeFix({ - errorCodes: errorCodes50, + errorCodes: errorCodes51, getCodeActions(context) { const { sourceFile, program, span: { start }, errorCode, cancellationToken, host, preferences } = context; const token = getTokenAtPosition(sourceFile, start); @@ -160918,13 +162743,13 @@ registerCodeFix({ ); }); const name = declaration && getNameOfDeclaration(declaration); - return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId39, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId39, Diagnostics.Infer_all_types_from_usage)]; + return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId40, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId40, Diagnostics.Infer_all_types_from_usage)]; }, - fixIds: [fixId39], + fixIds: [fixId40], getAllCodeActions(context) { const { sourceFile, program, cancellationToken, host, preferences } = context; const markSeen = nodeSeenTracker(); - return codeFixAll(context, errorCodes50, (changes, err) => { + return codeFixAll(context, errorCodes51, (changes, err) => { doChange33(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences); }); } @@ -160934,6 +162759,7 @@ function getDiagnostic(errorCode, token) { case Diagnostics.Parameter_0_implicitly_has_an_1_type.code: case Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: return isSetAccessorDeclaration(getContainingFunction(token)) ? Diagnostics.Infer_type_of_0_from_usage : Diagnostics.Infer_parameter_types_from_usage; + // TODO: GH#18217 case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code: case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code: return Diagnostics.Infer_parameter_types_from_usage; @@ -160972,6 +162798,7 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation const importAdder = createImportAdder(sourceFile, program, preferences, host); errorCode = mapSuggestionDiagnostic(errorCode); switch (errorCode) { + // Variable and Property declarations case Diagnostics.Member_0_implicitly_has_an_1_type.code: case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code: if (isVariableDeclaration(parent2) && markSeen(parent2) || isPropertyDeclaration(parent2) || isPropertySignature(parent2)) { @@ -161012,12 +162839,14 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation } let declaration; switch (errorCode) { + // Parameter declarations case Diagnostics.Parameter_0_implicitly_has_an_1_type.code: if (isSetAccessorDeclaration(containingFunction)) { annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken); declaration = containingFunction; break; } + // falls through case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code: if (markSeen(containingFunction)) { const param = cast(parent2, isParameter); @@ -161025,6 +162854,7 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation declaration = param; } break; + // Get Accessor declarations case Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code: case Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code: if (isGetAccessorDeclaration(containingFunction) && isIdentifier(containingFunction.name)) { @@ -161032,12 +162862,14 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation declaration = containingFunction; } break; + // Set Accessor declarations case Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code: if (isSetAccessorDeclaration(containingFunction)) { annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken); declaration = containingFunction; } break; + // Function 'this' case Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code: if (ts_textChanges_exports.isThisTypeAnnotatable(containingFunction) && markSeen(containingFunction)) { annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken); @@ -161419,6 +163251,7 @@ function inferTypeFromReferences(program, references, cancellationToken) { break; } } + // falls through default: return inferTypeFromContextualType(node, usage); } @@ -161446,16 +163279,25 @@ function inferTypeFromReferences(program, references, cancellationToken) { } function inferTypeFromBinaryExpression(node, parent2, usage) { switch (parent2.operatorToken.kind) { + // ExponentiationOperator case 43 /* AsteriskAsteriskToken */: + // MultiplicativeOperator + // falls through case 42 /* AsteriskToken */: case 44 /* SlashToken */: case 45 /* PercentToken */: + // ShiftOperator + // falls through case 48 /* LessThanLessThanToken */: case 49 /* GreaterThanGreaterThanToken */: case 50 /* GreaterThanGreaterThanGreaterThanToken */: + // BitwiseOperator + // falls through case 51 /* AmpersandToken */: case 52 /* BarToken */: case 53 /* CaretToken */: + // CompoundAssignmentOperator + // falls through case 66 /* MinusEqualsToken */: case 68 /* AsteriskAsteriskEqualsToken */: case 67 /* AsteriskEqualsToken */: @@ -161467,7 +163309,11 @@ function inferTypeFromReferences(program, references, cancellationToken) { case 71 /* LessThanLessThanEqualsToken */: case 73 /* GreaterThanGreaterThanGreaterThanEqualsToken */: case 72 /* GreaterThanGreaterThanEqualsToken */: + // AdditiveOperator + // falls through case 41 /* MinusToken */: + // RelationalOperator + // falls through case 30 /* LessThanToken */: case 33 /* LessThanEqualsToken */: case 32 /* GreaterThanToken */: @@ -161493,6 +163339,7 @@ function inferTypeFromReferences(program, references, cancellationToken) { usage.isNumberOrString = true; } break; + // AssignmentOperators case 64 /* EqualsToken */: case 35 /* EqualsEqualsToken */: case 37 /* EqualsEqualsEqualsToken */: @@ -161508,6 +163355,7 @@ function inferTypeFromReferences(program, references, cancellationToken) { usage.isString = true; } break; + // LogicalOperator Or NullishCoalescing case 57 /* BarBarToken */: case 61 /* QuestionQuestionToken */: if (node === parent2.left && (node.parent.parent.kind === 260 /* VariableDeclaration */ || isAssignmentExpression( @@ -161855,13 +163703,13 @@ function inferTypeFromReferences(program, references, cancellationToken) { } // src/services/codefixes/fixReturnTypeInAsyncFunction.ts -var fixId40 = "fixReturnTypeInAsyncFunction"; -var errorCodes51 = [ +var fixId41 = "fixReturnTypeInAsyncFunction"; +var errorCodes52 = [ Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code ]; registerCodeFix({ - errorCodes: errorCodes51, - fixIds: [fixId40], + errorCodes: errorCodes52, + fixIds: [fixId41], getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) { const { sourceFile, program, span } = context; const checker = program.getTypeChecker(); @@ -161872,14 +163720,14 @@ registerCodeFix({ const { returnTypeNode, returnType, promisedTypeNode, promisedType } = info; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(t, sourceFile, returnTypeNode, promisedTypeNode)); return [createCodeFixAction( - fixId40, + fixId41, changes, [Diagnostics.Replace_0_with_Promise_1, checker.typeToString(returnType), checker.typeToString(promisedType)], - fixId40, + fixId41, Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions )]; }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes51, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => { const info = getInfo16(diag2.file, context.program.getTypeChecker(), diag2.start); if (info) { doChange34(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode); @@ -161915,13 +163763,13 @@ function doChange34(changes, sourceFile, returnTypeNode, promisedTypeNode) { // src/services/codefixes/disableJsDiagnostics.ts var fixName4 = "disableJsDiagnostics"; -var fixId41 = "disableJsDiagnostics"; -var errorCodes52 = mapDefined(Object.keys(Diagnostics), (key) => { +var fixId42 = "disableJsDiagnostics"; +var errorCodes53 = mapDefined(Object.keys(Diagnostics), (key) => { const diag2 = Diagnostics[key]; return diag2.category === 1 /* Error */ ? diag2.code : void 0; }); registerCodeFix({ - errorCodes: errorCodes52, + errorCodes: errorCodes53, getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) { const { sourceFile, program, span, host, formatContext } = context; if (!isInJSFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) { @@ -161942,21 +163790,21 @@ registerCodeFix({ ) ]; if (ts_textChanges_exports.isValidLocationToAddComment(sourceFile, span.start)) { - fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId41, Diagnostics.Add_ts_ignore_to_all_error_messages)); + fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange9(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId42, Diagnostics.Add_ts_ignore_to_all_error_messages)); } return fixes; }, - fixIds: [fixId41], + fixIds: [fixId42], getAllCodeActions: (context) => { const seenLines = /* @__PURE__ */ new Set(); - return codeFixAll(context, errorCodes52, (changes, diag2) => { + return codeFixAll(context, errorCodes53, (changes, diag2) => { if (ts_textChanges_exports.isValidLocationToAddComment(diag2.file, diag2.start)) { - makeChange8(changes, diag2.file, diag2.start, seenLines); + makeChange9(changes, diag2.file, diag2.start, seenLines); } }); } }); -function makeChange8(changes, sourceFile, position, seenLines) { +function makeChange9(changes, sourceFile, position, seenLines) { const { line: lineNumber } = getLineAndCharacterOfPosition(sourceFile, position); if (!seenLines || tryAddToSet(seenLines, lineNumber)) { changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore"); @@ -162012,11 +163860,10 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con const optional = !!(symbol.flags & 16777216 /* Optional */); const ambient = !!(enclosingDeclaration.flags & 33554432 /* Ambient */) || isAmbient; const quotePreference = getQuotePreference(sourceFile, preferences); + const flags = 1 /* NoTruncation */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */); switch (kind) { case 171 /* PropertySignature */: case 172 /* PropertyDeclaration */: - let flags = 1 /* NoTruncation */; - flags |= quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0; let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context)); if (importAdder) { const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget); @@ -162040,8 +163887,7 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con let typeNode2 = checker.typeToTypeNode( type, enclosingDeclaration, - /*flags*/ - void 0, + flags, /*internalFlags*/ void 0, getNoopSymbolTrackerWithResolver(context) @@ -162368,7 +164214,13 @@ function createTypeParameterName(index) { return 84 /* T */ + index <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + index) : `T${index}`; } function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, internalFlags, tracker) { - let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker); + const typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker); + if (!typeNode) { + return void 0; + } + return typeNodeToAutoImportableTypeNode(typeNode, importAdder, scriptTarget); +} +function typeNodeToAutoImportableTypeNode(typeNode, importAdder, scriptTarget) { if (typeNode && isImportTypeNode(typeNode)) { const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget); if (importableReference) { @@ -162378,6 +164230,42 @@ function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, s } return getSynthesizedDeepClone(typeNode); } +function endOfRequiredTypeParameters(checker, type) { + Debug.assert(type.typeArguments); + const fullTypeArguments = type.typeArguments; + const target = type.target; + for (let cutoff = 0; cutoff < fullTypeArguments.length; cutoff++) { + const typeArguments = fullTypeArguments.slice(0, cutoff); + const filledIn = checker.fillMissingTypeArguments( + typeArguments, + target.typeParameters, + cutoff, + /*isJavaScriptImplicitAny*/ + false + ); + if (filledIn.every((fill, i) => fill === fullTypeArguments[i])) { + return cutoff; + } + } + return fullTypeArguments.length; +} +function typeToMinimizedReferenceType(checker, type, contextNode, flags, internalFlags, tracker) { + let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker); + if (!typeNode) { + return void 0; + } + if (isTypeReferenceNode(typeNode)) { + const genericType = type; + if (genericType.typeArguments && typeNode.typeArguments) { + const cutoff = endOfRequiredTypeParameters(checker, genericType); + if (cutoff < typeNode.typeArguments.length) { + const newTypeArguments = factory.createNodeArray(typeNode.typeArguments.slice(0, cutoff)); + typeNode = factory.updateTypeReferenceNode(typeNode, typeNode.typeName, newTypeArguments); + } + } + } + return typeNode; +} function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, internalFlags, tracker) { let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, internalFlags, tracker); if ((typePredicateNode == null ? void 0 : typePredicateNode.type) && isImportTypeNode(typePredicateNode.type)) { @@ -162969,9 +164857,9 @@ var fixName6 = "strictClassInitialization"; var fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions"; var fixIdAddUndefinedType = "addMissingPropertyUndefinedType"; var fixIdAddInitializer = "addMissingPropertyInitializer"; -var errorCodes53 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code]; +var errorCodes54 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code]; registerCodeFix({ - errorCodes: errorCodes53, + errorCodes: errorCodes54, getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) { const info = getInfo17(context.sourceFile, context.span.start); if (!info) return; @@ -162983,7 +164871,7 @@ registerCodeFix({ }, fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer], getAllCodeActions: (context) => { - return codeFixAll(context, errorCodes53, (changes, diag2) => { + return codeFixAll(context, errorCodes54, (changes, diag2) => { const info = getInfo17(diag2.file, diag2.start); if (!info) return; switch (context.fixId) { @@ -163106,20 +164994,20 @@ function getDefaultValueFromType(checker, type) { } // src/services/codefixes/requireInTs.ts -var fixId42 = "requireInTs"; -var errorCodes54 = [Diagnostics.require_call_may_be_converted_to_an_import.code]; +var fixId43 = "requireInTs"; +var errorCodes55 = [Diagnostics.require_call_may_be_converted_to_an_import.code]; registerCodeFix({ - errorCodes: errorCodes54, + errorCodes: errorCodes55, getCodeActions(context) { const info = getInfo18(context.sourceFile, context.program, context.span.start, context.preferences); if (!info) { return void 0; } const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(t, context.sourceFile, info)); - return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_require_to_import, fixId42, Diagnostics.Convert_all_require_to_import)]; + return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_require_to_import, fixId43, Diagnostics.Convert_all_require_to_import)]; }, - fixIds: [fixId42], - getAllCodeActions: (context) => codeFixAll(context, errorCodes54, (changes, diag2) => { + fixIds: [fixId43], + getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => { const info = getInfo18(diag2.file, context.program, diag2.start, context.preferences); if (info) { doChange35(changes, context.sourceFile, info); @@ -163196,19 +165084,19 @@ function tryCreateNamedImportsFromObjectBindingPattern(node) { } // src/services/codefixes/useDefaultImport.ts -var fixId43 = "useDefaultImport"; -var errorCodes55 = [Diagnostics.Import_may_be_converted_to_a_default_import.code]; +var fixId44 = "useDefaultImport"; +var errorCodes56 = [Diagnostics.Import_may_be_converted_to_a_default_import.code]; registerCodeFix({ - errorCodes: errorCodes55, + errorCodes: errorCodes56, getCodeActions(context) { const { sourceFile, span: { start } } = context; const info = getInfo19(sourceFile, start); if (!info) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange36(t, sourceFile, info, context.preferences)); - return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_to_default_import, fixId43, Diagnostics.Convert_all_to_default_imports)]; + return [createCodeFixAction(fixId44, changes, Diagnostics.Convert_to_default_import, fixId44, Diagnostics.Convert_all_to_default_imports)]; }, - fixIds: [fixId43], - getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => { + fixIds: [fixId44], + getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => { const info = getInfo19(diag2.file, diag2.start); if (info) doChange36(changes, diag2.file, info, context.preferences); }) @@ -163235,24 +165123,24 @@ function doChange36(changes, sourceFile, info, preferences) { } // src/services/codefixes/useBigintLiteral.ts -var fixId44 = "useBigintLiteral"; -var errorCodes56 = [ +var fixId45 = "useBigintLiteral"; +var errorCodes57 = [ Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code ]; registerCodeFix({ - errorCodes: errorCodes56, + errorCodes: errorCodes57, getCodeActions: function getCodeActionsToUseBigintLiteral(context) { - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange9(t, context.sourceFile, context.span)); + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span)); if (changes.length > 0) { - return [createCodeFixAction(fixId44, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId44, Diagnostics.Convert_all_to_bigint_numeric_literals)]; + return [createCodeFixAction(fixId45, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId45, Diagnostics.Convert_all_to_bigint_numeric_literals)]; } }, - fixIds: [fixId44], + fixIds: [fixId45], getAllCodeActions: (context) => { - return codeFixAll(context, errorCodes56, (changes, diag2) => makeChange9(changes, diag2.file, diag2)); + return codeFixAll(context, errorCodes57, (changes, diag2) => makeChange10(changes, diag2.file, diag2)); } }); -function makeChange9(changeTracker, sourceFile, span) { +function makeChange10(changeTracker, sourceFile, span) { const numericLiteral = tryCast(getTokenAtPosition(sourceFile, span.start), isNumericLiteral); if (!numericLiteral) { return; @@ -163263,18 +165151,18 @@ function makeChange9(changeTracker, sourceFile, span) { // src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts var fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof"; -var fixId45 = fixIdAddMissingTypeof; -var errorCodes57 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code]; +var fixId46 = fixIdAddMissingTypeof; +var errorCodes58 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code]; registerCodeFix({ - errorCodes: errorCodes57, + errorCodes: errorCodes58, getCodeActions: function getCodeActionsToAddMissingTypeof(context) { const { sourceFile, span } = context; const importType = getImportTypeNode(sourceFile, span.start); const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(t, sourceFile, importType)); - return [createCodeFixAction(fixId45, changes, Diagnostics.Add_missing_typeof, fixId45, Diagnostics.Add_missing_typeof)]; + return [createCodeFixAction(fixId46, changes, Diagnostics.Add_missing_typeof, fixId46, Diagnostics.Add_missing_typeof)]; }, - fixIds: [fixId45], - getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => doChange37(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start))) + fixIds: [fixId46], + getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => doChange37(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start))) }); function getImportTypeNode(sourceFile, pos) { const token = getTokenAtPosition(sourceFile, pos); @@ -163297,9 +165185,9 @@ function doChange37(changes, sourceFile, importType) { // src/services/codefixes/wrapJsxInFragment.ts var fixID2 = "wrapJsxInFragment"; -var errorCodes58 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code]; +var errorCodes59 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code]; registerCodeFix({ - errorCodes: errorCodes58, + errorCodes: errorCodes59, getCodeActions: function getCodeActionsToWrapJsxInFragment(context) { const { sourceFile, span } = context; const node = findNodeToFix(sourceFile, span.start); @@ -163308,7 +165196,7 @@ registerCodeFix({ return [createCodeFixAction(fixID2, changes, Diagnostics.Wrap_in_JSX_fragment, fixID2, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)]; }, fixIds: [fixID2], - getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, diag2) => { const node = findNodeToFix(context.sourceFile, diag2.start); if (!node) return void 0; doChange38(changes, context.sourceFile, node); @@ -163347,18 +165235,18 @@ function flattenInvalidBinaryExpr(node) { } // src/services/codefixes/wrapDecoratorInParentheses.ts -var fixId46 = "wrapDecoratorInParentheses"; -var errorCodes59 = [Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code]; +var fixId47 = "wrapDecoratorInParentheses"; +var errorCodes60 = [Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code]; registerCodeFix({ - errorCodes: errorCodes59, + errorCodes: errorCodes60, getCodeActions: function getCodeActionsToWrapDecoratorExpressionInParentheses(context) { - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span.start)); - return [createCodeFixAction(fixId46, changes, Diagnostics.Wrap_in_parentheses, fixId46, Diagnostics.Wrap_all_invalid_decorator_expressions_in_parentheses)]; + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span.start)); + return [createCodeFixAction(fixId47, changes, Diagnostics.Wrap_in_parentheses, fixId47, Diagnostics.Wrap_all_invalid_decorator_expressions_in_parentheses)]; }, - fixIds: [fixId46], - getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, diag2) => makeChange10(changes, diag2.file, diag2.start)) + fixIds: [fixId47], + getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, diag2) => makeChange11(changes, diag2.file, diag2.start)) }); -function makeChange10(changeTracker, sourceFile, pos) { +function makeChange11(changeTracker, sourceFile, pos) { const token = getTokenAtPosition(sourceFile, pos); const decorator = findAncestor(token, isDecorator); Debug.assert(!!decorator, "Expected position to be owned by a decorator."); @@ -163367,20 +165255,20 @@ function makeChange10(changeTracker, sourceFile, pos) { } // src/services/codefixes/convertToMappedObjectType.ts -var fixId47 = "fixConvertToMappedObjectType"; -var errorCodes60 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code]; +var fixId48 = "fixConvertToMappedObjectType"; +var errorCodes61 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code]; registerCodeFix({ - errorCodes: errorCodes60, + errorCodes: errorCodes61, getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) { const { sourceFile, span } = context; const info = getInfo20(sourceFile, span.start); if (!info) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange39(t, sourceFile, info)); const name = idText(info.container.name); - return [createCodeFixAction(fixId47, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId47, [Diagnostics.Convert_0_to_mapped_object_type, name])]; + return [createCodeFixAction(fixId48, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId48, [Diagnostics.Convert_0_to_mapped_object_type, name])]; }, - fixIds: [fixId47], - getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, diag2) => { + fixIds: [fixId48], + getAllCodeActions: (context) => codeFixAll(context, errorCodes61, (changes, diag2) => { const info = getInfo20(diag2.file, diag2.start); if (info) doChange39(changes, diag2.file, info); }) @@ -163425,12 +165313,12 @@ function doChange39(changes, sourceFile, { indexSignature, container }) { } // src/services/codefixes/removeAccidentalCallParentheses.ts -var fixId48 = "removeAccidentalCallParentheses"; -var errorCodes61 = [ +var fixId49 = "removeAccidentalCallParentheses"; +var errorCodes62 = [ Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code ]; registerCodeFix({ - errorCodes: errorCodes61, + errorCodes: errorCodes62, getCodeActions(context) { const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression); if (!callExpression) { @@ -163439,30 +165327,30 @@ registerCodeFix({ const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => { t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end }); }); - return [createCodeFixActionWithoutFixAll(fixId48, changes, Diagnostics.Remove_parentheses)]; + return [createCodeFixActionWithoutFixAll(fixId49, changes, Diagnostics.Remove_parentheses)]; }, - fixIds: [fixId48] + fixIds: [fixId49] }); // src/services/codefixes/removeUnnecessaryAwait.ts -var fixId49 = "removeUnnecessaryAwait"; -var errorCodes62 = [ +var fixId50 = "removeUnnecessaryAwait"; +var errorCodes63 = [ Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code ]; registerCodeFix({ - errorCodes: errorCodes62, + errorCodes: errorCodes63, getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) { - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span)); + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange12(t, context.sourceFile, context.span)); if (changes.length > 0) { - return [createCodeFixAction(fixId49, changes, Diagnostics.Remove_unnecessary_await, fixId49, Diagnostics.Remove_all_unnecessary_uses_of_await)]; + return [createCodeFixAction(fixId50, changes, Diagnostics.Remove_unnecessary_await, fixId50, Diagnostics.Remove_all_unnecessary_uses_of_await)]; } }, - fixIds: [fixId49], + fixIds: [fixId50], getAllCodeActions: (context) => { - return codeFixAll(context, errorCodes62, (changes, diag2) => makeChange11(changes, diag2.file, diag2)); + return codeFixAll(context, errorCodes63, (changes, diag2) => makeChange12(changes, diag2.file, diag2)); } }); -function makeChange11(changeTracker, sourceFile, span) { +function makeChange12(changeTracker, sourceFile, span) { const awaitKeyword = tryCast(getTokenAtPosition(sourceFile, span.start), (node) => node.kind === 135 /* AwaitKeyword */); const awaitExpression = awaitKeyword && tryCast(awaitKeyword.parent, isAwaitExpression); if (!awaitExpression) { @@ -163487,20 +165375,20 @@ function makeChange11(changeTracker, sourceFile, span) { } // src/services/codefixes/splitTypeOnlyImport.ts -var errorCodes63 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code]; -var fixId50 = "splitTypeOnlyImport"; +var errorCodes64 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code]; +var fixId51 = "splitTypeOnlyImport"; registerCodeFix({ - errorCodes: errorCodes63, - fixIds: [fixId50], + errorCodes: errorCodes64, + fixIds: [fixId51], getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) { const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => { return splitTypeOnlyImport(t, getImportDeclaration2(context.sourceFile, context.span), context); }); if (changes.length) { - return [createCodeFixAction(fixId50, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId50, Diagnostics.Split_all_invalid_type_only_imports)]; + return [createCodeFixAction(fixId51, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId51, Diagnostics.Split_all_invalid_type_only_imports)]; } }, - getAllCodeActions: (context) => codeFixAll(context, errorCodes63, (changes, error2) => { + getAllCodeActions: (context) => codeFixAll(context, errorCodes64, (changes, error2) => { splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error2), context); }) }); @@ -163549,22 +165437,22 @@ function splitTypeOnlyImport(changes, importDeclaration, context) { } // src/services/codefixes/convertConstToLet.ts -var fixId51 = "fixConvertConstToLet"; -var errorCodes64 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code]; +var fixId52 = "fixConvertConstToLet"; +var errorCodes65 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code]; registerCodeFix({ - errorCodes: errorCodes64, + errorCodes: errorCodes65, getCodeActions: function getCodeActionsToConvertConstToLet(context) { const { sourceFile, span, program } = context; const info = getInfo21(sourceFile, span.start, program); if (info === void 0) return; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange40(t, sourceFile, info.token)); - return [createCodeFixActionMaybeFixAll(fixId51, changes, Diagnostics.Convert_const_to_let, fixId51, Diagnostics.Convert_all_const_to_let)]; + return [createCodeFixActionMaybeFixAll(fixId52, changes, Diagnostics.Convert_const_to_let, fixId52, Diagnostics.Convert_all_const_to_let)]; }, getAllCodeActions: (context) => { const { program } = context; - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => { - eachDiagnostic(context, errorCodes64, (diag2) => { + eachDiagnostic(context, errorCodes65, (diag2) => { const info = getInfo21(diag2.file, diag2.start, program); if (info) { if (addToSeen(seen, getSymbolId(info.symbol))) { @@ -163575,7 +165463,7 @@ registerCodeFix({ }); })); }, - fixIds: [fixId51] + fixIds: [fixId52] }); function getInfo21(sourceFile, pos, program) { var _a; @@ -163593,26 +165481,26 @@ function doChange40(changes, sourceFile, token) { } // src/services/codefixes/fixExpectedComma.ts -var fixId52 = "fixExpectedComma"; +var fixId53 = "fixExpectedComma"; var expectedErrorCode = Diagnostics._0_expected.code; -var errorCodes65 = [expectedErrorCode]; +var errorCodes66 = [expectedErrorCode]; registerCodeFix({ - errorCodes: errorCodes65, + errorCodes: errorCodes66, getCodeActions(context) { const { sourceFile } = context; const info = getInfo22(sourceFile, context.span.start, context.errorCode); if (!info) return void 0; const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange41(t, sourceFile, info)); return [createCodeFixAction( - fixId52, + fixId53, changes, [Diagnostics.Change_0_to_1, ";", ","], - fixId52, + fixId53, [Diagnostics.Change_0_to_1, ";", ","] )]; }, - fixIds: [fixId52], - getAllCodeActions: (context) => codeFixAll(context, errorCodes65, (changes, diag2) => { + fixIds: [fixId53], + getAllCodeActions: (context) => codeFixAll(context, errorCodes66, (changes, diag2) => { const info = getInfo22(diag2.file, diag2.start, diag2.code); if (info) doChange41(changes, context.sourceFile, info); }) @@ -163628,25 +165516,25 @@ function doChange41(changes, sourceFile, { node }) { // src/services/codefixes/fixAddVoidToPromise.ts var fixName7 = "addVoidToPromise"; -var fixId53 = "addVoidToPromise"; -var errorCodes66 = [ +var fixId54 = "addVoidToPromise"; +var errorCodes67 = [ Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code, Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code ]; registerCodeFix({ - errorCodes: errorCodes66, - fixIds: [fixId53], + errorCodes: errorCodes67, + fixIds: [fixId54], getCodeActions(context) { - const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange12(t, context.sourceFile, context.span, context.program)); + const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange13(t, context.sourceFile, context.span, context.program)); if (changes.length > 0) { - return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId53, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)]; + return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId54, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)]; } }, getAllCodeActions(context) { - return codeFixAll(context, errorCodes66, (changes, diag2) => makeChange12(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set())); + return codeFixAll(context, errorCodes67, (changes, diag2) => makeChange13(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set())); } }); -function makeChange12(changes, sourceFile, span, program, seen) { +function makeChange13(changes, sourceFile, span, program, seen) { const node = getTokenAtPosition(sourceFile, span.start); if (!isIdentifier(node) || !isCallExpression(node.parent) || node.parent.expression !== node || node.parent.arguments.length !== 0) return; const checker = program.getTypeChecker(); @@ -163738,6 +165626,8 @@ var SortText = { return sortText + "1"; } }; +var allCommitCharacters = [".", ",", ";"]; +var noCommaCommitCharacters = [".", ";"]; var CompletionSource = /* @__PURE__ */ ((CompletionSource2) => { CompletionSource2["ThisProperty"] = "ThisProperty/"; CompletionSource2["ClassMemberSnippet"] = "ClassMemberSnippet/"; @@ -163844,7 +165734,7 @@ function getDefaultCommitCharacters(isNewIdentifierLocation) { if (isNewIdentifierLocation) { return []; } - return [".", ",", ";"]; + return allCommitCharacters; } function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext, includeSymbol = false) { var _a; @@ -164342,7 +166232,8 @@ function completionInfoFromData(sourceFile, host, program, compilerOptions, log, importStatementCompletion, insideJsDocTagTypeExpression, symbolToSortTextMap, - hasUnresolvedAutoImports + hasUnresolvedAutoImports, + defaultCommitCharacters } = completionData; let literals = completionData.literals; const checker = program.getTypeChecker(); @@ -164460,7 +166351,7 @@ function completionInfoFromData(sourceFile, host, program, compilerOptions, log, isNewIdentifierLocation, optionalReplacementSpan: getOptionalReplacementSpan(location), entries, - defaultCommitCharacters: getDefaultCommitCharacters(isNewIdentifierLocation) + defaultCommitCharacters: defaultCommitCharacters ?? getDefaultCommitCharacters(isNewIdentifierLocation) }; } function isCheckedFile(sourceFile, compilerOptions) { @@ -164795,9 +166686,13 @@ function createCompletionEntry(symbol, sortText, replacementToken, contextToken, if (parentNamedImportOrExport) { const languageVersion = getEmitScriptTarget(host.getCompilationSettings()); if (!isIdentifierText(name, languageVersion)) { - insertText = JSON.stringify(name); + insertText = quotePropertyName(sourceFile, preferences, name); if (parentNamedImportOrExport.kind === 275 /* NamedImports */) { - insertText += " as " + generateIdentifierForArbitraryString(name, languageVersion); + scanner.setText(sourceFile.text); + scanner.resetTokenState(position); + if (!(scanner.scan() === 130 /* AsKeyword */ && scanner.scan() === 80 /* Identifier */)) { + insertText += " as " + generateIdentifierForArbitraryString(name, languageVersion); + } } } else if (parentNamedImportOrExport.kind === 275 /* NamedImports */) { const possibleToken = stringToToken(name); @@ -165359,7 +167254,7 @@ function getSourceFromOrigin(origin) { } function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, position, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag, includeSymbol = false) { const start = timestamp(); - const variableOrParameterDeclaration = getVariableOrParameterDeclaration(contextToken, location); + const closestSymbolDeclaration = getClosestSymbolDeclaration(contextToken, location); const useSemicolons = probablyUsesSemicolons(sourceFile); const typeChecker = program.getTypeChecker(); const uniques = /* @__PURE__ */ new Map(); @@ -165429,15 +167324,26 @@ function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, con if (isExportAssignment(location.parent)) { return true; } - if (tryCast(variableOrParameterDeclaration, isVariableDeclaration) && symbol.valueDeclaration === variableOrParameterDeclaration) { + if (tryCast(closestSymbolDeclaration, isVariableDeclaration) && symbol.valueDeclaration === closestSymbolDeclaration) { return false; } const symbolDeclaration = symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]); - if (variableOrParameterDeclaration && symbolDeclaration && (isTypeParameterDeclaration(variableOrParameterDeclaration) && isTypeParameterDeclaration(symbolDeclaration) || isParameter(variableOrParameterDeclaration) && isParameter(symbolDeclaration))) { - const symbolDeclarationPos = symbolDeclaration.pos; - const parameters = isParameter(variableOrParameterDeclaration) ? variableOrParameterDeclaration.parent.parameters : isInferTypeNode(variableOrParameterDeclaration.parent) ? void 0 : variableOrParameterDeclaration.parent.typeParameters; - if (symbolDeclarationPos >= variableOrParameterDeclaration.pos && parameters && symbolDeclarationPos < parameters.end) { - return false; + if (closestSymbolDeclaration && symbolDeclaration) { + if (isParameter(closestSymbolDeclaration) && isParameter(symbolDeclaration)) { + const parameters = closestSymbolDeclaration.parent.parameters; + if (symbolDeclaration.pos >= closestSymbolDeclaration.pos && symbolDeclaration.pos < parameters.end) { + return false; + } + } else if (isTypeParameterDeclaration(closestSymbolDeclaration) && isTypeParameterDeclaration(symbolDeclaration)) { + if (closestSymbolDeclaration === symbolDeclaration && (contextToken == null ? void 0 : contextToken.kind) === 96 /* ExtendsKeyword */) { + return false; + } + if (isInTypeParameterDefault(contextToken) && !isInferTypeNode(closestSymbolDeclaration.parent)) { + const typeParameters = closestSymbolDeclaration.parent.typeParameters; + if (typeParameters && symbolDeclaration.pos >= closestSymbolDeclaration.pos && symbolDeclaration.pos < typeParameters.end) { + return false; + } + } } } const symbolOrigin = skipAlias(symbol, typeChecker); @@ -165754,6 +167660,7 @@ function getContextualType(previousToken, position, sourceFile, checker) { switch (parent2.kind) { case 260 /* VariableDeclaration */: return checker.getContextualType(parent2.initializer); + // TODO: GH#18217 case 226 /* BinaryExpression */: return checker.getTypeAtLocation(parent2.left); case 291 /* JsxAttribute */: @@ -165859,6 +167766,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, let keywordFilters = 0 /* None */; let isNewIdentifierLocation = false; let flags = 0 /* None */; + let defaultCommitCharacters; if (contextToken) { const importStatementCompletionInfo = getImportStatementCompletionInfo(contextToken, sourceFile); if (importStatementCompletionInfo.keywordCompletion) { @@ -165878,7 +167786,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, } if (!importStatementCompletionInfo.replacementSpan && isCompletionListBlocker(contextToken)) { log("Returning an empty list because completion was requested in an invalid position."); - return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation()) : void 0; + return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, computeCommitCharactersAndIsNewIdentifier().isNewIdentifierLocation) : void 0; } let parent2 = contextToken.parent; if (contextToken.kind === 25 /* DotToken */ || contextToken.kind === 29 /* QuestionDotToken */) { @@ -165939,6 +167847,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, if (!binaryExpressionMayBeOpenTag(parent2)) { break; } + // falls through case 285 /* JsxSelfClosingElement */: case 284 /* JsxElement */: case 286 /* JsxOpeningElement */: @@ -165980,7 +167889,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, let importSpecifierResolver; const symbolToOriginInfoMap = []; const symbolToSortTextMap = []; - const seenPropertySymbols = /* @__PURE__ */ new Map(); + const seenPropertySymbols = /* @__PURE__ */ new Set(); const isTypeOnlyLocation = isTypeOnlyCompletion(); const getModuleSpecifierResolutionHost = memoizeOne((isFromPackageJson) => { return createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host); @@ -166037,7 +167946,8 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, isRightOfDotOrQuestionDot: isRightOfDot || isRightOfQuestionDot, importStatementCompletion, hasUnresolvedAutoImports, - flags + flags, + defaultCommitCharacters }; function isTagWithTypeExpression(tag) { switch (tag.kind) { @@ -166072,7 +167982,10 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node); if (isEntityName(node) || isImportType || isPropertyAccessExpression(node)) { const isNamespaceName = isModuleDeclaration(node.parent); - if (isNamespaceName) isNewIdentifierLocation = true; + if (isNamespaceName) { + isNewIdentifierLocation = true; + defaultCommitCharacters = []; + } let symbol = typeChecker.getSymbolAtLocation(node); if (symbol) { symbol = skipAlias(symbol, typeChecker); @@ -166142,9 +168055,13 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, } } function addTypeProperties(type, insertAwait, insertQuestionDot) { - isNewIdentifierLocation = !!type.getStringIndexType(); + if (type.getStringIndexType()) { + isNewIdentifierLocation = true; + defaultCommitCharacters = []; + } if (isRightOfQuestionDot && some(type.getCallSignatures())) { isNewIdentifierLocation = true; + defaultCommitCharacters ?? (defaultCommitCharacters = allCommitCharacters); } const propertyAccess = node.kind === 205 /* ImportType */ ? node : node.parent; if (inCheckedFile) { @@ -166283,7 +168200,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, function getGlobalCompletions() { keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 5 /* FunctionLikeBodyKeywords */ : 1 /* All */; completionKind = 1 /* Global */; - isNewIdentifierLocation = isNewIdentifierDefinitionLocation(); + ({ isNewIdentifierLocation, defaultCommitCharacters } = computeCommitCharactersAndIsNewIdentifier()); if (previousToken !== contextToken) { Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); } @@ -166445,18 +168362,11 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, } ); function isImportableExportInfo(info) { - const moduleFile = tryCast(info.moduleSymbol.valueDeclaration, isSourceFile); - if (!moduleFile) { - const moduleName = stripQuotes(info.moduleSymbol.name); - if (ts_JsTyping_exports.nodeCoreModules.has(moduleName) && startsWith(moduleName, "node:") !== shouldUseUriStyleNodeCoreModules(sourceFile, program)) { - return false; - } - return ((packageJsonFilter == null ? void 0 : packageJsonFilter.allowsImportingAmbientModule(info.moduleSymbol, getModuleSpecifierResolutionHost(info.isFromPackageJson))) ?? true) || fileContainsPackageImport(sourceFile, moduleName); - } - return isImportableFile( + return isImportable( info.isFromPackageJson ? packageJsonAutoImportProvider : program, sourceFile, - moduleFile, + tryCast(info.moduleSymbol.valueDeclaration, isSourceFile), + info.moduleSymbol, preferences, packageJsonFilter, getModuleSpecifierResolutionHost(info.isFromPackageJson), @@ -166549,41 +168459,121 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, } return false; } - function isNewIdentifierDefinitionLocation() { + function computeCommitCharactersAndIsNewIdentifier() { if (contextToken) { const containingNodeKind = contextToken.parent.kind; const tokenKind = keywordForNode(contextToken); switch (tokenKind) { case 28 /* CommaToken */: - return containingNodeKind === 213 /* CallExpression */ || containingNodeKind === 176 /* Constructor */ || containingNodeKind === 214 /* NewExpression */ || containingNodeKind === 209 /* ArrayLiteralExpression */ || containingNodeKind === 226 /* BinaryExpression */ || containingNodeKind === 184 /* FunctionType */ || containingNodeKind === 210 /* ObjectLiteralExpression */; + switch (containingNodeKind) { + case 213 /* CallExpression */: + // func( a, | + case 214 /* NewExpression */: { + const expression = contextToken.parent.expression; + if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) { + return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true }; + } + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true }; + } + case 226 /* BinaryExpression */: + return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true }; + case 176 /* Constructor */: + // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */ + case 184 /* FunctionType */: + // var x: (s: string, list| + case 210 /* ObjectLiteralExpression */: + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; + case 209 /* ArrayLiteralExpression */: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 21 /* OpenParenToken */: - return containingNodeKind === 213 /* CallExpression */ || containingNodeKind === 176 /* Constructor */ || containingNodeKind === 214 /* NewExpression */ || containingNodeKind === 217 /* ParenthesizedExpression */ || containingNodeKind === 196 /* ParenthesizedType */; + switch (containingNodeKind) { + case 213 /* CallExpression */: + // func( | + case 214 /* NewExpression */: { + const expression = contextToken.parent.expression; + if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) { + return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true }; + } + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true }; + } + case 217 /* ParenthesizedExpression */: + return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true }; + case 176 /* Constructor */: + // constructor( | + case 196 /* ParenthesizedType */: + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 23 /* OpenBracketToken */: - return containingNodeKind === 209 /* ArrayLiteralExpression */ || containingNodeKind === 181 /* IndexSignature */ || containingNodeKind === 167 /* ComputedPropertyName */; + switch (containingNodeKind) { + case 209 /* ArrayLiteralExpression */: + // [ | + case 181 /* IndexSignature */: + // [ | : string ] + case 189 /* TupleType */: + // [ | : string ] + case 167 /* ComputedPropertyName */: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 144 /* ModuleKeyword */: + // module | case 145 /* NamespaceKeyword */: + // namespace | case 102 /* ImportKeyword */: - return true; + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; case 25 /* DotToken */: - return containingNodeKind === 267 /* ModuleDeclaration */; + switch (containingNodeKind) { + case 267 /* ModuleDeclaration */: + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 19 /* OpenBraceToken */: - return containingNodeKind === 263 /* ClassDeclaration */ || containingNodeKind === 210 /* ObjectLiteralExpression */; + switch (containingNodeKind) { + case 263 /* ClassDeclaration */: + // class A { | + case 210 /* ObjectLiteralExpression */: + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 64 /* EqualsToken */: - return containingNodeKind === 260 /* VariableDeclaration */ || containingNodeKind === 226 /* BinaryExpression */; + switch (containingNodeKind) { + case 260 /* VariableDeclaration */: + // const x = a| + case 226 /* BinaryExpression */: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true }; + default: + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; + } case 16 /* TemplateHead */: - return containingNodeKind === 228 /* TemplateExpression */; + return { + defaultCommitCharacters: allCommitCharacters, + isNewIdentifierLocation: containingNodeKind === 228 /* TemplateExpression */ + // `aa ${| + }; case 17 /* TemplateMiddle */: - return containingNodeKind === 239 /* TemplateSpan */; + return { + defaultCommitCharacters: allCommitCharacters, + isNewIdentifierLocation: containingNodeKind === 239 /* TemplateSpan */ + // `aa ${10} dd ${| + }; case 134 /* AsyncKeyword */: - return containingNodeKind === 174 /* MethodDeclaration */ || containingNodeKind === 304 /* ShorthandPropertyAssignment */; + return containingNodeKind === 174 /* MethodDeclaration */ || containingNodeKind === 304 /* ShorthandPropertyAssignment */ ? { defaultCommitCharacters: [], isNewIdentifierLocation: true } : { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; case 42 /* AsteriskToken */: - return containingNodeKind === 174 /* MethodDeclaration */; + return containingNodeKind === 174 /* MethodDeclaration */ ? { defaultCommitCharacters: [], isNewIdentifierLocation: true } : { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; } if (isClassMemberCompletionKeyword(tokenKind)) { - return true; + return { defaultCommitCharacters: [], isNewIdentifierLocation: true }; } } - return false; + return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false }; } function isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) { return (isRegularExpressionLiteral(contextToken2) || isStringTextContainingNode(contextToken2)) && (rangeContainsPositionExclusive(contextToken2, position) || position === contextToken2.end && (!!contextToken2.isUnterminated || isRegularExpressionLiteral(contextToken2))); @@ -166811,6 +168801,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, const parent2 = contextToken2.parent; switch (contextToken2.kind) { case 32 /* GreaterThanToken */: + // End of a type argument list case 31 /* LessThanSlashToken */: case 44 /* SlashToken */: case 80 /* Identifier */: @@ -166833,6 +168824,9 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, return parent2.parent.parent; } break; + // The context token is the closing } or " of an attribute, which means + // its parent is a JsxExpression, whose parent is a JsxAttribute, + // whose parent is a JsxOpeningLikeElement case 11 /* StringLiteral */: if (parent2 && (parent2.kind === 291 /* JsxAttribute */ || parent2.kind === 293 /* JsxSpreadAttribute */)) { return parent2.parent.parent; @@ -166867,14 +168861,18 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos; case 25 /* DotToken */: return containingNodeKind === 207 /* ArrayBindingPattern */; + // var [.| case 59 /* ColonToken */: return containingNodeKind === 208 /* BindingElement */; + // var {x :html| case 23 /* OpenBracketToken */: return containingNodeKind === 207 /* ArrayBindingPattern */; + // var [x| case 21 /* OpenParenToken */: return containingNodeKind === 299 /* CatchClause */ || isFunctionLikeButNotConstructor(containingNodeKind); case 19 /* OpenBraceToken */: return containingNodeKind === 266 /* EnumDeclaration */; + // enum a { | case 30 /* LessThanToken */: return containingNodeKind === 263 /* ClassDeclaration */ || // class A< | containingNodeKind === 231 /* ClassExpression */ || // var C = class D< | @@ -166885,6 +168883,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, return containingNodeKind === 172 /* PropertyDeclaration */ && !isClassLike(parent2.parent); case 26 /* DotDotDotToken */: return containingNodeKind === 169 /* Parameter */ || !!parent2.parent && parent2.parent.kind === 207 /* ArrayBindingPattern */; + // var [...z| case 125 /* PublicKeyword */: case 123 /* PrivateKeyword */: case 124 /* ProtectedKeyword */: @@ -166895,7 +168894,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position, case 153 /* SetKeyword */: return !isFromObjectTypeDeclaration(contextToken2); case 80 /* Identifier */: { - if (containingNodeKind === 276 /* ImportSpecifier */ && contextToken2 === parent2.name && contextToken2.text === "type") { + if ((containingNodeKind === 276 /* ImportSpecifier */ || containingNodeKind === 281 /* ExportSpecifier */) && contextToken2 === parent2.name && contextToken2.text === "type") { return false; } const ancestorVariableDeclaration = findAncestor( @@ -167111,6 +169110,7 @@ function tryGetObjectLikeCompletionContainer(contextToken, position, sourceFile) const { parent: parent2 } = contextToken; switch (contextToken.kind) { case 19 /* OpenBraceToken */: + // const x = { | case 28 /* CommaToken */: if (isObjectLiteralExpression(parent2) || isObjectBindingPattern(parent2)) { return parent2; @@ -167388,9 +169388,11 @@ function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken case 64 /* EqualsToken */: return void 0; case 27 /* SemicolonToken */: + // class c {getValue(): number; | } case 20 /* CloseBraceToken */: return isFromObjectTypeDeclaration(location) && location.parent.name === location ? location.parent.parent : tryCast(location, isObjectTypeDeclaration); case 19 /* OpenBraceToken */: + // class c { | case 28 /* CommaToken */: return tryCast(contextToken.parent, isObjectTypeDeclaration); default: @@ -167624,20 +169626,37 @@ function isModuleSpecifierMissingOrEmpty(specifier) { if (nodeIsMissing(specifier)) return true; return !((_a = tryCast(isExternalModuleReference(specifier) ? specifier.expression : specifier, isStringLiteralLike)) == null ? void 0 : _a.text); } -function getVariableOrParameterDeclaration(contextToken, location) { +function getClosestSymbolDeclaration(contextToken, location) { if (!contextToken) return; - const possiblyParameterDeclaration = findAncestor(contextToken, (node) => isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node) ? "quit" : (isParameter(node) || isTypeParameterDeclaration(node)) && !isIndexSignatureDeclaration(node.parent)); - const possiblyVariableDeclaration = findAncestor(location, (node) => isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node) ? "quit" : isVariableDeclaration(node)); - return possiblyParameterDeclaration || possiblyVariableDeclaration; + let closestDeclaration = findAncestor(contextToken, (node) => isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node) ? "quit" : (isParameter(node) || isTypeParameterDeclaration(node)) && !isIndexSignatureDeclaration(node.parent)); + if (!closestDeclaration) { + closestDeclaration = findAncestor(location, (node) => isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node) ? "quit" : isVariableDeclaration(node)); + } + return closestDeclaration; +} +function isInTypeParameterDefault(contextToken) { + if (!contextToken) { + return false; + } + let node = contextToken; + let parent2 = contextToken.parent; + while (parent2) { + if (isTypeParameterDeclaration(parent2)) { + return parent2.default === node || node.kind === 64 /* EqualsToken */; + } + node = parent2; + parent2 = parent2.parent; + } + return false; } function isArrowFunctionBody(node) { return node.parent && isArrowFunction(node.parent) && (node.parent.body === node || // const a = () => /**/; node.kind === 39 /* EqualsGreaterThanToken */); } -function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules = /* @__PURE__ */ new Map()) { +function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules = /* @__PURE__ */ new Set()) { return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(skipAlias(symbol.exportSymbol || symbol, checker)); function nonAliasCanBeReferencedAtTypeLocation(symbol2) { - return !!(symbol2.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol2) || !!(symbol2.flags & 1536 /* Module */) && addToSeen(seenModules, getSymbolId(symbol2)) && checker.getExportsOfModule(symbol2).some((e) => symbolCanBeReferencedAtTypeLocation(e, checker, seenModules)); + return !!(symbol2.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol2) || !!(symbol2.flags & 1536 /* Module */) && addToSeen(seenModules, symbol2) && checker.getExportsOfModule(symbol2).some((e) => symbolCanBeReferencedAtTypeLocation(e, checker, seenModules)); } } function isDeprecated(symbol, checker) { @@ -167709,7 +169728,7 @@ function createNameAndKindSet() { } function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences, includeSymbol) { if (isInReferenceComment(sourceFile, position)) { - const entries = getTripleSlashReferenceCompletion(sourceFile, position, program, host); + const entries = getTripleSlashReferenceCompletion(sourceFile, position, program, host, createModuleSpecifierResolutionHost(program, host)); return entries && convertPathCompletions(entries); } if (isInString(sourceFile, position, contextToken)) { @@ -167896,6 +169915,7 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, program, const argumentInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(parent2.kind === 291 /* JsxAttribute */ ? parent2.parent : node, position, sourceFile, typeChecker); return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType(0 /* None */); } + // falls through (is `require("")` or `require(""` or `import("")`) case 272 /* ImportDeclaration */: case 278 /* ExportDeclaration */: case 283 /* ExternalModuleReference */: @@ -167981,7 +170001,7 @@ function getAlreadyUsedTypesInStringLiteralUnion(union, current) { } function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) { let isNewIdentifier = false; - const uniques = /* @__PURE__ */ new Map(); + const uniques = /* @__PURE__ */ new Set(); const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg; const candidates = checker.getCandidateSignaturesForStringLiteralCompletions(call, editingArgument); const types = flatMap(candidates, (candidate) => { @@ -168021,7 +170041,7 @@ function stringLiteralCompletionsForObjectLiteral(checker, objectLiteralExpressi hasIndexSignature: hasIndexSignature(contextualType) }; } -function getStringLiteralTypes(type, uniques = /* @__PURE__ */ new Map()) { +function getStringLiteralTypes(type, uniques = /* @__PURE__ */ new Set()) { if (!type) return emptyArray; type = skipConstraint(type); return type.isUnion() ? flatMap(type.types, (t) => getStringLiteralTypes(t, uniques)) : type.isStringLiteral() && !(type.flags & 1024 /* EnumLiteral */) && addToSeen(uniques, type.value) ? [type] : emptyArray; @@ -168052,8 +170072,9 @@ function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, prog const scriptDirectory = getDirectoryPath(scriptPath); const compilerOptions = program.getCompilerOptions(); const typeChecker = program.getTypeChecker(); + const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host); const extensionOptions = getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile, typeChecker, preferences, mode); - return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, program, host, extensionOptions); + return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, moduleSpecifierResolutionHost, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, program, host, moduleSpecifierResolutionHost, extensionOptions); } function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile, typeChecker, preferences, resolutionMode) { return { @@ -168064,7 +170085,7 @@ function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile resolutionMode }; } -function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) { +function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, moduleSpecifierResolutionHost, scriptPath, extensionOptions) { const compilerOptions = program.getCompilerOptions(); if (compilerOptions.rootDirs) { return getCompletionEntriesForDirectoryFragmentWithRootDirs( @@ -168074,6 +170095,7 @@ function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, p extensionOptions, program, host, + moduleSpecifierResolutionHost, scriptPath ); } else { @@ -168083,6 +170105,7 @@ function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, p extensionOptions, program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ true, scriptPath @@ -168108,7 +170131,7 @@ function getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ign compareStringsCaseSensitive ); } -function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, program, host, exclude) { +function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, exclude) { const compilerOptions = program.getCompilerOptions(); const basePath = compilerOptions.project || host.getCurrentDirectory(); const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); @@ -168120,6 +170143,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment extensionOptions, program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ true, exclude @@ -168127,7 +170151,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment (itemA, itemB) => itemA.name === itemB.name && itemA.kind === itemB.kind && itemA.extension === itemB.extension ); } -function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) { +function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) { var _a; if (fragment === void 0) { fragment = ""; @@ -168152,7 +170176,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext if (versionPaths) { const packageDirectory = getDirectoryPath(packageJsonPath); const pathInPackage = absolutePath.slice(ensureTrailingDirectorySeparator(packageDirectory).length); - if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, program, host, versionPaths)) { + if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, versionPaths)) { return result; } } @@ -168180,7 +170204,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext getBaseFileName(filePath), program, extensionOptions, - /*isExportsWildcard*/ + /*isExportsOrImportsWildcard*/ false ); result.add(nameAndKind(name, "script" /* scriptElement */, extension)); @@ -168197,7 +170221,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext } return result; } -function getFilenameWithExtensionOption(name, program, extensionOptions, isExportsWildcard) { +function getFilenameWithExtensionOption(name, program, extensionOptions, isExportsOrImportsWildcard) { const nonJsResult = ts_moduleSpecifiers_exports.tryGetRealFileNameForNonJsDeclarationFileName(name); if (nonJsResult) { return { name: nonJsResult, extension: tryGetExtensionFromPath2(nonJsResult) }; @@ -168211,7 +170235,7 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor program.getCompilerOptions(), extensionOptions.importingSourceFile ).getAllowedEndingsInPreferredOrder(extensionOptions.resolutionMode); - if (isExportsWildcard) { + if (isExportsOrImportsWildcard) { allowedEndings = allowedEndings.filter((e) => e !== 0 /* Minimal */ && e !== 1 /* Index */); } if (allowedEndings[0] === 3 /* TsExtension */) { @@ -168221,13 +170245,13 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor const outputExtension2 = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions()); return outputExtension2 ? { name: changeExtension(name, outputExtension2), extension: outputExtension2 } : { name, extension: tryGetExtensionFromPath2(name) }; } - if (!isExportsWildcard && (allowedEndings[0] === 0 /* Minimal */ || allowedEndings[0] === 1 /* Index */) && fileExtensionIsOneOf(name, [".js" /* Js */, ".jsx" /* Jsx */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */])) { + if (!isExportsOrImportsWildcard && (allowedEndings[0] === 0 /* Minimal */ || allowedEndings[0] === 1 /* Index */) && fileExtensionIsOneOf(name, [".js" /* Js */, ".jsx" /* Jsx */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */])) { return { name: removeFileExtension(name), extension: tryGetExtensionFromPath2(name) }; } const outputExtension = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions()); return outputExtension ? { name: changeExtension(name, outputExtension), extension: outputExtension } : { name, extension: tryGetExtensionFromPath2(name) }; } -function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, program, host, paths) { +function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, paths) { const getPatternsForKey = (key) => paths[key]; const comparePaths2 = (a, b) => { const patternA = tryParsePattern(a); @@ -168236,40 +170260,43 @@ function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensio const lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length; return compareValues(lengthB, lengthA); }; - return addCompletionEntriesFromPathsOrExports( + return addCompletionEntriesFromPathsOrExportsOrImports( result, /*isExports*/ false, + /*isImports*/ + false, fragment, baseDirectory, extensionOptions, program, host, + moduleSpecifierResolutionHost, getOwnKeys(paths), getPatternsForKey, comparePaths2 ); } -function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, baseDirectory, extensionOptions, program, host, keys, getPatternsForKey, comparePaths2) { +function addCompletionEntriesFromPathsOrExportsOrImports(result, isExports, isImports, fragment, baseDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, keys, getPatternsForKey, comparePaths2) { let pathResults = []; let matchedPath; for (const key of keys) { if (key === ".") continue; - const keyWithoutLeadingDotSlash = key.replace(/^\.\//, ""); + const keyWithoutLeadingDotSlash = key.replace(/^\.\//, "") + ((isExports || isImports) && endsWith(key, "/") ? "*" : ""); const patterns = getPatternsForKey(key); if (patterns) { const pathPattern = tryParsePattern(keyWithoutLeadingDotSlash); if (!pathPattern) continue; const isMatch = typeof pathPattern === "object" && isPatternMatch(pathPattern, fragment); - const isLongestMatch = isMatch && (matchedPath === void 0 || comparePaths2(key, matchedPath) === -1 /* LessThan */); + const isLongestMatch = isMatch && (matchedPath === void 0 || comparePaths2(keyWithoutLeadingDotSlash, matchedPath) === -1 /* LessThan */); if (isLongestMatch) { - matchedPath = key; + matchedPath = keyWithoutLeadingDotSlash; pathResults = pathResults.filter((r) => !r.matchedPattern); } - if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(key, matchedPath) !== 1 /* GreaterThan */) { + if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(keyWithoutLeadingDotSlash, matchedPath) !== 1 /* GreaterThan */) { pathResults.push({ matchedPattern: isMatch, - results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports && isMatch, program, host).map(({ name, kind, extension }) => nameAndKind(name, kind, extension)) + results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost).map(({ name, kind, extension }) => nameAndKind(name, kind, extension)) }); } } @@ -168277,7 +170304,7 @@ function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, bas pathResults.forEach((pathResult) => pathResult.results.forEach((r) => result.add(r))); return matchedPath !== void 0; } -function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, program, host, extensionOptions) { +function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, program, host, moduleSpecifierResolutionHost, extensionOptions) { const typeChecker = program.getTypeChecker(); const compilerOptions = program.getCompilerOptions(); const { baseUrl, paths } = compilerOptions; @@ -168291,6 +170318,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p extensionOptions, program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ false, /*exclude*/ @@ -168300,7 +170328,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p } if (paths) { const absolute = getPathsBasePath(compilerOptions, host); - addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, program, host, paths); + addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, program, host, moduleSpecifierResolutionHost, paths); } const fragmentDirectory = getFragmentDirectory(fragment); for (const ambientName of getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker)) { @@ -168311,7 +170339,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p void 0 )); } - getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result); + getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, fragmentDirectory, extensionOptions, result); if (moduleResolutionUsesNodeModules(moduleResolution)) { let foundGlobal = false; if (fragmentDirectory === void 0) { @@ -168329,6 +170357,26 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p } } if (!foundGlobal) { + const resolvePackageJsonExports = getResolvePackageJsonExports(compilerOptions); + const resolvePackageJsonImports = getResolvePackageJsonImports(compilerOptions); + let seenPackageScope = false; + const importsLookup = (directory) => { + if (resolvePackageJsonImports && !seenPackageScope) { + const packageFile = combinePaths(directory, "package.json"); + if (seenPackageScope = tryFileExists(host, packageFile)) { + const packageJson = readJson(packageFile, host); + exportsOrImportsLookup( + packageJson.imports, + fragment, + directory, + /*isExports*/ + false, + /*isImports*/ + true + ); + } + } + }; let ancestorLookup = (ancestor) => { const nodeModules = combinePaths(ancestor, "node_modules"); if (tryDirectoryExists(host, nodeModules)) { @@ -168338,6 +170386,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p extensionOptions, program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ false, /*exclude*/ @@ -168345,58 +170394,77 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p result ); } + importsLookup(ancestor); }; - if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) { - const nodeModulesDirectoryLookup = ancestorLookup; + if (fragmentDirectory && resolvePackageJsonExports) { + const nodeModulesDirectoryOrImportsLookup = ancestorLookup; ancestorLookup = (ancestor) => { const components = getPathComponents(fragment); components.shift(); let packagePath = components.shift(); if (!packagePath) { - return nodeModulesDirectoryLookup(ancestor); + return nodeModulesDirectoryOrImportsLookup(ancestor); } if (startsWith(packagePath, "@")) { const subName = components.shift(); if (!subName) { - return nodeModulesDirectoryLookup(ancestor); + return nodeModulesDirectoryOrImportsLookup(ancestor); } packagePath = combinePaths(packagePath, subName); } + if (resolvePackageJsonImports && startsWith(packagePath, "#")) { + return importsLookup(ancestor); + } const packageDirectory = combinePaths(ancestor, "node_modules", packagePath); const packageFile = combinePaths(packageDirectory, "package.json"); if (tryFileExists(host, packageFile)) { const packageJson = readJson(packageFile, host); - const exports2 = packageJson.exports; - if (exports2) { - if (typeof exports2 !== "object" || exports2 === null) { - return; - } - const keys = getOwnKeys(exports2); - const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); - const conditions = getConditions(compilerOptions, mode); - addCompletionEntriesFromPathsOrExports( - result, - /*isExports*/ - true, - fragmentSubpath, - packageDirectory, - extensionOptions, - program, - host, - keys, - (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports2[key], conditions)), - comparePatternKeys - ); - return; - } + const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); + exportsOrImportsLookup( + packageJson.exports, + fragmentSubpath, + packageDirectory, + /*isExports*/ + true, + /*isImports*/ + false + ); + return; } - return nodeModulesDirectoryLookup(ancestor); + return nodeModulesDirectoryOrImportsLookup(ancestor); }; } - forEachAncestorDirectory(scriptPath, ancestorLookup); + forEachAncestorDirectoryStoppingAtGlobalCache(host, scriptPath, ancestorLookup); } } return arrayFrom(result.values()); + function exportsOrImportsLookup(lookupTable, fragment2, baseDirectory, isExports, isImports) { + if (typeof lookupTable !== "object" || lookupTable === null) { + return; + } + const keys = getOwnKeys(lookupTable); + const conditions = getConditions(compilerOptions, mode); + addCompletionEntriesFromPathsOrExportsOrImports( + result, + isExports, + isImports, + fragment2, + baseDirectory, + extensionOptions, + program, + host, + moduleSpecifierResolutionHost, + keys, + (key) => { + const pattern = getPatternFromFirstMatchingCondition(lookupTable[key], conditions); + if (pattern === void 0) { + return void 0; + } + return singleElementArray(endsWith(key, "/") && endsWith(pattern, "/") ? pattern + "*" : pattern); + }, + comparePatternKeys + ); + } } function getPatternFromFirstMatchingCondition(target, conditions) { if (typeof target === "string") { @@ -168414,25 +170482,28 @@ function getPatternFromFirstMatchingCondition(target, conditions) { function getFragmentDirectory(fragment) { return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0; } -function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExportsWildcard, program, host) { - if (!endsWith(path, "*")) { - return !path.includes("*") ? justPathMappingName(path, "script" /* scriptElement */) : emptyArray; +function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) { + const parsedPath = tryParsePattern(path); + if (!parsedPath) { + return emptyArray; } - const pathPrefix = path.slice(0, path.length - 1); - const remainingFragment = tryRemovePrefix(fragment, pathPrefix); + if (typeof parsedPath === "string") { + return justPathMappingName(path, "script" /* scriptElement */); + } + const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix); if (remainingFragment === void 0) { - const starIsFullPathComponent = path[path.length - 2] === "/"; - return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* directory */) : flatMap(patterns, (pattern) => { + const starIsFullPathComponent = endsWith(path, "/*"); + return starIsFullPathComponent ? justPathMappingName(parsedPath.prefix, "directory" /* directory */) : flatMap(patterns, (pattern) => { var _a; - return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: pathPrefix + name, ...rest })); + return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: parsedPath.prefix + name + parsedPath.suffix, ...rest })); }); } - return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host)); + return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost)); function justPathMappingName(name, kind) { return startsWith(name, fragment) ? [{ name: removeTrailingDirectorySeparator(name), kind, extension: void 0 }] : emptyArray; } } -function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host) { +function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) { if (!host.readDirectory) { return void 0; } @@ -168445,35 +170516,67 @@ function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensio const normalizedPrefixBase = hasTrailingDirectorySeparator(parsed.prefix) ? "" : getBaseFileName(normalizedPrefix); const fragmentHasPath = containsSlash(fragment); const fragmentDirectory = fragmentHasPath ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0; + const getCommonSourceDirectory2 = () => moduleSpecifierResolutionHost.getCommonSourceDirectory(); + const ignoreCase = !hostUsesCaseSensitiveFileNames(moduleSpecifierResolutionHost); + const outDir = program.getCompilerOptions().outDir; + const declarationDir = program.getCompilerOptions().declarationDir; const expandedPrefixDirectory = fragmentHasPath ? combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + fragmentDirectory) : normalizedPrefixDirectory; + const baseDirectory = normalizePath(combinePaths(packageDirectory, expandedPrefixDirectory)); + const possibleInputBaseDirectoryForOutDir = isImports && outDir && getPossibleOriginalInputPathWithoutChangingExt(baseDirectory, ignoreCase, outDir, getCommonSourceDirectory2); + const possibleInputBaseDirectoryForDeclarationDir = isImports && declarationDir && getPossibleOriginalInputPathWithoutChangingExt(baseDirectory, ignoreCase, declarationDir, getCommonSourceDirectory2); const normalizedSuffix = normalizePath(parsed.suffix); const declarationExtension = normalizedSuffix && getDeclarationEmitExtensionForPath("_" + normalizedSuffix); - const matchingSuffixes = declarationExtension ? [changeExtension(normalizedSuffix, declarationExtension), normalizedSuffix] : [normalizedSuffix]; - const baseDirectory = normalizePath(combinePaths(packageDirectory, expandedPrefixDirectory)); - const completePrefix = fragmentHasPath ? baseDirectory : ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase; + const inputExtension = normalizedSuffix ? getPossibleOriginalInputExtensionForExtension("_" + normalizedSuffix) : void 0; + const matchingSuffixes = [ + declarationExtension && changeExtension(normalizedSuffix, declarationExtension), + ...inputExtension ? inputExtension.map((ext) => changeExtension(normalizedSuffix, ext)) : [], + normalizedSuffix + ].filter(isString); const includeGlobs = normalizedSuffix ? matchingSuffixes.map((suffix) => "**/*" + suffix) : ["./*"]; - const matches = mapDefined(tryReadDirectory( - host, - baseDirectory, - extensionOptions.extensionsToSearch, - /*exclude*/ - void 0, - includeGlobs - ), (match) => { - const trimmedWithPattern = trimPrefixAndSuffix(match); - if (trimmedWithPattern) { - if (containsSlash(trimmedWithPattern)) { - return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]); - } - const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, program, extensionOptions, isExportsWildcard); - return nameAndKind(name, "script" /* scriptElement */, extension); + const isExportsOrImportsWildcard = (isExports || isImports) && endsWith(pattern, "/*"); + let matches = getMatchesWithPrefix(baseDirectory); + if (possibleInputBaseDirectoryForOutDir) { + matches = concatenate(matches, getMatchesWithPrefix(possibleInputBaseDirectoryForOutDir)); + } + if (possibleInputBaseDirectoryForDeclarationDir) { + matches = concatenate(matches, getMatchesWithPrefix(possibleInputBaseDirectoryForDeclarationDir)); + } + if (!normalizedSuffix) { + matches = concatenate(matches, getDirectoryMatches(baseDirectory)); + if (possibleInputBaseDirectoryForOutDir) { + matches = concatenate(matches, getDirectoryMatches(possibleInputBaseDirectoryForOutDir)); } - }); - const directories = normalizedSuffix ? emptyArray : mapDefined(tryGetDirectories(host, baseDirectory), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir)); - return [...matches, ...directories]; - function trimPrefixAndSuffix(path) { + if (possibleInputBaseDirectoryForDeclarationDir) { + matches = concatenate(matches, getDirectoryMatches(possibleInputBaseDirectoryForDeclarationDir)); + } + } + return matches; + function getMatchesWithPrefix(directory) { + const completePrefix = fragmentHasPath ? directory : ensureTrailingDirectorySeparator(directory) + normalizedPrefixBase; + return mapDefined(tryReadDirectory( + host, + directory, + extensionOptions.extensionsToSearch, + /*exclude*/ + void 0, + includeGlobs + ), (match) => { + const trimmedWithPattern = trimPrefixAndSuffix(match, completePrefix); + if (trimmedWithPattern) { + if (containsSlash(trimmedWithPattern)) { + return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]); + } + const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, program, extensionOptions, isExportsOrImportsWildcard); + return nameAndKind(name, "script" /* scriptElement */, extension); + } + }); + } + function getDirectoryMatches(directoryName) { + return mapDefined(tryGetDirectories(host, directoryName), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir)); + } + function trimPrefixAndSuffix(path, prefix) { return firstDefined(matchingSuffixes, (suffix) => { - const inner = withoutStartAndEnd(normalizePath(path), completePrefix, suffix); + const inner = withoutStartAndEnd(normalizePath(path), prefix, suffix); return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner); }); } @@ -168493,7 +170596,7 @@ function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) { } return nonRelativeModuleNames; } -function getTripleSlashReferenceCompletion(sourceFile, position, program, host) { +function getTripleSlashReferenceCompletion(sourceFile, position, program, host, moduleSpecifierResolutionHost) { const compilerOptions = program.getCompilerOptions(); const token = getTokenAtPosition(sourceFile, position); const commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos); @@ -168514,13 +170617,14 @@ function getTripleSlashReferenceCompletion(sourceFile, position, program, host) getExtensionOptions(compilerOptions, 0 /* Filename */, sourceFile), program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ true, sourceFile.path - ) : kind === "types" ? getCompletionEntriesFromTypings(host, program, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail(); + ) : kind === "types" ? getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail(); return addReplacementSpans(toComplete, range.pos + prefix.length, arrayFrom(names.values())); } -function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) { +function getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) { const options = program.getCompilerOptions(); const seen = /* @__PURE__ */ new Map(); const typeRoots = tryAndIgnoreErrors(() => getEffectiveTypeRoots(options, host)) || emptyArray; @@ -168557,6 +170661,7 @@ function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDire extensionOptions, program, host, + moduleSpecifierResolutionHost, /*moduleSpecifierIsRelative*/ false, /*exclude*/ @@ -168702,6 +170807,7 @@ function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, { break; case 80 /* Identifier */: break; + // TODO: GH#23879 case 271 /* ImportEqualsDeclaration */: handleNamespaceImport( direct, @@ -169308,7 +171414,7 @@ function getImplementationsAtPosition(program, cancellationToken, sourceFiles, s referenceEntries = entries && [...entries]; } else if (entries) { const queue = createQueue(entries); - const seenNodes = /* @__PURE__ */ new Map(); + const seenNodes = /* @__PURE__ */ new Set(); while (!queue.isEmpty()) { const entry = queue.dequeue(); if (!addToSeen(seenNodes, getNodeId(entry.node))) { @@ -169596,6 +171702,7 @@ function declarationIsWriteAccess(decl) { case 306 /* EnumMember */: case 281 /* ExportSpecifier */: case 273 /* ImportClause */: + // default import case 271 /* ImportEqualsDeclaration */: case 276 /* ImportSpecifier */: case 264 /* InterfaceDeclaration */: @@ -169982,6 +172089,7 @@ var Core; Debug.assert(node.parent.name === node); return 2 /* Class */; } + // falls through default: return 0 /* None */; } @@ -170313,6 +172421,7 @@ var Core; if (isJSDocMemberName(node.parent)) { return true; } + // falls through I guess case 80 /* Identifier */: return node.text.length === searchSymbolName.length; case 15 /* NoSubstitutionTemplateLiteral */: @@ -170738,6 +172847,7 @@ var Core; searchSpaceNode = searchSpaceNode.parent; break; } + // falls through case 172 /* PropertyDeclaration */: case 171 /* PropertySignature */: case 176 /* Constructor */: @@ -170750,9 +172860,12 @@ var Core; if (isExternalModule(searchSpaceNode) || isParameterName(thisOrSuperKeyword)) { return void 0; } + // falls through case 262 /* FunctionDeclaration */: case 218 /* FunctionExpression */: break; + // Computed properties in classes are not handled here because references to this are illegal, + // so there is no point finding references to them. default: return void 0; } @@ -170953,10 +173066,10 @@ var Core; } } function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) { - const seen = /* @__PURE__ */ new Map(); + const seen = /* @__PURE__ */ new Set(); return recur(symbol); function recur(symbol2) { - if (!(symbol2.flags & (32 /* Class */ | 64 /* Interface */)) || !addToSeen(seen, getSymbolId(symbol2))) return; + if (!(symbol2.flags & (32 /* Class */ | 64 /* Interface */)) || !addToSeen(seen, symbol2)) return; return firstDefined(symbol2.declarations, (declaration) => firstDefined(getAllSuperTypeNodes(declaration), (typeReference) => { const type = checker.getTypeAtLocation(typeReference); const propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName); @@ -171092,6 +173205,7 @@ function getDefinitionAtPosition(program, sourceFile, position, searchOtherFiles if (!isDefaultClause(node.parent)) { break; } + // falls through case 84 /* CaseKeyword */: const switchStatement = findAncestor(node.parent, isSwitchStatement); if (switchStatement) { @@ -171536,6 +173650,8 @@ function isDefinitionVisible(checker, declaration) { case 178 /* SetAccessor */: case 174 /* MethodDeclaration */: if (hasEffectiveModifier(declaration, 2 /* Private */)) return false; + // Public properties/methods are visible if its parents are visible, so: + // falls through case 176 /* Constructor */: case 303 /* PropertyAssignment */: case 304 /* ShorthandPropertyAssignment */: @@ -171739,11 +173855,8 @@ function provideInlayHints(context) { if (!args || !args.length) { return; } - const candidates = []; - const signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates); - if (!signature || !candidates.length) { - return; - } + const signature = checker.getResolvedSignature(expr); + if (signature === void 0) return; let signatureParamPos = 0; for (const originalArg of args) { const arg = skipParentheses(originalArg); @@ -172512,6 +174625,7 @@ function getCommentHavingNodes(declaration) { if (isJSDocOverloadTag(declaration.parent)) { return [declaration.parent.parent]; } + // falls through default: return getJSDocCommentsAndTags(declaration); } @@ -173849,6 +175963,7 @@ function getOutliningSpanForNode(n, sourceFile) { const node = findChildOfKind(tryStatement, 98 /* FinallyKeyword */, sourceFile); if (node) return spanForNode(node); } + // falls through default: return createOutliningSpan(createTextSpanFromNode(n, sourceFile), "code" /* Code */); } @@ -175599,6 +177714,7 @@ __export(ts_textChanges_exports, { assignPositionsToNode: () => assignPositionsToNode, createWriter: () => createWriter, deleteNode: () => deleteNode, + getAdjustedEndPosition: () => getAdjustedEndPosition, isThisTypeAnnotatable: () => isThisTypeAnnotatable, isValidLocationToAddComment: () => isValidLocationToAddComment }); @@ -176098,7 +178214,10 @@ var ChangeTracker = class _ChangeTracker { getInsertNodeAtStartInsertOptions(sourceFile, node, indentation) { const members = getMembersOrProperties(node); const isEmpty = members.length === 0; - const isFirstInsertion = addToSeen(this.classesWithNodesInsertedAtStart, getNodeId(node), { node, sourceFile }); + const isFirstInsertion = !this.classesWithNodesInsertedAtStart.has(getNodeId(node)); + if (isFirstInsertion) { + this.classesWithNodesInsertedAtStart.set(getNodeId(node), { node, sourceFile }); + } const insertTrailingComma = isObjectLiteralExpression(node) && (!isJsonSourceFile(sourceFile) || !isEmpty); const insertLeadingComma = isObjectLiteralExpression(node) && isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion; return { @@ -177674,19 +179793,34 @@ function isBinaryOpContext(context) { case 193 /* IntersectionType */: case 238 /* SatisfiesExpression */: return true; + // equals in binding elements: function foo([[x, y] = [1, 2]]) case 208 /* BindingElement */: + // equals in type X = ... + // falls through case 265 /* TypeAliasDeclaration */: + // equal in import a = module('a'); + // falls through case 271 /* ImportEqualsDeclaration */: + // equal in export = 1 + // falls through case 277 /* ExportAssignment */: + // equal in let a = 0 + // falls through case 260 /* VariableDeclaration */: + // equal in p = 0 + // falls through case 169 /* Parameter */: case 306 /* EnumMember */: case 172 /* PropertyDeclaration */: case 171 /* PropertySignature */: return context.currentTokenSpan.kind === 64 /* EqualsToken */ || context.nextTokenSpan.kind === 64 /* EqualsToken */; + // "in" keyword in for (let x in []) { } case 249 /* ForInStatement */: + // "in" keyword in [P in keyof T]: T[P] + // falls through case 168 /* TypeParameter */: return context.currentTokenSpan.kind === 103 /* InKeyword */ || context.nextTokenSpan.kind === 103 /* InKeyword */ || context.currentTokenSpan.kind === 64 /* EqualsToken */ || context.nextTokenSpan.kind === 64 /* EqualsToken */; + // Technically, "of" is not a binary operator, but format it the same way as "in" case 250 /* ForOfStatement */: return context.currentTokenSpan.kind === 165 /* OfKeyword */ || context.nextTokenSpan.kind === 165 /* OfKeyword */; } @@ -177750,12 +179884,20 @@ function isFunctionDeclContext(context) { case 262 /* FunctionDeclaration */: case 174 /* MethodDeclaration */: case 173 /* MethodSignature */: + // case SyntaxKind.MemberFunctionDeclaration: + // falls through case 177 /* GetAccessor */: case 178 /* SetAccessor */: + // case SyntaxKind.MethodSignature: + // falls through case 179 /* CallSignature */: case 218 /* FunctionExpression */: case 176 /* Constructor */: case 219 /* ArrowFunction */: + // case SyntaxKind.ConstructorDeclaration: + // case SyntaxKind.SimpleArrowFunctionExpression: + // case SyntaxKind.ParenthesizedArrowFunctionExpression: + // falls through case 264 /* InterfaceDeclaration */: return true; } @@ -177815,6 +179957,9 @@ function isControlDeclContext(context) { case 258 /* TryStatement */: case 246 /* DoStatement */: case 254 /* WithStatement */: + // TODO + // case SyntaxKind.ElseClause: + // falls through case 299 /* CatchClause */: return true; default: @@ -177982,6 +180127,9 @@ function isSemicolonDeletionContext(context) { if (startLine === endLine) { return nextTokenKind === 20 /* CloseBraceToken */ || nextTokenKind === 1 /* EndOfFileToken */; } + if (nextTokenKind === 27 /* SemicolonToken */ && context.currentTokenSpan.kind === 27 /* SemicolonToken */) { + return true; + } if (nextTokenKind === 240 /* SemicolonClassElement */ || nextTokenKind === 27 /* SemicolonToken */) { return false; } @@ -178443,6 +180591,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt if (node.asteriskToken) { return 42 /* AsteriskToken */; } + // falls through case 172 /* PropertyDeclaration */: case 169 /* Parameter */: const name = getNameOfDeclaration(node); @@ -178455,6 +180604,10 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt return { getIndentationForComment: (kind, tokenIndentation, container) => { switch (kind) { + // preceding comment to the token that closes the indentation scope inherits the indentation from the scope + // .. { + // // comment + // } case 20 /* CloseBraceToken */: case 24 /* CloseBracketToken */: case 22 /* CloseParenToken */: @@ -178484,6 +180637,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt }; function shouldAddDelta(line, kind, container) { switch (kind) { + // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent case 19 /* OpenBraceToken */: case 20 /* CloseBraceToken */: case 22 /* CloseParenToken */: @@ -179641,6 +181795,48 @@ var SmartIndenter; } })(SmartIndenter || (SmartIndenter = {})); +// src/services/_namespaces/ts.preparePasteEdits.ts +var ts_preparePasteEdits_exports = {}; +__export(ts_preparePasteEdits_exports, { + preparePasteEdits: () => preparePasteEdits +}); + +// src/services/preparePasteEdits.ts +function preparePasteEdits(sourceFile, copiedFromRange, checker) { + let shouldProvidePasteEdits = false; + copiedFromRange.forEach((range) => { + const enclosingNode = findAncestor( + getTokenAtPosition(sourceFile, range.pos), + (ancestorNode) => rangeContainsRange(ancestorNode, range) + ); + if (!enclosingNode) return; + forEachChild(enclosingNode, function checkNameResolution(node) { + var _a; + if (shouldProvidePasteEdits) return; + if (isIdentifier(node) && rangeContainsPosition(range, node.getStart(sourceFile))) { + const resolvedSymbol = checker.resolveName( + node.text, + node, + -1 /* All */, + /*excludeGlobals*/ + false + ); + if (resolvedSymbol && resolvedSymbol.declarations) { + for (const decl of resolvedSymbol.declarations) { + if (isInImport(decl) || !!(node.text && sourceFile.symbol && ((_a = sourceFile.symbol.exports) == null ? void 0 : _a.has(node.escapedText)))) { + shouldProvidePasteEdits = true; + return; + } + } + } + } + node.forEachChild(checkNameResolution); + }); + if (shouldProvidePasteEdits) return; + }); + return shouldProvidePasteEdits; +} + // src/services/_namespaces/ts.PasteEdits.ts var ts_PasteEdits_exports = {}; __export(ts_PasteEdits_exports, { @@ -179648,10 +181844,10 @@ __export(ts_PasteEdits_exports, { }); // src/services/pasteEdits.ts -var fixId54 = "providePostPasteEdits"; +var fixId55 = "providePostPasteEdits"; function pasteEditsProvider(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken) { const changes = ts_textChanges_exports.ChangeTracker.with({ host, formatContext, preferences }, (changeTracker) => pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken, changeTracker)); - return { edits: changes, fixId: fixId54 }; + return { edits: changes, fixId: fixId55 }; } function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken, changes) { let actualPastedText; @@ -179679,11 +181875,13 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr } statements.push(...statementsInSourceFile.slice(startNodeIndex, endNodeIndex === -1 ? statementsInSourceFile.length : endNodeIndex + 1)); }); - const usage = getUsageInfo(copiedFrom.file, statements, originalProgram.getTypeChecker(), getExistingLocals(updatedFile, statements, originalProgram.getTypeChecker()), { pos: copiedFrom.range[0].pos, end: copiedFrom.range[copiedFrom.range.length - 1].end }); - Debug.assertIsDefined(originalProgram); + Debug.assertIsDefined(originalProgram, "no original program found"); + const originalProgramTypeChecker = originalProgram.getTypeChecker(); + const usageInfoRange = getUsageInfoRangeForPasteEdits(copiedFrom); + const usage = getUsageInfo(copiedFrom.file, statements, originalProgramTypeChecker, getExistingLocals(updatedFile, statements, originalProgramTypeChecker), usageInfoRange); const useEsModuleSyntax = !fileShouldUseJavaScriptRequire(targetFile.fileName, originalProgram, host, !!copiedFrom.file.commonJsModuleIndicator); addExportsInOldFile(copiedFrom.file, usage.targetFileImportsFromOldFile, changes, useEsModuleSyntax); - addTargetFileImports(copiedFrom.file, usage.oldImportsNeededByTargetFile, usage.targetFileImportsFromOldFile, originalProgram.getTypeChecker(), updatedProgram, importAdder); + addTargetFileImports(copiedFrom.file, usage.oldImportsNeededByTargetFile, usage.targetFileImportsFromOldFile, originalProgramTypeChecker, updatedProgram, importAdder); } else { const context = { sourceFile: updatedFile, @@ -179739,14350 +181937,17 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr ); }); } - -// src/server/_namespaces/ts.ts -var ts_exports2 = {}; -__export(ts_exports2, { - ANONYMOUS: () => ANONYMOUS, - AccessFlags: () => AccessFlags, - AssertionLevel: () => AssertionLevel, - AssignmentDeclarationKind: () => AssignmentDeclarationKind, - AssignmentKind: () => AssignmentKind, - Associativity: () => Associativity, - BreakpointResolver: () => ts_BreakpointResolver_exports, - BuilderFileEmit: () => BuilderFileEmit, - BuilderProgramKind: () => BuilderProgramKind, - BuilderState: () => BuilderState, - CallHierarchy: () => ts_CallHierarchy_exports, - CharacterCodes: () => CharacterCodes, - CheckFlags: () => CheckFlags, - CheckMode: () => CheckMode, - ClassificationType: () => ClassificationType, - ClassificationTypeNames: () => ClassificationTypeNames, - CommentDirectiveType: () => CommentDirectiveType, - Comparison: () => Comparison, - CompletionInfoFlags: () => CompletionInfoFlags, - CompletionTriggerKind: () => CompletionTriggerKind, - Completions: () => ts_Completions_exports, - ContainerFlags: () => ContainerFlags, - ContextFlags: () => ContextFlags, - Debug: () => Debug, - DiagnosticCategory: () => DiagnosticCategory, - Diagnostics: () => Diagnostics, - DocumentHighlights: () => DocumentHighlights, - ElementFlags: () => ElementFlags, - EmitFlags: () => EmitFlags, - EmitHint: () => EmitHint, - EmitOnly: () => EmitOnly, - EndOfLineState: () => EndOfLineState, - ExitStatus: () => ExitStatus, - ExportKind: () => ExportKind, - Extension: () => Extension, - ExternalEmitHelpers: () => ExternalEmitHelpers, - FileIncludeKind: () => FileIncludeKind, - FilePreprocessingDiagnosticsKind: () => FilePreprocessingDiagnosticsKind, - FileSystemEntryKind: () => FileSystemEntryKind, - FileWatcherEventKind: () => FileWatcherEventKind, - FindAllReferences: () => ts_FindAllReferences_exports, - FlattenLevel: () => FlattenLevel, - FlowFlags: () => FlowFlags, - ForegroundColorEscapeSequences: () => ForegroundColorEscapeSequences, - FunctionFlags: () => FunctionFlags, - GeneratedIdentifierFlags: () => GeneratedIdentifierFlags, - GetLiteralTextFlags: () => GetLiteralTextFlags, - GoToDefinition: () => ts_GoToDefinition_exports, - HighlightSpanKind: () => HighlightSpanKind, - IdentifierNameMap: () => IdentifierNameMap, - ImportKind: () => ImportKind, - ImportsNotUsedAsValues: () => ImportsNotUsedAsValues, - IndentStyle: () => IndentStyle, - IndexFlags: () => IndexFlags, - IndexKind: () => IndexKind, - InferenceFlags: () => InferenceFlags, - InferencePriority: () => InferencePriority, - InlayHintKind: () => InlayHintKind2, - InlayHints: () => ts_InlayHints_exports, - InternalEmitFlags: () => InternalEmitFlags, - InternalNodeBuilderFlags: () => InternalNodeBuilderFlags, - InternalSymbolName: () => InternalSymbolName, - IntersectionFlags: () => IntersectionFlags, - InvalidatedProjectKind: () => InvalidatedProjectKind, - JSDocParsingMode: () => JSDocParsingMode, - JsDoc: () => ts_JsDoc_exports, - JsTyping: () => ts_JsTyping_exports, - JsxEmit: () => JsxEmit, - JsxFlags: () => JsxFlags, - JsxReferenceKind: () => JsxReferenceKind, - LanguageFeatureMinimumTarget: () => LanguageFeatureMinimumTarget, - LanguageServiceMode: () => LanguageServiceMode, - LanguageVariant: () => LanguageVariant, - LexicalEnvironmentFlags: () => LexicalEnvironmentFlags, - ListFormat: () => ListFormat, - LogLevel: () => LogLevel, - MapCode: () => ts_MapCode_exports, - MemberOverrideStatus: () => MemberOverrideStatus, - ModifierFlags: () => ModifierFlags, - ModuleDetectionKind: () => ModuleDetectionKind, - ModuleInstanceState: () => ModuleInstanceState, - ModuleKind: () => ModuleKind, - ModuleResolutionKind: () => ModuleResolutionKind, - ModuleSpecifierEnding: () => ModuleSpecifierEnding, - NavigateTo: () => ts_NavigateTo_exports, - NavigationBar: () => ts_NavigationBar_exports, - NewLineKind: () => NewLineKind, - NodeBuilderFlags: () => NodeBuilderFlags, - NodeCheckFlags: () => NodeCheckFlags, - NodeFactoryFlags: () => NodeFactoryFlags, - NodeFlags: () => NodeFlags, - NodeResolutionFeatures: () => NodeResolutionFeatures, - ObjectFlags: () => ObjectFlags, - OperationCanceledException: () => OperationCanceledException, - OperatorPrecedence: () => OperatorPrecedence, - OrganizeImports: () => ts_OrganizeImports_exports, - OrganizeImportsMode: () => OrganizeImportsMode, - OuterExpressionKinds: () => OuterExpressionKinds, - OutliningElementsCollector: () => ts_OutliningElementsCollector_exports, - OutliningSpanKind: () => OutliningSpanKind, - OutputFileType: () => OutputFileType, - PackageJsonAutoImportPreference: () => PackageJsonAutoImportPreference, - PackageJsonDependencyGroup: () => PackageJsonDependencyGroup, - PatternMatchKind: () => PatternMatchKind, - PollingInterval: () => PollingInterval, - PollingWatchKind: () => PollingWatchKind, - PragmaKindFlags: () => PragmaKindFlags, - PredicateSemantics: () => PredicateSemantics, - PrivateIdentifierKind: () => PrivateIdentifierKind, - ProcessLevel: () => ProcessLevel, - ProgramUpdateLevel: () => ProgramUpdateLevel, - QuotePreference: () => QuotePreference, - RegularExpressionFlags: () => RegularExpressionFlags, - RelationComparisonResult: () => RelationComparisonResult, - Rename: () => ts_Rename_exports, - ScriptElementKind: () => ScriptElementKind, - ScriptElementKindModifier: () => ScriptElementKindModifier, - ScriptKind: () => ScriptKind, - ScriptSnapshot: () => ScriptSnapshot, - ScriptTarget: () => ScriptTarget, - SemanticClassificationFormat: () => SemanticClassificationFormat, - SemanticMeaning: () => SemanticMeaning, - SemicolonPreference: () => SemicolonPreference, - SignatureCheckMode: () => SignatureCheckMode, - SignatureFlags: () => SignatureFlags, - SignatureHelp: () => ts_SignatureHelp_exports, - SignatureInfo: () => SignatureInfo, - SignatureKind: () => SignatureKind, - SmartSelectionRange: () => ts_SmartSelectionRange_exports, - SnippetKind: () => SnippetKind, - StatisticType: () => StatisticType, - StructureIsReused: () => StructureIsReused, - SymbolAccessibility: () => SymbolAccessibility, - SymbolDisplay: () => ts_SymbolDisplay_exports, - SymbolDisplayPartKind: () => SymbolDisplayPartKind, - SymbolFlags: () => SymbolFlags, - SymbolFormatFlags: () => SymbolFormatFlags, - SyntaxKind: () => SyntaxKind, - Ternary: () => Ternary, - ThrottledCancellationToken: () => ThrottledCancellationToken, - TokenClass: () => TokenClass, - TokenFlags: () => TokenFlags, - TransformFlags: () => TransformFlags, - TypeFacts: () => TypeFacts, - TypeFlags: () => TypeFlags, - TypeFormatFlags: () => TypeFormatFlags, - TypeMapKind: () => TypeMapKind, - TypePredicateKind: () => TypePredicateKind, - TypeReferenceSerializationKind: () => TypeReferenceSerializationKind, - UnionReduction: () => UnionReduction, - UpToDateStatusType: () => UpToDateStatusType, - VarianceFlags: () => VarianceFlags, - Version: () => Version, - VersionRange: () => VersionRange, - WatchDirectoryFlags: () => WatchDirectoryFlags, - WatchDirectoryKind: () => WatchDirectoryKind, - WatchFileKind: () => WatchFileKind, - WatchLogLevel: () => WatchLogLevel, - WatchType: () => WatchType, - accessPrivateIdentifier: () => accessPrivateIdentifier, - addEmitFlags: () => addEmitFlags, - addEmitHelper: () => addEmitHelper, - addEmitHelpers: () => addEmitHelpers, - addInternalEmitFlags: () => addInternalEmitFlags, - addNodeFactoryPatcher: () => addNodeFactoryPatcher, - addObjectAllocatorPatcher: () => addObjectAllocatorPatcher, - addRange: () => addRange, - addRelatedInfo: () => addRelatedInfo, - addSyntheticLeadingComment: () => addSyntheticLeadingComment, - addSyntheticTrailingComment: () => addSyntheticTrailingComment, - addToSeen: () => addToSeen, - advancedAsyncSuperHelper: () => advancedAsyncSuperHelper, - affectsDeclarationPathOptionDeclarations: () => affectsDeclarationPathOptionDeclarations, - affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations, - allKeysStartWithDot: () => allKeysStartWithDot, - altDirectorySeparator: () => altDirectorySeparator, - and: () => and, - append: () => append, - appendIfUnique: () => appendIfUnique, - arrayFrom: () => arrayFrom, - arrayIsEqualTo: () => arrayIsEqualTo, - arrayIsHomogeneous: () => arrayIsHomogeneous, - arrayOf: () => arrayOf, - arrayReverseIterator: () => arrayReverseIterator, - arrayToMap: () => arrayToMap, - arrayToMultiMap: () => arrayToMultiMap, - arrayToNumericMap: () => arrayToNumericMap, - assertType: () => assertType, - assign: () => assign, - asyncSuperHelper: () => asyncSuperHelper, - attachFileToDiagnostics: () => attachFileToDiagnostics, - base64decode: () => base64decode, - base64encode: () => base64encode, - binarySearch: () => binarySearch, - binarySearchKey: () => binarySearchKey, - bindSourceFile: () => bindSourceFile, - breakIntoCharacterSpans: () => breakIntoCharacterSpans, - breakIntoWordSpans: () => breakIntoWordSpans, - buildLinkParts: () => buildLinkParts, - buildOpts: () => buildOpts, - buildOverload: () => buildOverload, - bundlerModuleNameResolver: () => bundlerModuleNameResolver, - canBeConvertedToAsync: () => canBeConvertedToAsync, - canEmitTsBuildInfo: () => canEmitTsBuildInfo, - canHaveDecorators: () => canHaveDecorators, - canHaveExportModifier: () => canHaveExportModifier, - canHaveFlowNode: () => canHaveFlowNode, - canHaveIllegalDecorators: () => canHaveIllegalDecorators, - canHaveIllegalModifiers: () => canHaveIllegalModifiers, - canHaveIllegalType: () => canHaveIllegalType, - canHaveIllegalTypeParameters: () => canHaveIllegalTypeParameters, - canHaveJSDoc: () => canHaveJSDoc, - canHaveLocals: () => canHaveLocals, - canHaveModifiers: () => canHaveModifiers, - canHaveModuleSpecifier: () => canHaveModuleSpecifier, - canHaveSymbol: () => canHaveSymbol, - canIncludeBindAndCheckDiagnostics: () => canIncludeBindAndCheckDiagnostics, - canJsonReportNoInputFiles: () => canJsonReportNoInputFiles, - canProduceDiagnostics: () => canProduceDiagnostics, - canUsePropertyAccess: () => canUsePropertyAccess, - canWatchAffectingLocation: () => canWatchAffectingLocation, - canWatchAtTypes: () => canWatchAtTypes, - canWatchDirectoryOrFile: () => canWatchDirectoryOrFile, - cartesianProduct: () => cartesianProduct, - cast: () => cast, - chainBundle: () => chainBundle, - chainDiagnosticMessages: () => chainDiagnosticMessages, - changeAnyExtension: () => changeAnyExtension, - changeCompilerHostLikeToUseCache: () => changeCompilerHostLikeToUseCache, - changeExtension: () => changeExtension, - changeFullExtension: () => changeFullExtension, - changesAffectModuleResolution: () => changesAffectModuleResolution, - changesAffectingProgramStructure: () => changesAffectingProgramStructure, - characterCodeToRegularExpressionFlag: () => characterCodeToRegularExpressionFlag, - childIsDecorated: () => childIsDecorated, - classElementOrClassElementParameterIsDecorated: () => classElementOrClassElementParameterIsDecorated, - classHasClassThisAssignment: () => classHasClassThisAssignment, - classHasDeclaredOrExplicitlyAssignedName: () => classHasDeclaredOrExplicitlyAssignedName, - classHasExplicitlyAssignedName: () => classHasExplicitlyAssignedName, - classOrConstructorParameterIsDecorated: () => classOrConstructorParameterIsDecorated, - classicNameResolver: () => classicNameResolver, - classifier: () => ts_classifier_exports, - cleanExtendedConfigCache: () => cleanExtendedConfigCache, - clear: () => clear, - clearMap: () => clearMap, - clearSharedExtendedConfigFileWatcher: () => clearSharedExtendedConfigFileWatcher, - climbPastPropertyAccess: () => climbPastPropertyAccess, - clone: () => clone, - cloneCompilerOptions: () => cloneCompilerOptions, - closeFileWatcher: () => closeFileWatcher, - closeFileWatcherOf: () => closeFileWatcherOf, - codefix: () => ts_codefix_exports, - collapseTextChangeRangesAcrossMultipleVersions: () => collapseTextChangeRangesAcrossMultipleVersions, - collectExternalModuleInfo: () => collectExternalModuleInfo, - combine: () => combine, - combinePaths: () => combinePaths, - commandLineOptionOfCustomType: () => commandLineOptionOfCustomType, - commentPragmas: () => commentPragmas, - commonOptionsWithBuild: () => commonOptionsWithBuild, - compact: () => compact, - compareBooleans: () => compareBooleans, - compareDataObjects: () => compareDataObjects, - compareDiagnostics: () => compareDiagnostics, - compareEmitHelpers: () => compareEmitHelpers, - compareNumberOfDirectorySeparators: () => compareNumberOfDirectorySeparators, - comparePaths: () => comparePaths, - comparePathsCaseInsensitive: () => comparePathsCaseInsensitive, - comparePathsCaseSensitive: () => comparePathsCaseSensitive, - comparePatternKeys: () => comparePatternKeys, - compareProperties: () => compareProperties, - compareStringsCaseInsensitive: () => compareStringsCaseInsensitive, - compareStringsCaseInsensitiveEslintCompatible: () => compareStringsCaseInsensitiveEslintCompatible, - compareStringsCaseSensitive: () => compareStringsCaseSensitive, - compareStringsCaseSensitiveUI: () => compareStringsCaseSensitiveUI, - compareTextSpans: () => compareTextSpans, - compareValues: () => compareValues, - compilerOptionsAffectDeclarationPath: () => compilerOptionsAffectDeclarationPath, - compilerOptionsAffectEmit: () => compilerOptionsAffectEmit, - compilerOptionsAffectSemanticDiagnostics: () => compilerOptionsAffectSemanticDiagnostics, - compilerOptionsDidYouMeanDiagnostics: () => compilerOptionsDidYouMeanDiagnostics, - compilerOptionsIndicateEsModules: () => compilerOptionsIndicateEsModules, - computeCommonSourceDirectoryOfFilenames: () => computeCommonSourceDirectoryOfFilenames, - computeLineAndCharacterOfPosition: () => computeLineAndCharacterOfPosition, - computeLineOfPosition: () => computeLineOfPosition, - computeLineStarts: () => computeLineStarts, - computePositionOfLineAndCharacter: () => computePositionOfLineAndCharacter, - computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics, - computeSuggestionDiagnostics: () => computeSuggestionDiagnostics, - computedOptions: () => computedOptions, - concatenate: () => concatenate, - concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains, - consumesNodeCoreModules: () => consumesNodeCoreModules, - contains: () => contains, - containsIgnoredPath: () => containsIgnoredPath, - containsObjectRestOrSpread: () => containsObjectRestOrSpread, - containsParseError: () => containsParseError, - containsPath: () => containsPath, - convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry, - convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson, - convertJsonOption: () => convertJsonOption, - convertToBase64: () => convertToBase64, - convertToJson: () => convertToJson, - convertToObject: () => convertToObject, - convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths, - convertToRelativePath: () => convertToRelativePath, - convertToTSConfig: () => convertToTSConfig, - convertTypeAcquisitionFromJson: () => convertTypeAcquisitionFromJson, - copyComments: () => copyComments, - copyEntries: () => copyEntries, - copyLeadingComments: () => copyLeadingComments, - copyProperties: () => copyProperties, - copyTrailingAsLeadingComments: () => copyTrailingAsLeadingComments, - copyTrailingComments: () => copyTrailingComments, - couldStartTrivia: () => couldStartTrivia, - countWhere: () => countWhere, - createAbstractBuilder: () => createAbstractBuilder, - createAccessorPropertyBackingField: () => createAccessorPropertyBackingField, - createAccessorPropertyGetRedirector: () => createAccessorPropertyGetRedirector, - createAccessorPropertySetRedirector: () => createAccessorPropertySetRedirector, - createBaseNodeFactory: () => createBaseNodeFactory, - createBinaryExpressionTrampoline: () => createBinaryExpressionTrampoline, - createBuilderProgram: () => createBuilderProgram, - createBuilderProgramUsingIncrementalBuildInfo: () => createBuilderProgramUsingIncrementalBuildInfo, - createBuilderStatusReporter: () => createBuilderStatusReporter, - createCacheableExportInfoMap: () => createCacheableExportInfoMap, - createCachedDirectoryStructureHost: () => createCachedDirectoryStructureHost, - createClassifier: () => createClassifier, - createCommentDirectivesMap: () => createCommentDirectivesMap, - createCompilerDiagnostic: () => createCompilerDiagnostic, - createCompilerDiagnosticForInvalidCustomType: () => createCompilerDiagnosticForInvalidCustomType, - createCompilerDiagnosticFromMessageChain: () => createCompilerDiagnosticFromMessageChain, - createCompilerHost: () => createCompilerHost, - createCompilerHostFromProgramHost: () => createCompilerHostFromProgramHost, - createCompilerHostWorker: () => createCompilerHostWorker, - createDetachedDiagnostic: () => createDetachedDiagnostic, - createDiagnosticCollection: () => createDiagnosticCollection, - createDiagnosticForFileFromMessageChain: () => createDiagnosticForFileFromMessageChain, - createDiagnosticForNode: () => createDiagnosticForNode, - createDiagnosticForNodeArray: () => createDiagnosticForNodeArray, - createDiagnosticForNodeArrayFromMessageChain: () => createDiagnosticForNodeArrayFromMessageChain, - createDiagnosticForNodeFromMessageChain: () => createDiagnosticForNodeFromMessageChain, - createDiagnosticForNodeInSourceFile: () => createDiagnosticForNodeInSourceFile, - createDiagnosticForRange: () => createDiagnosticForRange, - createDiagnosticMessageChainFromDiagnostic: () => createDiagnosticMessageChainFromDiagnostic, - createDiagnosticReporter: () => createDiagnosticReporter, - createDocumentPositionMapper: () => createDocumentPositionMapper, - createDocumentRegistry: () => createDocumentRegistry, - createDocumentRegistryInternal: () => createDocumentRegistryInternal, - createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram, - createEmitHelperFactory: () => createEmitHelperFactory, - createEmptyExports: () => createEmptyExports, - createEvaluator: () => createEvaluator, - createExpressionForJsxElement: () => createExpressionForJsxElement, - createExpressionForJsxFragment: () => createExpressionForJsxFragment, - createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike, - createExpressionForPropertyName: () => createExpressionForPropertyName, - createExpressionFromEntityName: () => createExpressionFromEntityName, - createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded, - createFileDiagnostic: () => createFileDiagnostic, - createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain, - createFlowNode: () => createFlowNode, - createForOfBindingStatement: () => createForOfBindingStatement, - createFutureSourceFile: () => createFutureSourceFile, - createGetCanonicalFileName: () => createGetCanonicalFileName, - createGetIsolatedDeclarationErrors: () => createGetIsolatedDeclarationErrors, - createGetSourceFile: () => createGetSourceFile, - createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode, - createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName, - createGetSymbolWalker: () => createGetSymbolWalker, - createIncrementalCompilerHost: () => createIncrementalCompilerHost, - createIncrementalProgram: () => createIncrementalProgram, - createJsxFactoryExpression: () => createJsxFactoryExpression, - createLanguageService: () => createLanguageService, - createLanguageServiceSourceFile: () => createLanguageServiceSourceFile, - createMemberAccessForPropertyName: () => createMemberAccessForPropertyName, - createModeAwareCache: () => createModeAwareCache, - createModeAwareCacheKey: () => createModeAwareCacheKey, - createModeMismatchDetails: () => createModeMismatchDetails, - createModuleNotFoundChain: () => createModuleNotFoundChain, - createModuleResolutionCache: () => createModuleResolutionCache, - createModuleResolutionLoader: () => createModuleResolutionLoader, - createModuleResolutionLoaderUsingGlobalCache: () => createModuleResolutionLoaderUsingGlobalCache, - createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost, - createMultiMap: () => createMultiMap, - createNameResolver: () => createNameResolver, - createNodeConverters: () => createNodeConverters, - createNodeFactory: () => createNodeFactory, - createOptionNameMap: () => createOptionNameMap, - createOverload: () => createOverload, - createPackageJsonImportFilter: () => createPackageJsonImportFilter, - createPackageJsonInfo: () => createPackageJsonInfo, - createParenthesizerRules: () => createParenthesizerRules, - createPatternMatcher: () => createPatternMatcher, - createPrinter: () => createPrinter, - createPrinterWithDefaults: () => createPrinterWithDefaults, - createPrinterWithRemoveComments: () => createPrinterWithRemoveComments, - createPrinterWithRemoveCommentsNeverAsciiEscape: () => createPrinterWithRemoveCommentsNeverAsciiEscape, - createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => createPrinterWithRemoveCommentsOmitTrailingSemicolon, - createProgram: () => createProgram, - createProgramHost: () => createProgramHost, - createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral, - createQueue: () => createQueue, - createRange: () => createRange, - createRedirectedBuilderProgram: () => createRedirectedBuilderProgram, - createResolutionCache: () => createResolutionCache, - createRuntimeTypeSerializer: () => createRuntimeTypeSerializer, - createScanner: () => createScanner, - createSemanticDiagnosticsBuilderProgram: () => createSemanticDiagnosticsBuilderProgram, - createSet: () => createSet, - createSolutionBuilder: () => createSolutionBuilder, - createSolutionBuilderHost: () => createSolutionBuilderHost, - createSolutionBuilderWithWatch: () => createSolutionBuilderWithWatch, - createSolutionBuilderWithWatchHost: () => createSolutionBuilderWithWatchHost, - createSortedArray: () => createSortedArray, - createSourceFile: () => createSourceFile, - createSourceMapGenerator: () => createSourceMapGenerator, - createSourceMapSource: () => createSourceMapSource, - createSuperAccessVariableStatement: () => createSuperAccessVariableStatement, - createSymbolTable: () => createSymbolTable, - createSymlinkCache: () => createSymlinkCache, - createSyntacticTypeNodeBuilder: () => createSyntacticTypeNodeBuilder, - createSystemWatchFunctions: () => createSystemWatchFunctions, - createTextChange: () => createTextChange, - createTextChangeFromStartLength: () => createTextChangeFromStartLength, - createTextChangeRange: () => createTextChangeRange, - createTextRangeFromNode: () => createTextRangeFromNode, - createTextRangeFromSpan: () => createTextRangeFromSpan, - createTextSpan: () => createTextSpan, - createTextSpanFromBounds: () => createTextSpanFromBounds, - createTextSpanFromNode: () => createTextSpanFromNode, - createTextSpanFromRange: () => createTextSpanFromRange, - createTextSpanFromStringLiteralLikeContent: () => createTextSpanFromStringLiteralLikeContent, - createTextWriter: () => createTextWriter, - createTokenRange: () => createTokenRange, - createTypeChecker: () => createTypeChecker, - createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache, - createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader, - createWatchCompilerHost: () => createWatchCompilerHost2, - createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile, - createWatchCompilerHostOfFilesAndCompilerOptions: () => createWatchCompilerHostOfFilesAndCompilerOptions, - createWatchFactory: () => createWatchFactory, - createWatchHost: () => createWatchHost, - createWatchProgram: () => createWatchProgram, - createWatchStatusReporter: () => createWatchStatusReporter, - createWriteFileMeasuringIO: () => createWriteFileMeasuringIO, - declarationNameToString: () => declarationNameToString, - decodeMappings: () => decodeMappings, - decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith, - deduplicate: () => deduplicate, - defaultInitCompilerOptions: () => defaultInitCompilerOptions, - defaultMaximumTruncationLength: () => defaultMaximumTruncationLength, - deno: () => deno_exports, - diagnosticCategoryName: () => diagnosticCategoryName, - diagnosticToString: () => diagnosticToString, - diagnosticsEqualityComparer: () => diagnosticsEqualityComparer, - directoryProbablyExists: () => directoryProbablyExists, - directorySeparator: () => directorySeparator, - displayPart: () => displayPart, - displayPartsToString: () => displayPartsToString, - disposeEmitNodes: () => disposeEmitNodes, - documentSpansEqual: () => documentSpansEqual, - dumpTracingLegend: () => dumpTracingLegend, - elementAt: () => elementAt, - elideNodes: () => elideNodes, - emitDetachedComments: () => emitDetachedComments, - emitFiles: () => emitFiles, - emitFilesAndReportErrors: () => emitFilesAndReportErrors, - emitFilesAndReportErrorsAndGetExitStatus: () => emitFilesAndReportErrorsAndGetExitStatus, - emitModuleKindIsNonNodeESM: () => emitModuleKindIsNonNodeESM, - emitNewLineBeforeLeadingCommentOfPosition: () => emitNewLineBeforeLeadingCommentOfPosition, - emitResolverSkipsTypeChecking: () => emitResolverSkipsTypeChecking, - emitSkippedWithNoDiagnostics: () => emitSkippedWithNoDiagnostics, - emptyArray: () => emptyArray, - emptyFileSystemEntries: () => emptyFileSystemEntries, - emptyMap: () => emptyMap, - emptyOptions: () => emptyOptions, - endsWith: () => endsWith, - ensurePathIsNonModuleName: () => ensurePathIsNonModuleName, - ensureScriptKind: () => ensureScriptKind, - ensureTrailingDirectorySeparator: () => ensureTrailingDirectorySeparator, - entityNameToString: () => entityNameToString, - enumerateInsertsAndDeletes: () => enumerateInsertsAndDeletes, - equalOwnProperties: () => equalOwnProperties, - equateStringsCaseInsensitive: () => equateStringsCaseInsensitive, - equateStringsCaseSensitive: () => equateStringsCaseSensitive, - equateValues: () => equateValues, - escapeJsxAttributeString: () => escapeJsxAttributeString, - escapeLeadingUnderscores: () => escapeLeadingUnderscores, - escapeNonAsciiString: () => escapeNonAsciiString, - escapeSnippetText: () => escapeSnippetText, - escapeString: () => escapeString, - escapeTemplateSubstitution: () => escapeTemplateSubstitution, - evaluatorResult: () => evaluatorResult, - every: () => every, - executeCommandLine: () => executeCommandLine, - expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression, - explainFiles: () => explainFiles, - explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat, - exportAssignmentIsAlias: () => exportAssignmentIsAlias, - expressionResultIsUnused: () => expressionResultIsUnused, - extend: () => extend, - extensionFromPath: () => extensionFromPath, - extensionIsTS: () => extensionIsTS, - extensionsNotSupportingExtensionlessResolution: () => extensionsNotSupportingExtensionlessResolution, - externalHelpersModuleNameText: () => externalHelpersModuleNameText, - factory: () => factory, - fileContainsPackageImport: () => fileContainsPackageImport, - fileExtensionIs: () => fileExtensionIs, - fileExtensionIsOneOf: () => fileExtensionIsOneOf, - fileIncludeReasonToDiagnostics: () => fileIncludeReasonToDiagnostics, - fileShouldUseJavaScriptRequire: () => fileShouldUseJavaScriptRequire, - filter: () => filter, - filterMutate: () => filterMutate, - filterSemanticDiagnostics: () => filterSemanticDiagnostics, - find: () => find, - findAncestor: () => findAncestor, - findBestPatternMatch: () => findBestPatternMatch, - findChildOfKind: () => findChildOfKind, - findComputedPropertyNameCacheAssignment: () => findComputedPropertyNameCacheAssignment, - findConfigFile: () => findConfigFile, - findConstructorDeclaration: () => findConstructorDeclaration, - findContainingList: () => findContainingList, - findDiagnosticForNode: () => findDiagnosticForNode, - findFirstNonJsxWhitespaceToken: () => findFirstNonJsxWhitespaceToken, - findIndex: () => findIndex, - findLast: () => findLast, - findLastIndex: () => findLastIndex, - findListItemInfo: () => findListItemInfo, - findModifier: () => findModifier, - findNextToken: () => findNextToken, - findPackageJson: () => findPackageJson, - findPackageJsons: () => findPackageJsons, - findPrecedingMatchingToken: () => findPrecedingMatchingToken, - findPrecedingToken: () => findPrecedingToken, - findSuperStatementIndexPath: () => findSuperStatementIndexPath, - findTokenOnLeftOfPosition: () => findTokenOnLeftOfPosition, - findUseStrictPrologue: () => findUseStrictPrologue, - first: () => first, - firstDefined: () => firstDefined, - firstDefinedIterator: () => firstDefinedIterator, - firstIterator: () => firstIterator, - firstOrOnly: () => firstOrOnly, - firstOrUndefined: () => firstOrUndefined, - firstOrUndefinedIterator: () => firstOrUndefinedIterator, - fixupCompilerOptions: () => fixupCompilerOptions, - flatMap: () => flatMap, - flatMapIterator: () => flatMapIterator, - flatMapToMutable: () => flatMapToMutable, - flatten: () => flatten, - flattenCommaList: () => flattenCommaList, - flattenDestructuringAssignment: () => flattenDestructuringAssignment, - flattenDestructuringBinding: () => flattenDestructuringBinding, - flattenDiagnosticMessageText: () => flattenDiagnosticMessageText, - forEach: () => forEach, - forEachAncestor: () => forEachAncestor, - forEachAncestorDirectory: () => forEachAncestorDirectory, - forEachChild: () => forEachChild, - forEachChildRecursively: () => forEachChildRecursively, - forEachEmittedFile: () => forEachEmittedFile, - forEachEnclosingBlockScopeContainer: () => forEachEnclosingBlockScopeContainer, - forEachEntry: () => forEachEntry, - forEachExternalModuleToImportFrom: () => forEachExternalModuleToImportFrom, - forEachImportClauseDeclaration: () => forEachImportClauseDeclaration, - forEachKey: () => forEachKey, - forEachLeadingCommentRange: () => forEachLeadingCommentRange, - forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft, - forEachNameOfDefaultExport: () => forEachNameOfDefaultExport, - forEachPropertyAssignment: () => forEachPropertyAssignment, - forEachResolvedProjectReference: () => forEachResolvedProjectReference, - forEachReturnStatement: () => forEachReturnStatement, - forEachRight: () => forEachRight, - forEachTrailingCommentRange: () => forEachTrailingCommentRange, - forEachTsConfigPropArray: () => forEachTsConfigPropArray, - forEachUnique: () => forEachUnique, - forEachYieldExpression: () => forEachYieldExpression, - formatColorAndReset: () => formatColorAndReset, - formatDiagnostic: () => formatDiagnostic, - formatDiagnostics: () => formatDiagnostics, - formatDiagnosticsWithColorAndContext: () => formatDiagnosticsWithColorAndContext, - formatGeneratedName: () => formatGeneratedName, - formatGeneratedNamePart: () => formatGeneratedNamePart, - formatLocation: () => formatLocation, - formatMessage: () => formatMessage, - formatStringFromArgs: () => formatStringFromArgs, - formatting: () => ts_formatting_exports, - generateDjb2Hash: () => generateDjb2Hash, - generateTSConfig: () => generateTSConfig, - getAdjustedReferenceLocation: () => getAdjustedReferenceLocation, - getAdjustedRenameLocation: () => getAdjustedRenameLocation, - getAliasDeclarationFromName: () => getAliasDeclarationFromName, - getAllAccessorDeclarations: () => getAllAccessorDeclarations, - getAllDecoratorsOfClass: () => getAllDecoratorsOfClass, - getAllDecoratorsOfClassElement: () => getAllDecoratorsOfClassElement, - getAllJSDocTags: () => getAllJSDocTags, - getAllJSDocTagsOfKind: () => getAllJSDocTagsOfKind, - getAllKeys: () => getAllKeys, - getAllProjectOutputs: () => getAllProjectOutputs, - getAllSuperTypeNodes: () => getAllSuperTypeNodes, - getAllowJSCompilerOption: () => getAllowJSCompilerOption, - getAllowSyntheticDefaultImports: () => getAllowSyntheticDefaultImports, - getAncestor: () => getAncestor, - getAnyExtensionFromPath: () => getAnyExtensionFromPath, - getAreDeclarationMapsEnabled: () => getAreDeclarationMapsEnabled, - getAssignedExpandoInitializer: () => getAssignedExpandoInitializer, - getAssignedName: () => getAssignedName, - getAssignmentDeclarationKind: () => getAssignmentDeclarationKind, - getAssignmentDeclarationPropertyAccessKind: () => getAssignmentDeclarationPropertyAccessKind, - getAssignmentTargetKind: () => getAssignmentTargetKind, - getAutomaticTypeDirectiveNames: () => getAutomaticTypeDirectiveNames, - getBaseFileName: () => getBaseFileName, - getBinaryOperatorPrecedence: () => getBinaryOperatorPrecedence, - getBuildInfo: () => getBuildInfo, - getBuildInfoFileVersionMap: () => getBuildInfoFileVersionMap, - getBuildInfoText: () => getBuildInfoText, - getBuildOrderFromAnyBuildOrder: () => getBuildOrderFromAnyBuildOrder, - getBuilderCreationParameters: () => getBuilderCreationParameters, - getBuilderFileEmit: () => getBuilderFileEmit, - getCanonicalDiagnostic: () => getCanonicalDiagnostic, - getCheckFlags: () => getCheckFlags, - getClassExtendsHeritageElement: () => getClassExtendsHeritageElement, - getClassLikeDeclarationOfSymbol: () => getClassLikeDeclarationOfSymbol, - getCombinedLocalAndExportSymbolFlags: () => getCombinedLocalAndExportSymbolFlags, - getCombinedModifierFlags: () => getCombinedModifierFlags, - getCombinedNodeFlags: () => getCombinedNodeFlags, - getCombinedNodeFlagsAlwaysIncludeJSDoc: () => getCombinedNodeFlagsAlwaysIncludeJSDoc, - getCommentRange: () => getCommentRange, - getCommonSourceDirectory: () => getCommonSourceDirectory, - getCommonSourceDirectoryOfConfig: () => getCommonSourceDirectoryOfConfig, - getCompilerOptionValue: () => getCompilerOptionValue, - getCompilerOptionsDiffValue: () => getCompilerOptionsDiffValue, - getConditions: () => getConditions, - getConfigFileParsingDiagnostics: () => getConfigFileParsingDiagnostics, - getConstantValue: () => getConstantValue, - getContainerFlags: () => getContainerFlags, - getContainerNode: () => getContainerNode, - getContainingClass: () => getContainingClass, - getContainingClassExcludingClassDecorators: () => getContainingClassExcludingClassDecorators, - getContainingClassStaticBlock: () => getContainingClassStaticBlock, - getContainingFunction: () => getContainingFunction, - getContainingFunctionDeclaration: () => getContainingFunctionDeclaration, - getContainingFunctionOrClassStaticBlock: () => getContainingFunctionOrClassStaticBlock, - getContainingNodeArray: () => getContainingNodeArray, - getContainingObjectLiteralElement: () => getContainingObjectLiteralElement, - getContextualTypeFromParent: () => getContextualTypeFromParent, - getContextualTypeFromParentOrAncestorTypeNode: () => getContextualTypeFromParentOrAncestorTypeNode, - getDeclarationDiagnostics: () => getDeclarationDiagnostics, - getDeclarationEmitExtensionForPath: () => getDeclarationEmitExtensionForPath, - getDeclarationEmitOutputFilePath: () => getDeclarationEmitOutputFilePath, - getDeclarationEmitOutputFilePathWorker: () => getDeclarationEmitOutputFilePathWorker, - getDeclarationFileExtension: () => getDeclarationFileExtension, - getDeclarationFromName: () => getDeclarationFromName, - getDeclarationModifierFlagsFromSymbol: () => getDeclarationModifierFlagsFromSymbol, - getDeclarationOfKind: () => getDeclarationOfKind, - getDeclarationsOfKind: () => getDeclarationsOfKind, - getDeclaredExpandoInitializer: () => getDeclaredExpandoInitializer, - getDecorators: () => getDecorators, - getDefaultCompilerOptions: () => getDefaultCompilerOptions2, - getDefaultFormatCodeSettings: () => getDefaultFormatCodeSettings, - getDefaultLibFileName: () => getDefaultLibFileName, - getDefaultLibFilePath: () => getDefaultLibFilePath, - getDefaultLikeExportInfo: () => getDefaultLikeExportInfo, - getDefaultLikeExportNameFromDeclaration: () => getDefaultLikeExportNameFromDeclaration, - getDefaultResolutionModeForFileWorker: () => getDefaultResolutionModeForFileWorker, - getDiagnosticText: () => getDiagnosticText, - getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan, - getDirectoryPath: () => getDirectoryPath, - getDirectoryToWatchFailedLookupLocation: () => getDirectoryToWatchFailedLookupLocation, - getDirectoryToWatchFailedLookupLocationFromTypeRoot: () => getDirectoryToWatchFailedLookupLocationFromTypeRoot, - getDocumentPositionMapper: () => getDocumentPositionMapper, - getDocumentSpansEqualityComparer: () => getDocumentSpansEqualityComparer, - getESModuleInterop: () => getESModuleInterop, - getEditsForFileRename: () => getEditsForFileRename, - getEffectiveBaseTypeNode: () => getEffectiveBaseTypeNode, - getEffectiveConstraintOfTypeParameter: () => getEffectiveConstraintOfTypeParameter, - getEffectiveContainerForJSDocTemplateTag: () => getEffectiveContainerForJSDocTemplateTag, - getEffectiveImplementsTypeNodes: () => getEffectiveImplementsTypeNodes, - getEffectiveInitializer: () => getEffectiveInitializer, - getEffectiveJSDocHost: () => getEffectiveJSDocHost, - getEffectiveModifierFlags: () => getEffectiveModifierFlags, - getEffectiveModifierFlagsAlwaysIncludeJSDoc: () => getEffectiveModifierFlagsAlwaysIncludeJSDoc, - getEffectiveModifierFlagsNoCache: () => getEffectiveModifierFlagsNoCache, - getEffectiveReturnTypeNode: () => getEffectiveReturnTypeNode, - getEffectiveSetAccessorTypeAnnotationNode: () => getEffectiveSetAccessorTypeAnnotationNode, - getEffectiveTypeAnnotationNode: () => getEffectiveTypeAnnotationNode, - getEffectiveTypeParameterDeclarations: () => getEffectiveTypeParameterDeclarations, - getEffectiveTypeRoots: () => getEffectiveTypeRoots, - getElementOrPropertyAccessArgumentExpressionOrName: () => getElementOrPropertyAccessArgumentExpressionOrName, - getElementOrPropertyAccessName: () => getElementOrPropertyAccessName, - getElementsOfBindingOrAssignmentPattern: () => getElementsOfBindingOrAssignmentPattern, - getEmitDeclarations: () => getEmitDeclarations, - getEmitFlags: () => getEmitFlags, - getEmitHelpers: () => getEmitHelpers, - getEmitModuleDetectionKind: () => getEmitModuleDetectionKind, - getEmitModuleFormatOfFileWorker: () => getEmitModuleFormatOfFileWorker, - getEmitModuleKind: () => getEmitModuleKind, - getEmitModuleResolutionKind: () => getEmitModuleResolutionKind, - getEmitScriptTarget: () => getEmitScriptTarget, - getEmitStandardClassFields: () => getEmitStandardClassFields, - getEnclosingBlockScopeContainer: () => getEnclosingBlockScopeContainer, - getEnclosingContainer: () => getEnclosingContainer, - getEncodedSemanticClassifications: () => getEncodedSemanticClassifications, - getEncodedSyntacticClassifications: () => getEncodedSyntacticClassifications, - getEndLinePosition: () => getEndLinePosition, - getEntityNameFromTypeNode: () => getEntityNameFromTypeNode, - getEntrypointsFromPackageJsonInfo: () => getEntrypointsFromPackageJsonInfo, - getErrorCountForSummary: () => getErrorCountForSummary, - getErrorSpanForNode: () => getErrorSpanForNode, - getErrorSummaryText: () => getErrorSummaryText, - getEscapedTextOfIdentifierOrLiteral: () => getEscapedTextOfIdentifierOrLiteral, - getEscapedTextOfJsxAttributeName: () => getEscapedTextOfJsxAttributeName, - getEscapedTextOfJsxNamespacedName: () => getEscapedTextOfJsxNamespacedName, - getExpandoInitializer: () => getExpandoInitializer, - getExportAssignmentExpression: () => getExportAssignmentExpression, - getExportInfoMap: () => getExportInfoMap, - getExportNeedsImportStarHelper: () => getExportNeedsImportStarHelper, - getExpressionAssociativity: () => getExpressionAssociativity, - getExpressionPrecedence: () => getExpressionPrecedence, - getExternalHelpersModuleName: () => getExternalHelpersModuleName, - getExternalModuleImportEqualsDeclarationExpression: () => getExternalModuleImportEqualsDeclarationExpression, - getExternalModuleName: () => getExternalModuleName, - getExternalModuleNameFromDeclaration: () => getExternalModuleNameFromDeclaration, - getExternalModuleNameFromPath: () => getExternalModuleNameFromPath, - getExternalModuleNameLiteral: () => getExternalModuleNameLiteral, - getExternalModuleRequireArgument: () => getExternalModuleRequireArgument, - getFallbackOptions: () => getFallbackOptions, - getFileEmitOutput: () => getFileEmitOutput, - getFileMatcherPatterns: () => getFileMatcherPatterns, - getFileNamesFromConfigSpecs: () => getFileNamesFromConfigSpecs, - getFileWatcherEventKind: () => getFileWatcherEventKind, - getFilesInErrorForSummary: () => getFilesInErrorForSummary, - getFirstConstructorWithBody: () => getFirstConstructorWithBody, - getFirstIdentifier: () => getFirstIdentifier, - getFirstNonSpaceCharacterPosition: () => getFirstNonSpaceCharacterPosition, - getFirstProjectOutput: () => getFirstProjectOutput, - getFixableErrorSpanExpression: () => getFixableErrorSpanExpression, - getFormatCodeSettingsForWriting: () => getFormatCodeSettingsForWriting, - getFullWidth: () => getFullWidth, - getFunctionFlags: () => getFunctionFlags, - getHeritageClause: () => getHeritageClause, - getHostSignatureFromJSDoc: () => getHostSignatureFromJSDoc, - getIdentifierAutoGenerate: () => getIdentifierAutoGenerate, - getIdentifierGeneratedImportReference: () => getIdentifierGeneratedImportReference, - getIdentifierTypeArguments: () => getIdentifierTypeArguments, - getImmediatelyInvokedFunctionExpression: () => getImmediatelyInvokedFunctionExpression, - getImpliedNodeFormatForEmitWorker: () => getImpliedNodeFormatForEmitWorker, - getImpliedNodeFormatForFile: () => getImpliedNodeFormatForFile, - getImpliedNodeFormatForFileWorker: () => getImpliedNodeFormatForFileWorker, - getImportNeedsImportDefaultHelper: () => getImportNeedsImportDefaultHelper, - getImportNeedsImportStarHelper: () => getImportNeedsImportStarHelper, - getIndentString: () => getIndentString, - getInferredLibraryNameResolveFrom: () => getInferredLibraryNameResolveFrom, - getInitializedVariables: () => getInitializedVariables, - getInitializerOfBinaryExpression: () => getInitializerOfBinaryExpression, - getInitializerOfBindingOrAssignmentElement: () => getInitializerOfBindingOrAssignmentElement, - getInterfaceBaseTypeNodes: () => getInterfaceBaseTypeNodes, - getInternalEmitFlags: () => getInternalEmitFlags, - getInvokedExpression: () => getInvokedExpression, - getIsFileExcluded: () => getIsFileExcluded, - getIsolatedModules: () => getIsolatedModules, - getJSDocAugmentsTag: () => getJSDocAugmentsTag, - getJSDocClassTag: () => getJSDocClassTag, - getJSDocCommentRanges: () => getJSDocCommentRanges, - getJSDocCommentsAndTags: () => getJSDocCommentsAndTags, - getJSDocDeprecatedTag: () => getJSDocDeprecatedTag, - getJSDocDeprecatedTagNoCache: () => getJSDocDeprecatedTagNoCache, - getJSDocEnumTag: () => getJSDocEnumTag, - getJSDocHost: () => getJSDocHost, - getJSDocImplementsTags: () => getJSDocImplementsTags, - getJSDocOverloadTags: () => getJSDocOverloadTags, - getJSDocOverrideTagNoCache: () => getJSDocOverrideTagNoCache, - getJSDocParameterTags: () => getJSDocParameterTags, - getJSDocParameterTagsNoCache: () => getJSDocParameterTagsNoCache, - getJSDocPrivateTag: () => getJSDocPrivateTag, - getJSDocPrivateTagNoCache: () => getJSDocPrivateTagNoCache, - getJSDocProtectedTag: () => getJSDocProtectedTag, - getJSDocProtectedTagNoCache: () => getJSDocProtectedTagNoCache, - getJSDocPublicTag: () => getJSDocPublicTag, - getJSDocPublicTagNoCache: () => getJSDocPublicTagNoCache, - getJSDocReadonlyTag: () => getJSDocReadonlyTag, - getJSDocReadonlyTagNoCache: () => getJSDocReadonlyTagNoCache, - getJSDocReturnTag: () => getJSDocReturnTag, - getJSDocReturnType: () => getJSDocReturnType, - getJSDocRoot: () => getJSDocRoot, - getJSDocSatisfiesExpressionType: () => getJSDocSatisfiesExpressionType, - getJSDocSatisfiesTag: () => getJSDocSatisfiesTag, - getJSDocTags: () => getJSDocTags, - getJSDocTemplateTag: () => getJSDocTemplateTag, - getJSDocThisTag: () => getJSDocThisTag, - getJSDocType: () => getJSDocType, - getJSDocTypeAliasName: () => getJSDocTypeAliasName, - getJSDocTypeAssertionType: () => getJSDocTypeAssertionType, - getJSDocTypeParameterDeclarations: () => getJSDocTypeParameterDeclarations, - getJSDocTypeParameterTags: () => getJSDocTypeParameterTags, - getJSDocTypeParameterTagsNoCache: () => getJSDocTypeParameterTagsNoCache, - getJSDocTypeTag: () => getJSDocTypeTag, - getJSXImplicitImportBase: () => getJSXImplicitImportBase, - getJSXRuntimeImport: () => getJSXRuntimeImport, - getJSXTransformEnabled: () => getJSXTransformEnabled, - getKeyForCompilerOptions: () => getKeyForCompilerOptions, - getLanguageVariant: () => getLanguageVariant, - getLastChild: () => getLastChild, - getLeadingCommentRanges: () => getLeadingCommentRanges, - getLeadingCommentRangesOfNode: () => getLeadingCommentRangesOfNode, - getLeftmostAccessExpression: () => getLeftmostAccessExpression, - getLeftmostExpression: () => getLeftmostExpression, - getLibraryNameFromLibFileName: () => getLibraryNameFromLibFileName, - getLineAndCharacterOfPosition: () => getLineAndCharacterOfPosition, - getLineInfo: () => getLineInfo, - getLineOfLocalPosition: () => getLineOfLocalPosition, - getLineStartPositionForPosition: () => getLineStartPositionForPosition, - getLineStarts: () => getLineStarts, - getLinesBetweenPositionAndNextNonWhitespaceCharacter: () => getLinesBetweenPositionAndNextNonWhitespaceCharacter, - getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter: () => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter, - getLinesBetweenPositions: () => getLinesBetweenPositions, - getLinesBetweenRangeEndAndRangeStart: () => getLinesBetweenRangeEndAndRangeStart, - getLinesBetweenRangeEndPositions: () => getLinesBetweenRangeEndPositions, - getLiteralText: () => getLiteralText, - getLocalNameForExternalImport: () => getLocalNameForExternalImport, - getLocalSymbolForExportDefault: () => getLocalSymbolForExportDefault, - getLocaleSpecificMessage: () => getLocaleSpecificMessage, - getLocaleTimeString: () => getLocaleTimeString, - getMappedContextSpan: () => getMappedContextSpan, - getMappedDocumentSpan: () => getMappedDocumentSpan, - getMappedLocation: () => getMappedLocation, - getMatchedFileSpec: () => getMatchedFileSpec, - getMatchedIncludeSpec: () => getMatchedIncludeSpec, - getMeaningFromDeclaration: () => getMeaningFromDeclaration, - getMeaningFromLocation: () => getMeaningFromLocation, - getMembersOfDeclaration: () => getMembersOfDeclaration, - getModeForFileReference: () => getModeForFileReference, - getModeForResolutionAtIndex: () => getModeForResolutionAtIndex, - getModeForUsageLocation: () => getModeForUsageLocation, - getModifiedTime: () => getModifiedTime, - getModifiers: () => getModifiers, - getModuleInstanceState: () => getModuleInstanceState, - getModuleNameStringLiteralAt: () => getModuleNameStringLiteralAt, - getModuleSpecifierEndingPreference: () => getModuleSpecifierEndingPreference, - getModuleSpecifierResolverHost: () => getModuleSpecifierResolverHost, - getNameForExportedSymbol: () => getNameForExportedSymbol, - getNameFromImportAttribute: () => getNameFromImportAttribute, - getNameFromIndexInfo: () => getNameFromIndexInfo, - getNameFromPropertyName: () => getNameFromPropertyName, - getNameOfAccessExpression: () => getNameOfAccessExpression, - getNameOfCompilerOptionValue: () => getNameOfCompilerOptionValue, - getNameOfDeclaration: () => getNameOfDeclaration, - getNameOfExpando: () => getNameOfExpando, - getNameOfJSDocTypedef: () => getNameOfJSDocTypedef, - getNameOfScriptTarget: () => getNameOfScriptTarget, - getNameOrArgument: () => getNameOrArgument, - getNameTable: () => getNameTable, - getNamespaceDeclarationNode: () => getNamespaceDeclarationNode, - getNewLineCharacter: () => getNewLineCharacter, - getNewLineKind: () => getNewLineKind, - getNewLineOrDefaultFromHost: () => getNewLineOrDefaultFromHost, - getNewTargetContainer: () => getNewTargetContainer, - getNextJSDocCommentLocation: () => getNextJSDocCommentLocation, - getNodeChildren: () => getNodeChildren, - getNodeForGeneratedName: () => getNodeForGeneratedName, - getNodeId: () => getNodeId, - getNodeKind: () => getNodeKind, - getNodeModifiers: () => getNodeModifiers, - getNodeModulePathParts: () => getNodeModulePathParts, - getNonAssignedNameOfDeclaration: () => getNonAssignedNameOfDeclaration, - getNonAssignmentOperatorForCompoundAssignment: () => getNonAssignmentOperatorForCompoundAssignment, - getNonAugmentationDeclaration: () => getNonAugmentationDeclaration, - getNonDecoratorTokenPosOfNode: () => getNonDecoratorTokenPosOfNode, - getNonIncrementalBuildInfoRoots: () => getNonIncrementalBuildInfoRoots, - getNonModifierTokenPosOfNode: () => getNonModifierTokenPosOfNode, - getNormalizedAbsolutePath: () => getNormalizedAbsolutePath, - getNormalizedAbsolutePathWithoutRoot: () => getNormalizedAbsolutePathWithoutRoot, - getNormalizedPathComponents: () => getNormalizedPathComponents, - getObjectFlags: () => getObjectFlags, - getOperatorAssociativity: () => getOperatorAssociativity, - getOperatorPrecedence: () => getOperatorPrecedence, - getOptionFromName: () => getOptionFromName, - getOptionsForLibraryResolution: () => getOptionsForLibraryResolution, - getOptionsNameMap: () => getOptionsNameMap, - getOrCreateEmitNode: () => getOrCreateEmitNode, - getOrUpdate: () => getOrUpdate, - getOriginalNode: () => getOriginalNode, - getOriginalNodeId: () => getOriginalNodeId, - getOutputDeclarationFileName: () => getOutputDeclarationFileName, - getOutputDeclarationFileNameWorker: () => getOutputDeclarationFileNameWorker, - getOutputExtension: () => getOutputExtension, - getOutputFileNames: () => getOutputFileNames, - getOutputJSFileNameWorker: () => getOutputJSFileNameWorker, - getOutputPathsFor: () => getOutputPathsFor, - getOwnEmitOutputFilePath: () => getOwnEmitOutputFilePath, - getOwnKeys: () => getOwnKeys, - getOwnValues: () => getOwnValues, - getPackageJsonTypesVersionsPaths: () => getPackageJsonTypesVersionsPaths, - getPackageNameFromTypesPackageName: () => getPackageNameFromTypesPackageName, - getPackageScopeForPath: () => getPackageScopeForPath, - getParameterSymbolFromJSDoc: () => getParameterSymbolFromJSDoc, - getParentNodeInSpan: () => getParentNodeInSpan, - getParseTreeNode: () => getParseTreeNode, - getParsedCommandLineOfConfigFile: () => getParsedCommandLineOfConfigFile, - getPathComponents: () => getPathComponents, - getPathFromPathComponents: () => getPathFromPathComponents, - getPathUpdater: () => getPathUpdater, - getPathsBasePath: () => getPathsBasePath, - getPatternFromSpec: () => getPatternFromSpec, - getPendingEmitKindWithSeen: () => getPendingEmitKindWithSeen, - getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter, - getPossibleGenericSignatures: () => getPossibleGenericSignatures, - getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension, - getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo, - getPreEmitDiagnostics: () => getPreEmitDiagnostics, - getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition, - getPrivateIdentifier: () => getPrivateIdentifier, - getProperties: () => getProperties, - getProperty: () => getProperty, - getPropertyArrayElementValue: () => getPropertyArrayElementValue, - getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression, - getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode, - getPropertyNameFromType: () => getPropertyNameFromType, - getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement, - getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement, - getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType, - getQuoteFromPreference: () => getQuoteFromPreference, - getQuotePreference: () => getQuotePreference, - getRangesWhere: () => getRangesWhere, - getRefactorContextSpan: () => getRefactorContextSpan, - getReferencedFileLocation: () => getReferencedFileLocation, - getRegexFromPattern: () => getRegexFromPattern, - getRegularExpressionForWildcard: () => getRegularExpressionForWildcard, - getRegularExpressionsForWildcards: () => getRegularExpressionsForWildcards, - getRelativePathFromDirectory: () => getRelativePathFromDirectory, - getRelativePathFromFile: () => getRelativePathFromFile, - getRelativePathToDirectoryOrUrl: () => getRelativePathToDirectoryOrUrl, - getRenameLocation: () => getRenameLocation, - getReplacementSpanForContextToken: () => getReplacementSpanForContextToken, - getResolutionDiagnostic: () => getResolutionDiagnostic, - getResolutionModeOverride: () => getResolutionModeOverride, - getResolveJsonModule: () => getResolveJsonModule, - getResolvePackageJsonExports: () => getResolvePackageJsonExports, - getResolvePackageJsonImports: () => getResolvePackageJsonImports, - getResolvedExternalModuleName: () => getResolvedExternalModuleName, - getResolvedModuleFromResolution: () => getResolvedModuleFromResolution, - getResolvedTypeReferenceDirectiveFromResolution: () => getResolvedTypeReferenceDirectiveFromResolution, - getRestIndicatorOfBindingOrAssignmentElement: () => getRestIndicatorOfBindingOrAssignmentElement, - getRestParameterElementType: () => getRestParameterElementType, - getRightMostAssignedExpression: () => getRightMostAssignedExpression, - getRootDeclaration: () => getRootDeclaration, - getRootDirectoryOfResolutionCache: () => getRootDirectoryOfResolutionCache, - getRootLength: () => getRootLength, - getScriptKind: () => getScriptKind, - getScriptKindFromFileName: () => getScriptKindFromFileName, - getScriptTargetFeatures: () => getScriptTargetFeatures, - getSelectedEffectiveModifierFlags: () => getSelectedEffectiveModifierFlags, - getSelectedSyntacticModifierFlags: () => getSelectedSyntacticModifierFlags, - getSemanticClassifications: () => getSemanticClassifications, - getSemanticJsxChildren: () => getSemanticJsxChildren, - getSetAccessorTypeAnnotationNode: () => getSetAccessorTypeAnnotationNode, - getSetAccessorValueParameter: () => getSetAccessorValueParameter, - getSetExternalModuleIndicator: () => getSetExternalModuleIndicator, - getShebang: () => getShebang, - getSingleVariableOfVariableStatement: () => getSingleVariableOfVariableStatement, - getSnapshotText: () => getSnapshotText, - getSnippetElement: () => getSnippetElement, - getSourceFileOfModule: () => getSourceFileOfModule, - getSourceFileOfNode: () => getSourceFileOfNode, - getSourceFilePathInNewDir: () => getSourceFilePathInNewDir, - getSourceFileVersionAsHashFromText: () => getSourceFileVersionAsHashFromText, - getSourceFilesToEmit: () => getSourceFilesToEmit, - getSourceMapRange: () => getSourceMapRange, - getSourceMapper: () => getSourceMapper, - getSourceTextOfNodeFromSourceFile: () => getSourceTextOfNodeFromSourceFile, - getSpanOfTokenAtPosition: () => getSpanOfTokenAtPosition, - getSpellingSuggestion: () => getSpellingSuggestion, - getStartPositionOfLine: () => getStartPositionOfLine, - getStartPositionOfRange: () => getStartPositionOfRange, - getStartsOnNewLine: () => getStartsOnNewLine, - getStaticPropertiesAndClassStaticBlock: () => getStaticPropertiesAndClassStaticBlock, - getStrictOptionValue: () => getStrictOptionValue, - getStringComparer: () => getStringComparer, - getSubPatternFromSpec: () => getSubPatternFromSpec, - getSuperCallFromStatement: () => getSuperCallFromStatement, - getSuperContainer: () => getSuperContainer, - getSupportedCodeFixes: () => getSupportedCodeFixes, - getSupportedExtensions: () => getSupportedExtensions, - getSupportedExtensionsWithJsonIfResolveJsonModule: () => getSupportedExtensionsWithJsonIfResolveJsonModule, - getSwitchedType: () => getSwitchedType, - getSymbolId: () => getSymbolId, - getSymbolNameForPrivateIdentifier: () => getSymbolNameForPrivateIdentifier, - getSymbolTarget: () => getSymbolTarget, - getSyntacticClassifications: () => getSyntacticClassifications, - getSyntacticModifierFlags: () => getSyntacticModifierFlags, - getSyntacticModifierFlagsNoCache: () => getSyntacticModifierFlagsNoCache, - getSynthesizedDeepClone: () => getSynthesizedDeepClone, - getSynthesizedDeepCloneWithReplacements: () => getSynthesizedDeepCloneWithReplacements, - getSynthesizedDeepClones: () => getSynthesizedDeepClones, - getSynthesizedDeepClonesWithReplacements: () => getSynthesizedDeepClonesWithReplacements, - getSyntheticLeadingComments: () => getSyntheticLeadingComments, - getSyntheticTrailingComments: () => getSyntheticTrailingComments, - getTargetLabel: () => getTargetLabel, - getTargetOfBindingOrAssignmentElement: () => getTargetOfBindingOrAssignmentElement, - getTemporaryModuleResolutionState: () => getTemporaryModuleResolutionState, - getTextOfConstantValue: () => getTextOfConstantValue, - getTextOfIdentifierOrLiteral: () => getTextOfIdentifierOrLiteral, - getTextOfJSDocComment: () => getTextOfJSDocComment, - getTextOfJsxAttributeName: () => getTextOfJsxAttributeName, - getTextOfJsxNamespacedName: () => getTextOfJsxNamespacedName, - getTextOfNode: () => getTextOfNode, - getTextOfNodeFromSourceText: () => getTextOfNodeFromSourceText, - getTextOfPropertyName: () => getTextOfPropertyName, - getThisContainer: () => getThisContainer, - getThisParameter: () => getThisParameter, - getTokenAtPosition: () => getTokenAtPosition, - getTokenPosOfNode: () => getTokenPosOfNode, - getTokenSourceMapRange: () => getTokenSourceMapRange, - getTouchingPropertyName: () => getTouchingPropertyName, - getTouchingToken: () => getTouchingToken, - getTrailingCommentRanges: () => getTrailingCommentRanges, - getTrailingSemicolonDeferringWriter: () => getTrailingSemicolonDeferringWriter, - getTransformers: () => getTransformers, - getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath, - getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression, - getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue, - getTypeAnnotationNode: () => getTypeAnnotationNode, - getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList, - getTypeKeywordOfTypeOnlyImport: () => getTypeKeywordOfTypeOnlyImport, - getTypeNode: () => getTypeNode, - getTypeNodeIfAccessible: () => getTypeNodeIfAccessible, - getTypeParameterFromJsDoc: () => getTypeParameterFromJsDoc, - getTypeParameterOwner: () => getTypeParameterOwner, - getTypesPackageName: () => getTypesPackageName, - getUILocale: () => getUILocale, - getUniqueName: () => getUniqueName, - getUniqueSymbolId: () => getUniqueSymbolId, - getUseDefineForClassFields: () => getUseDefineForClassFields, - getWatchErrorSummaryDiagnosticMessage: () => getWatchErrorSummaryDiagnosticMessage, - getWatchFactory: () => getWatchFactory, - group: () => group, - groupBy: () => groupBy, - guessIndentation: () => guessIndentation, - handleNoEmitOptions: () => handleNoEmitOptions, - handleWatchOptionsConfigDirTemplateSubstitution: () => handleWatchOptionsConfigDirTemplateSubstitution, - hasAbstractModifier: () => hasAbstractModifier, - hasAccessorModifier: () => hasAccessorModifier, - hasAmbientModifier: () => hasAmbientModifier, - hasChangesInResolutions: () => hasChangesInResolutions, - hasContextSensitiveParameters: () => hasContextSensitiveParameters, - hasDecorators: () => hasDecorators, - hasDocComment: () => hasDocComment, - hasDynamicName: () => hasDynamicName, - hasEffectiveModifier: () => hasEffectiveModifier, - hasEffectiveModifiers: () => hasEffectiveModifiers, - hasEffectiveReadonlyModifier: () => hasEffectiveReadonlyModifier, - hasExtension: () => hasExtension, - hasImplementationTSFileExtension: () => hasImplementationTSFileExtension, - hasIndexSignature: () => hasIndexSignature, - hasInferredType: () => hasInferredType, - hasInitializer: () => hasInitializer, - hasInvalidEscape: () => hasInvalidEscape, - hasJSDocNodes: () => hasJSDocNodes, - hasJSDocParameterTags: () => hasJSDocParameterTags, - hasJSFileExtension: () => hasJSFileExtension, - hasJsonModuleEmitEnabled: () => hasJsonModuleEmitEnabled, - hasOnlyExpressionInitializer: () => hasOnlyExpressionInitializer, - hasOverrideModifier: () => hasOverrideModifier, - hasPossibleExternalModuleReference: () => hasPossibleExternalModuleReference, - hasProperty: () => hasProperty, - hasPropertyAccessExpressionWithName: () => hasPropertyAccessExpressionWithName, - hasQuestionToken: () => hasQuestionToken, - hasRecordedExternalHelpers: () => hasRecordedExternalHelpers, - hasResolutionModeOverride: () => hasResolutionModeOverride, - hasRestParameter: () => hasRestParameter, - hasScopeMarker: () => hasScopeMarker, - hasStaticModifier: () => hasStaticModifier, - hasSyntacticModifier: () => hasSyntacticModifier, - hasSyntacticModifiers: () => hasSyntacticModifiers, - hasTSFileExtension: () => hasTSFileExtension, - hasTabstop: () => hasTabstop, - hasTrailingDirectorySeparator: () => hasTrailingDirectorySeparator, - hasType: () => hasType, - hasTypeArguments: () => hasTypeArguments, - hasZeroOrOneAsteriskCharacter: () => hasZeroOrOneAsteriskCharacter, - hostGetCanonicalFileName: () => hostGetCanonicalFileName, - hostUsesCaseSensitiveFileNames: () => hostUsesCaseSensitiveFileNames, - idText: () => idText, - identifierIsThisKeyword: () => identifierIsThisKeyword, - identifierToKeywordKind: () => identifierToKeywordKind, - identity: () => identity, - identitySourceMapConsumer: () => identitySourceMapConsumer, - ignoreSourceNewlines: () => ignoreSourceNewlines, - ignoredPaths: () => ignoredPaths, - importFromModuleSpecifier: () => importFromModuleSpecifier, - importSyntaxAffectsModuleResolution: () => importSyntaxAffectsModuleResolution, - indexOfAnyCharCode: () => indexOfAnyCharCode, - indexOfNode: () => indexOfNode, - indicesOf: () => indicesOf, - inferredTypesContainingFile: () => inferredTypesContainingFile, - injectClassNamedEvaluationHelperBlockIfMissing: () => injectClassNamedEvaluationHelperBlockIfMissing, - injectClassThisAssignmentIfMissing: () => injectClassThisAssignmentIfMissing, - insertImports: () => insertImports, - insertSorted: () => insertSorted, - insertStatementAfterCustomPrologue: () => insertStatementAfterCustomPrologue, - insertStatementAfterStandardPrologue: () => insertStatementAfterStandardPrologue, - insertStatementsAfterCustomPrologue: () => insertStatementsAfterCustomPrologue, - insertStatementsAfterStandardPrologue: () => insertStatementsAfterStandardPrologue, - intersperse: () => intersperse, - intrinsicTagNameToString: () => intrinsicTagNameToString, - introducesArgumentsExoticObject: () => introducesArgumentsExoticObject, - inverseJsxOptionMap: () => inverseJsxOptionMap, - isAbstractConstructorSymbol: () => isAbstractConstructorSymbol, - isAbstractModifier: () => isAbstractModifier, - isAccessExpression: () => isAccessExpression, - isAccessibilityModifier: () => isAccessibilityModifier, - isAccessor: () => isAccessor, - isAccessorModifier: () => isAccessorModifier, - isAliasableExpression: () => isAliasableExpression, - isAmbientModule: () => isAmbientModule, - isAmbientPropertyDeclaration: () => isAmbientPropertyDeclaration, - isAnyDirectorySeparator: () => isAnyDirectorySeparator, - isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire, - isAnyImportOrReExport: () => isAnyImportOrReExport, - isAnyImportOrRequireStatement: () => isAnyImportOrRequireStatement, - isAnyImportSyntax: () => isAnyImportSyntax, - isAnySupportedFileExtension: () => isAnySupportedFileExtension, - isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey, - isArgumentExpressionOfElementAccess: () => isArgumentExpressionOfElementAccess, - isArray: () => isArray, - isArrayBindingElement: () => isArrayBindingElement, - isArrayBindingOrAssignmentElement: () => isArrayBindingOrAssignmentElement, - isArrayBindingOrAssignmentPattern: () => isArrayBindingOrAssignmentPattern, - isArrayBindingPattern: () => isArrayBindingPattern, - isArrayLiteralExpression: () => isArrayLiteralExpression, - isArrayLiteralOrObjectLiteralDestructuringPattern: () => isArrayLiteralOrObjectLiteralDestructuringPattern, - isArrayTypeNode: () => isArrayTypeNode, - isArrowFunction: () => isArrowFunction, - isAsExpression: () => isAsExpression, - isAssertClause: () => isAssertClause, - isAssertEntry: () => isAssertEntry, - isAssertionExpression: () => isAssertionExpression, - isAssertsKeyword: () => isAssertsKeyword, - isAssignmentDeclaration: () => isAssignmentDeclaration, - isAssignmentExpression: () => isAssignmentExpression, - isAssignmentOperator: () => isAssignmentOperator, - isAssignmentPattern: () => isAssignmentPattern, - isAssignmentTarget: () => isAssignmentTarget, - isAsteriskToken: () => isAsteriskToken, - isAsyncFunction: () => isAsyncFunction, - isAsyncModifier: () => isAsyncModifier, - isAutoAccessorPropertyDeclaration: () => isAutoAccessorPropertyDeclaration, - isAwaitExpression: () => isAwaitExpression, - isAwaitKeyword: () => isAwaitKeyword, - isBigIntLiteral: () => isBigIntLiteral, - isBinaryExpression: () => isBinaryExpression, - isBinaryLogicalOperator: () => isBinaryLogicalOperator, - isBinaryOperatorToken: () => isBinaryOperatorToken, - isBindableObjectDefinePropertyCall: () => isBindableObjectDefinePropertyCall, - isBindableStaticAccessExpression: () => isBindableStaticAccessExpression, - isBindableStaticElementAccessExpression: () => isBindableStaticElementAccessExpression, - isBindableStaticNameExpression: () => isBindableStaticNameExpression, - isBindingElement: () => isBindingElement, - isBindingElementOfBareOrAccessedRequire: () => isBindingElementOfBareOrAccessedRequire, - isBindingName: () => isBindingName, - isBindingOrAssignmentElement: () => isBindingOrAssignmentElement, - isBindingOrAssignmentPattern: () => isBindingOrAssignmentPattern, - isBindingPattern: () => isBindingPattern, - isBlock: () => isBlock, - isBlockLike: () => isBlockLike, - isBlockOrCatchScoped: () => isBlockOrCatchScoped, - isBlockScope: () => isBlockScope, - isBlockScopedContainerTopLevel: () => isBlockScopedContainerTopLevel, - isBooleanLiteral: () => isBooleanLiteral, - isBreakOrContinueStatement: () => isBreakOrContinueStatement, - isBreakStatement: () => isBreakStatement, - isBuild: () => isBuild, - isBuildInfoFile: () => isBuildInfoFile, - isBuilderProgram: () => isBuilderProgram, - isBundle: () => isBundle, - isCallChain: () => isCallChain, - isCallExpression: () => isCallExpression, - isCallExpressionTarget: () => isCallExpressionTarget, - isCallLikeExpression: () => isCallLikeExpression, - isCallLikeOrFunctionLikeExpression: () => isCallLikeOrFunctionLikeExpression, - isCallOrNewExpression: () => isCallOrNewExpression, - isCallOrNewExpressionTarget: () => isCallOrNewExpressionTarget, - isCallSignatureDeclaration: () => isCallSignatureDeclaration, - isCallToHelper: () => isCallToHelper, - isCaseBlock: () => isCaseBlock, - isCaseClause: () => isCaseClause, - isCaseKeyword: () => isCaseKeyword, - isCaseOrDefaultClause: () => isCaseOrDefaultClause, - isCatchClause: () => isCatchClause, - isCatchClauseVariableDeclaration: () => isCatchClauseVariableDeclaration, - isCatchClauseVariableDeclarationOrBindingElement: () => isCatchClauseVariableDeclarationOrBindingElement, - isCheckJsEnabledForFile: () => isCheckJsEnabledForFile, - isCircularBuildOrder: () => isCircularBuildOrder, - isClassDeclaration: () => isClassDeclaration, - isClassElement: () => isClassElement, - isClassExpression: () => isClassExpression, - isClassInstanceProperty: () => isClassInstanceProperty, - isClassLike: () => isClassLike, - isClassMemberModifier: () => isClassMemberModifier, - isClassNamedEvaluationHelperBlock: () => isClassNamedEvaluationHelperBlock, - isClassOrTypeElement: () => isClassOrTypeElement, - isClassStaticBlockDeclaration: () => isClassStaticBlockDeclaration, - isClassThisAssignmentBlock: () => isClassThisAssignmentBlock, - isColonToken: () => isColonToken, - isCommaExpression: () => isCommaExpression, - isCommaListExpression: () => isCommaListExpression, - isCommaSequence: () => isCommaSequence, - isCommaToken: () => isCommaToken, - isComment: () => isComment, - isCommonJsExportPropertyAssignment: () => isCommonJsExportPropertyAssignment, - isCommonJsExportedExpression: () => isCommonJsExportedExpression, - isCompoundAssignment: () => isCompoundAssignment, - isComputedNonLiteralName: () => isComputedNonLiteralName, - isComputedPropertyName: () => isComputedPropertyName, - isConciseBody: () => isConciseBody, - isConditionalExpression: () => isConditionalExpression, - isConditionalTypeNode: () => isConditionalTypeNode, - isConstAssertion: () => isConstAssertion, - isConstTypeReference: () => isConstTypeReference, - isConstructSignatureDeclaration: () => isConstructSignatureDeclaration, - isConstructorDeclaration: () => isConstructorDeclaration, - isConstructorTypeNode: () => isConstructorTypeNode, - isContextualKeyword: () => isContextualKeyword, - isContinueStatement: () => isContinueStatement, - isCustomPrologue: () => isCustomPrologue, - isDebuggerStatement: () => isDebuggerStatement, - isDeclaration: () => isDeclaration, - isDeclarationBindingElement: () => isDeclarationBindingElement, - isDeclarationFileName: () => isDeclarationFileName, - isDeclarationName: () => isDeclarationName, - isDeclarationNameOfEnumOrNamespace: () => isDeclarationNameOfEnumOrNamespace, - isDeclarationReadonly: () => isDeclarationReadonly, - isDeclarationStatement: () => isDeclarationStatement, - isDeclarationWithTypeParameterChildren: () => isDeclarationWithTypeParameterChildren, - isDeclarationWithTypeParameters: () => isDeclarationWithTypeParameters, - isDecorator: () => isDecorator, - isDecoratorTarget: () => isDecoratorTarget, - isDefaultClause: () => isDefaultClause, - isDefaultImport: () => isDefaultImport, - isDefaultModifier: () => isDefaultModifier, - isDefaultedExpandoInitializer: () => isDefaultedExpandoInitializer, - isDeleteExpression: () => isDeleteExpression, - isDeleteTarget: () => isDeleteTarget, - isDeprecatedDeclaration: () => isDeprecatedDeclaration, - isDestructuringAssignment: () => isDestructuringAssignment, - isDiskPathRoot: () => isDiskPathRoot, - isDoStatement: () => isDoStatement, - isDocumentRegistryEntry: () => isDocumentRegistryEntry, - isDotDotDotToken: () => isDotDotDotToken, - isDottedName: () => isDottedName, - isDynamicName: () => isDynamicName, - isEffectiveExternalModule: () => isEffectiveExternalModule, - isEffectiveStrictModeSourceFile: () => isEffectiveStrictModeSourceFile, - isElementAccessChain: () => isElementAccessChain, - isElementAccessExpression: () => isElementAccessExpression, - isEmittedFileOfProgram: () => isEmittedFileOfProgram, - isEmptyArrayLiteral: () => isEmptyArrayLiteral, - isEmptyBindingElement: () => isEmptyBindingElement, - isEmptyBindingPattern: () => isEmptyBindingPattern, - isEmptyObjectLiteral: () => isEmptyObjectLiteral, - isEmptyStatement: () => isEmptyStatement, - isEmptyStringLiteral: () => isEmptyStringLiteral, - isEntityName: () => isEntityName, - isEntityNameExpression: () => isEntityNameExpression, - isEnumConst: () => isEnumConst, - isEnumDeclaration: () => isEnumDeclaration, - isEnumMember: () => isEnumMember, - isEqualityOperatorKind: () => isEqualityOperatorKind, - isEqualsGreaterThanToken: () => isEqualsGreaterThanToken, - isExclamationToken: () => isExclamationToken, - isExcludedFile: () => isExcludedFile, - isExclusivelyTypeOnlyImportOrExport: () => isExclusivelyTypeOnlyImportOrExport, - isExpandoPropertyDeclaration: () => isExpandoPropertyDeclaration, - isExportAssignment: () => isExportAssignment, - isExportDeclaration: () => isExportDeclaration, - isExportModifier: () => isExportModifier, - isExportName: () => isExportName, - isExportNamespaceAsDefaultDeclaration: () => isExportNamespaceAsDefaultDeclaration, - isExportOrDefaultModifier: () => isExportOrDefaultModifier, - isExportSpecifier: () => isExportSpecifier, - isExportsIdentifier: () => isExportsIdentifier, - isExportsOrModuleExportsOrAlias: () => isExportsOrModuleExportsOrAlias, - isExpression: () => isExpression, - isExpressionNode: () => isExpressionNode, - isExpressionOfExternalModuleImportEqualsDeclaration: () => isExpressionOfExternalModuleImportEqualsDeclaration, - isExpressionOfOptionalChainRoot: () => isExpressionOfOptionalChainRoot, - isExpressionStatement: () => isExpressionStatement, - isExpressionWithTypeArguments: () => isExpressionWithTypeArguments, - isExpressionWithTypeArgumentsInClassExtendsClause: () => isExpressionWithTypeArgumentsInClassExtendsClause, - isExternalModule: () => isExternalModule, - isExternalModuleAugmentation: () => isExternalModuleAugmentation, - isExternalModuleImportEqualsDeclaration: () => isExternalModuleImportEqualsDeclaration, - isExternalModuleIndicator: () => isExternalModuleIndicator, - isExternalModuleNameRelative: () => isExternalModuleNameRelative, - isExternalModuleReference: () => isExternalModuleReference, - isExternalModuleSymbol: () => isExternalModuleSymbol, - isExternalOrCommonJsModule: () => isExternalOrCommonJsModule, - isFileLevelReservedGeneratedIdentifier: () => isFileLevelReservedGeneratedIdentifier, - isFileLevelUniqueName: () => isFileLevelUniqueName, - isFileProbablyExternalModule: () => isFileProbablyExternalModule, - isFirstDeclarationOfSymbolParameter: () => isFirstDeclarationOfSymbolParameter, - isFixablePromiseHandler: () => isFixablePromiseHandler, - isForInOrOfStatement: () => isForInOrOfStatement, - isForInStatement: () => isForInStatement, - isForInitializer: () => isForInitializer, - isForOfStatement: () => isForOfStatement, - isForStatement: () => isForStatement, - isFullSourceFile: () => isFullSourceFile, - isFunctionBlock: () => isFunctionBlock, - isFunctionBody: () => isFunctionBody, - isFunctionDeclaration: () => isFunctionDeclaration, - isFunctionExpression: () => isFunctionExpression, - isFunctionExpressionOrArrowFunction: () => isFunctionExpressionOrArrowFunction, - isFunctionLike: () => isFunctionLike, - isFunctionLikeDeclaration: () => isFunctionLikeDeclaration, - isFunctionLikeKind: () => isFunctionLikeKind, - isFunctionLikeOrClassStaticBlockDeclaration: () => isFunctionLikeOrClassStaticBlockDeclaration, - isFunctionOrConstructorTypeNode: () => isFunctionOrConstructorTypeNode, - isFunctionOrModuleBlock: () => isFunctionOrModuleBlock, - isFunctionSymbol: () => isFunctionSymbol, - isFunctionTypeNode: () => isFunctionTypeNode, - isGeneratedIdentifier: () => isGeneratedIdentifier, - isGeneratedPrivateIdentifier: () => isGeneratedPrivateIdentifier, - isGetAccessor: () => isGetAccessor, - isGetAccessorDeclaration: () => isGetAccessorDeclaration, - isGetOrSetAccessorDeclaration: () => isGetOrSetAccessorDeclaration, - isGlobalScopeAugmentation: () => isGlobalScopeAugmentation, - isGlobalSourceFile: () => isGlobalSourceFile, - isGrammarError: () => isGrammarError, - isHeritageClause: () => isHeritageClause, - isHoistedFunction: () => isHoistedFunction, - isHoistedVariableStatement: () => isHoistedVariableStatement, - isIdentifier: () => isIdentifier, - isIdentifierANonContextualKeyword: () => isIdentifierANonContextualKeyword, - isIdentifierName: () => isIdentifierName, - isIdentifierOrThisTypeNode: () => isIdentifierOrThisTypeNode, - isIdentifierPart: () => isIdentifierPart, - isIdentifierStart: () => isIdentifierStart, - isIdentifierText: () => isIdentifierText, - isIdentifierTypePredicate: () => isIdentifierTypePredicate, - isIdentifierTypeReference: () => isIdentifierTypeReference, - isIfStatement: () => isIfStatement, - isIgnoredFileFromWildCardWatching: () => isIgnoredFileFromWildCardWatching, - isImplicitGlob: () => isImplicitGlob, - isImportAttribute: () => isImportAttribute, - isImportAttributeName: () => isImportAttributeName, - isImportAttributes: () => isImportAttributes, - isImportCall: () => isImportCall, - isImportClause: () => isImportClause, - isImportDeclaration: () => isImportDeclaration, - isImportEqualsDeclaration: () => isImportEqualsDeclaration, - isImportKeyword: () => isImportKeyword, - isImportMeta: () => isImportMeta, - isImportOrExportSpecifier: () => isImportOrExportSpecifier, - isImportOrExportSpecifierName: () => isImportOrExportSpecifierName, - isImportSpecifier: () => isImportSpecifier, - isImportTypeAssertionContainer: () => isImportTypeAssertionContainer, - isImportTypeNode: () => isImportTypeNode, - isImportableFile: () => isImportableFile, - isInComment: () => isInComment, - isInCompoundLikeAssignment: () => isInCompoundLikeAssignment, - isInExpressionContext: () => isInExpressionContext, - isInJSDoc: () => isInJSDoc, - isInJSFile: () => isInJSFile, - isInJSXText: () => isInJSXText, - isInJsonFile: () => isInJsonFile, - isInNonReferenceComment: () => isInNonReferenceComment, - isInReferenceComment: () => isInReferenceComment, - isInRightSideOfInternalImportEqualsDeclaration: () => isInRightSideOfInternalImportEqualsDeclaration, - isInString: () => isInString, - isInTemplateString: () => isInTemplateString, - isInTopLevelContext: () => isInTopLevelContext, - isInTypeQuery: () => isInTypeQuery, - isIncrementalBuildInfo: () => isIncrementalBuildInfo, - isIncrementalBundleEmitBuildInfo: () => isIncrementalBundleEmitBuildInfo, - isIncrementalCompilation: () => isIncrementalCompilation, - isIndexSignatureDeclaration: () => isIndexSignatureDeclaration, - isIndexedAccessTypeNode: () => isIndexedAccessTypeNode, - isInferTypeNode: () => isInferTypeNode, - isInfinityOrNaNString: () => isInfinityOrNaNString, - isInitializedProperty: () => isInitializedProperty, - isInitializedVariable: () => isInitializedVariable, - isInsideJsxElement: () => isInsideJsxElement, - isInsideJsxElementOrAttribute: () => isInsideJsxElementOrAttribute, - isInsideNodeModules: () => isInsideNodeModules, - isInsideTemplateLiteral: () => isInsideTemplateLiteral, - isInstanceOfExpression: () => isInstanceOfExpression, - isInstantiatedModule: () => isInstantiatedModule, - isInterfaceDeclaration: () => isInterfaceDeclaration, - isInternalDeclaration: () => isInternalDeclaration, - isInternalModuleImportEqualsDeclaration: () => isInternalModuleImportEqualsDeclaration, - isInternalName: () => isInternalName, - isIntersectionTypeNode: () => isIntersectionTypeNode, - isIntrinsicJsxName: () => isIntrinsicJsxName, - isIterationStatement: () => isIterationStatement, - isJSDoc: () => isJSDoc, - isJSDocAllType: () => isJSDocAllType, - isJSDocAugmentsTag: () => isJSDocAugmentsTag, - isJSDocAuthorTag: () => isJSDocAuthorTag, - isJSDocCallbackTag: () => isJSDocCallbackTag, - isJSDocClassTag: () => isJSDocClassTag, - isJSDocCommentContainingNode: () => isJSDocCommentContainingNode, - isJSDocConstructSignature: () => isJSDocConstructSignature, - isJSDocDeprecatedTag: () => isJSDocDeprecatedTag, - isJSDocEnumTag: () => isJSDocEnumTag, - isJSDocFunctionType: () => isJSDocFunctionType, - isJSDocImplementsTag: () => isJSDocImplementsTag, - isJSDocImportTag: () => isJSDocImportTag, - isJSDocIndexSignature: () => isJSDocIndexSignature, - isJSDocLikeText: () => isJSDocLikeText, - isJSDocLink: () => isJSDocLink, - isJSDocLinkCode: () => isJSDocLinkCode, - isJSDocLinkLike: () => isJSDocLinkLike, - isJSDocLinkPlain: () => isJSDocLinkPlain, - isJSDocMemberName: () => isJSDocMemberName, - isJSDocNameReference: () => isJSDocNameReference, - isJSDocNamepathType: () => isJSDocNamepathType, - isJSDocNamespaceBody: () => isJSDocNamespaceBody, - isJSDocNode: () => isJSDocNode, - isJSDocNonNullableType: () => isJSDocNonNullableType, - isJSDocNullableType: () => isJSDocNullableType, - isJSDocOptionalParameter: () => isJSDocOptionalParameter, - isJSDocOptionalType: () => isJSDocOptionalType, - isJSDocOverloadTag: () => isJSDocOverloadTag, - isJSDocOverrideTag: () => isJSDocOverrideTag, - isJSDocParameterTag: () => isJSDocParameterTag, - isJSDocPrivateTag: () => isJSDocPrivateTag, - isJSDocPropertyLikeTag: () => isJSDocPropertyLikeTag, - isJSDocPropertyTag: () => isJSDocPropertyTag, - isJSDocProtectedTag: () => isJSDocProtectedTag, - isJSDocPublicTag: () => isJSDocPublicTag, - isJSDocReadonlyTag: () => isJSDocReadonlyTag, - isJSDocReturnTag: () => isJSDocReturnTag, - isJSDocSatisfiesExpression: () => isJSDocSatisfiesExpression, - isJSDocSatisfiesTag: () => isJSDocSatisfiesTag, - isJSDocSeeTag: () => isJSDocSeeTag, - isJSDocSignature: () => isJSDocSignature, - isJSDocTag: () => isJSDocTag, - isJSDocTemplateTag: () => isJSDocTemplateTag, - isJSDocThisTag: () => isJSDocThisTag, - isJSDocThrowsTag: () => isJSDocThrowsTag, - isJSDocTypeAlias: () => isJSDocTypeAlias, - isJSDocTypeAssertion: () => isJSDocTypeAssertion, - isJSDocTypeExpression: () => isJSDocTypeExpression, - isJSDocTypeLiteral: () => isJSDocTypeLiteral, - isJSDocTypeTag: () => isJSDocTypeTag, - isJSDocTypedefTag: () => isJSDocTypedefTag, - isJSDocUnknownTag: () => isJSDocUnknownTag, - isJSDocUnknownType: () => isJSDocUnknownType, - isJSDocVariadicType: () => isJSDocVariadicType, - isJSXTagName: () => isJSXTagName, - isJsonEqual: () => isJsonEqual, - isJsonSourceFile: () => isJsonSourceFile, - isJsxAttribute: () => isJsxAttribute, - isJsxAttributeLike: () => isJsxAttributeLike, - isJsxAttributeName: () => isJsxAttributeName, - isJsxAttributes: () => isJsxAttributes, - isJsxChild: () => isJsxChild, - isJsxClosingElement: () => isJsxClosingElement, - isJsxClosingFragment: () => isJsxClosingFragment, - isJsxElement: () => isJsxElement, - isJsxExpression: () => isJsxExpression, - isJsxFragment: () => isJsxFragment, - isJsxNamespacedName: () => isJsxNamespacedName, - isJsxOpeningElement: () => isJsxOpeningElement, - isJsxOpeningFragment: () => isJsxOpeningFragment, - isJsxOpeningLikeElement: () => isJsxOpeningLikeElement, - isJsxOpeningLikeElementTagName: () => isJsxOpeningLikeElementTagName, - isJsxSelfClosingElement: () => isJsxSelfClosingElement, - isJsxSpreadAttribute: () => isJsxSpreadAttribute, - isJsxTagNameExpression: () => isJsxTagNameExpression, - isJsxText: () => isJsxText, - isJumpStatementTarget: () => isJumpStatementTarget, - isKeyword: () => isKeyword, - isKeywordOrPunctuation: () => isKeywordOrPunctuation, - isKnownSymbol: () => isKnownSymbol, - isLabelName: () => isLabelName, - isLabelOfLabeledStatement: () => isLabelOfLabeledStatement, - isLabeledStatement: () => isLabeledStatement, - isLateVisibilityPaintedStatement: () => isLateVisibilityPaintedStatement, - isLeftHandSideExpression: () => isLeftHandSideExpression, - isLet: () => isLet, - isLineBreak: () => isLineBreak, - isLiteralComputedPropertyDeclarationName: () => isLiteralComputedPropertyDeclarationName, - isLiteralExpression: () => isLiteralExpression, - isLiteralExpressionOfObject: () => isLiteralExpressionOfObject, - isLiteralImportTypeNode: () => isLiteralImportTypeNode, - isLiteralKind: () => isLiteralKind, - isLiteralNameOfPropertyDeclarationOrIndexAccess: () => isLiteralNameOfPropertyDeclarationOrIndexAccess, - isLiteralTypeLiteral: () => isLiteralTypeLiteral, - isLiteralTypeNode: () => isLiteralTypeNode, - isLocalName: () => isLocalName, - isLogicalOperator: () => isLogicalOperator, - isLogicalOrCoalescingAssignmentExpression: () => isLogicalOrCoalescingAssignmentExpression, - isLogicalOrCoalescingAssignmentOperator: () => isLogicalOrCoalescingAssignmentOperator, - isLogicalOrCoalescingBinaryExpression: () => isLogicalOrCoalescingBinaryExpression, - isLogicalOrCoalescingBinaryOperator: () => isLogicalOrCoalescingBinaryOperator, - isMappedTypeNode: () => isMappedTypeNode, - isMemberName: () => isMemberName, - isMetaProperty: () => isMetaProperty, - isMethodDeclaration: () => isMethodDeclaration, - isMethodOrAccessor: () => isMethodOrAccessor, - isMethodSignature: () => isMethodSignature, - isMinusToken: () => isMinusToken, - isMissingDeclaration: () => isMissingDeclaration, - isMissingPackageJsonInfo: () => isMissingPackageJsonInfo, - isModifier: () => isModifier, - isModifierKind: () => isModifierKind, - isModifierLike: () => isModifierLike, - isModuleAugmentationExternal: () => isModuleAugmentationExternal, - isModuleBlock: () => isModuleBlock, - isModuleBody: () => isModuleBody, - isModuleDeclaration: () => isModuleDeclaration, - isModuleExportName: () => isModuleExportName, - isModuleExportsAccessExpression: () => isModuleExportsAccessExpression, - isModuleIdentifier: () => isModuleIdentifier, - isModuleName: () => isModuleName, - isModuleOrEnumDeclaration: () => isModuleOrEnumDeclaration, - isModuleReference: () => isModuleReference, - isModuleSpecifierLike: () => isModuleSpecifierLike, - isModuleWithStringLiteralName: () => isModuleWithStringLiteralName, - isNameOfFunctionDeclaration: () => isNameOfFunctionDeclaration, - isNameOfModuleDeclaration: () => isNameOfModuleDeclaration, - isNamedDeclaration: () => isNamedDeclaration, - isNamedEvaluation: () => isNamedEvaluation, - isNamedEvaluationSource: () => isNamedEvaluationSource, - isNamedExportBindings: () => isNamedExportBindings, - isNamedExports: () => isNamedExports, - isNamedImportBindings: () => isNamedImportBindings, - isNamedImports: () => isNamedImports, - isNamedImportsOrExports: () => isNamedImportsOrExports, - isNamedTupleMember: () => isNamedTupleMember, - isNamespaceBody: () => isNamespaceBody, - isNamespaceExport: () => isNamespaceExport, - isNamespaceExportDeclaration: () => isNamespaceExportDeclaration, - isNamespaceImport: () => isNamespaceImport, - isNamespaceReexportDeclaration: () => isNamespaceReexportDeclaration, - isNewExpression: () => isNewExpression, - isNewExpressionTarget: () => isNewExpressionTarget, - isNoSubstitutionTemplateLiteral: () => isNoSubstitutionTemplateLiteral, - isNodeArray: () => isNodeArray, - isNodeArrayMultiLine: () => isNodeArrayMultiLine, - isNodeDescendantOf: () => isNodeDescendantOf, - isNodeKind: () => isNodeKind, - isNodeLikeSystem: () => isNodeLikeSystem, - isNodeModulesDirectory: () => isNodeModulesDirectory, - isNodeWithPossibleHoistedDeclaration: () => isNodeWithPossibleHoistedDeclaration, - isNonContextualKeyword: () => isNonContextualKeyword, - isNonGlobalAmbientModule: () => isNonGlobalAmbientModule, - isNonNullAccess: () => isNonNullAccess, - isNonNullChain: () => isNonNullChain, - isNonNullExpression: () => isNonNullExpression, - isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName, - isNotEmittedStatement: () => isNotEmittedStatement, - isNullishCoalesce: () => isNullishCoalesce, - isNumber: () => isNumber, - isNumericLiteral: () => isNumericLiteral, - isNumericLiteralName: () => isNumericLiteralName, - isObjectBindingElementWithoutPropertyName: () => isObjectBindingElementWithoutPropertyName, - isObjectBindingOrAssignmentElement: () => isObjectBindingOrAssignmentElement, - isObjectBindingOrAssignmentPattern: () => isObjectBindingOrAssignmentPattern, - isObjectBindingPattern: () => isObjectBindingPattern, - isObjectLiteralElement: () => isObjectLiteralElement, - isObjectLiteralElementLike: () => isObjectLiteralElementLike, - isObjectLiteralExpression: () => isObjectLiteralExpression, - isObjectLiteralMethod: () => isObjectLiteralMethod, - isObjectLiteralOrClassExpressionMethodOrAccessor: () => isObjectLiteralOrClassExpressionMethodOrAccessor, - isObjectTypeDeclaration: () => isObjectTypeDeclaration, - isOmittedExpression: () => isOmittedExpression, - isOptionalChain: () => isOptionalChain, - isOptionalChainRoot: () => isOptionalChainRoot, - isOptionalDeclaration: () => isOptionalDeclaration, - isOptionalJSDocPropertyLikeTag: () => isOptionalJSDocPropertyLikeTag, - isOptionalTypeNode: () => isOptionalTypeNode, - isOuterExpression: () => isOuterExpression, - isOutermostOptionalChain: () => isOutermostOptionalChain, - isOverrideModifier: () => isOverrideModifier, - isPackageJsonInfo: () => isPackageJsonInfo, - isPackedArrayLiteral: () => isPackedArrayLiteral, - isParameter: () => isParameter, - isParameterPropertyDeclaration: () => isParameterPropertyDeclaration, - isParameterPropertyModifier: () => isParameterPropertyModifier, - isParenthesizedExpression: () => isParenthesizedExpression, - isParenthesizedTypeNode: () => isParenthesizedTypeNode, - isParseTreeNode: () => isParseTreeNode, - isPartOfParameterDeclaration: () => isPartOfParameterDeclaration, - isPartOfTypeNode: () => isPartOfTypeNode, - isPartOfTypeQuery: () => isPartOfTypeQuery, - isPartiallyEmittedExpression: () => isPartiallyEmittedExpression, - isPatternMatch: () => isPatternMatch, - isPinnedComment: () => isPinnedComment, - isPlainJsFile: () => isPlainJsFile, - isPlusToken: () => isPlusToken, - isPossiblyTypeArgumentPosition: () => isPossiblyTypeArgumentPosition, - isPostfixUnaryExpression: () => isPostfixUnaryExpression, - isPrefixUnaryExpression: () => isPrefixUnaryExpression, - isPrimitiveLiteralValue: () => isPrimitiveLiteralValue, - isPrivateIdentifier: () => isPrivateIdentifier, - isPrivateIdentifierClassElementDeclaration: () => isPrivateIdentifierClassElementDeclaration, - isPrivateIdentifierPropertyAccessExpression: () => isPrivateIdentifierPropertyAccessExpression, - isPrivateIdentifierSymbol: () => isPrivateIdentifierSymbol, - isProgramUptoDate: () => isProgramUptoDate, - isPrologueDirective: () => isPrologueDirective, - isPropertyAccessChain: () => isPropertyAccessChain, - isPropertyAccessEntityNameExpression: () => isPropertyAccessEntityNameExpression, - isPropertyAccessExpression: () => isPropertyAccessExpression, - isPropertyAccessOrQualifiedName: () => isPropertyAccessOrQualifiedName, - isPropertyAccessOrQualifiedNameOrImportTypeNode: () => isPropertyAccessOrQualifiedNameOrImportTypeNode, - isPropertyAssignment: () => isPropertyAssignment, - isPropertyDeclaration: () => isPropertyDeclaration, - isPropertyName: () => isPropertyName, - isPropertyNameLiteral: () => isPropertyNameLiteral, - isPropertySignature: () => isPropertySignature, - isPrototypeAccess: () => isPrototypeAccess, - isPrototypePropertyAssignment: () => isPrototypePropertyAssignment, - isPunctuation: () => isPunctuation, - isPushOrUnshiftIdentifier: () => isPushOrUnshiftIdentifier, - isQualifiedName: () => isQualifiedName, - isQuestionDotToken: () => isQuestionDotToken, - isQuestionOrExclamationToken: () => isQuestionOrExclamationToken, - isQuestionOrPlusOrMinusToken: () => isQuestionOrPlusOrMinusToken, - isQuestionToken: () => isQuestionToken, - isReadonlyKeyword: () => isReadonlyKeyword, - isReadonlyKeywordOrPlusOrMinusToken: () => isReadonlyKeywordOrPlusOrMinusToken, - isRecognizedTripleSlashComment: () => isRecognizedTripleSlashComment, - isReferenceFileLocation: () => isReferenceFileLocation, - isReferencedFile: () => isReferencedFile, - isRegularExpressionLiteral: () => isRegularExpressionLiteral, - isRequireCall: () => isRequireCall, - isRequireVariableStatement: () => isRequireVariableStatement, - isRestParameter: () => isRestParameter, - isRestTypeNode: () => isRestTypeNode, - isReturnStatement: () => isReturnStatement, - isReturnStatementWithFixablePromiseHandler: () => isReturnStatementWithFixablePromiseHandler, - isRightSideOfAccessExpression: () => isRightSideOfAccessExpression, - isRightSideOfInstanceofExpression: () => isRightSideOfInstanceofExpression, - isRightSideOfPropertyAccess: () => isRightSideOfPropertyAccess, - isRightSideOfQualifiedName: () => isRightSideOfQualifiedName, - isRightSideOfQualifiedNameOrPropertyAccess: () => isRightSideOfQualifiedNameOrPropertyAccess, - isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName: () => isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName, - isRootedDiskPath: () => isRootedDiskPath, - isSameEntityName: () => isSameEntityName, - isSatisfiesExpression: () => isSatisfiesExpression, - isSemicolonClassElement: () => isSemicolonClassElement, - isSetAccessor: () => isSetAccessor, - isSetAccessorDeclaration: () => isSetAccessorDeclaration, - isShiftOperatorOrHigher: () => isShiftOperatorOrHigher, - isShorthandAmbientModuleSymbol: () => isShorthandAmbientModuleSymbol, - isShorthandPropertyAssignment: () => isShorthandPropertyAssignment, - isSideEffectImport: () => isSideEffectImport, - isSignedNumericLiteral: () => isSignedNumericLiteral, - isSimpleCopiableExpression: () => isSimpleCopiableExpression, - isSimpleInlineableExpression: () => isSimpleInlineableExpression, - isSimpleParameterList: () => isSimpleParameterList, - isSingleOrDoubleQuote: () => isSingleOrDoubleQuote, - isSourceElement: () => isSourceElement, - isSourceFile: () => isSourceFile, - isSourceFileFromLibrary: () => isSourceFileFromLibrary, - isSourceFileJS: () => isSourceFileJS, - isSourceFileNotJson: () => isSourceFileNotJson, - isSourceMapping: () => isSourceMapping, - isSpecialPropertyDeclaration: () => isSpecialPropertyDeclaration, - isSpreadAssignment: () => isSpreadAssignment, - isSpreadElement: () => isSpreadElement, - isStatement: () => isStatement, - isStatementButNotDeclaration: () => isStatementButNotDeclaration, - isStatementOrBlock: () => isStatementOrBlock, - isStatementWithLocals: () => isStatementWithLocals, - isStatic: () => isStatic, - isStaticModifier: () => isStaticModifier, - isString: () => isString, - isStringANonContextualKeyword: () => isStringANonContextualKeyword, - isStringAndEmptyAnonymousObjectIntersection: () => isStringAndEmptyAnonymousObjectIntersection, - isStringDoubleQuoted: () => isStringDoubleQuoted, - isStringLiteral: () => isStringLiteral, - isStringLiteralLike: () => isStringLiteralLike, - isStringLiteralOrJsxExpression: () => isStringLiteralOrJsxExpression, - isStringLiteralOrTemplate: () => isStringLiteralOrTemplate, - isStringOrNumericLiteralLike: () => isStringOrNumericLiteralLike, - isStringOrRegularExpressionOrTemplateLiteral: () => isStringOrRegularExpressionOrTemplateLiteral, - isStringTextContainingNode: () => isStringTextContainingNode, - isSuperCall: () => isSuperCall, - isSuperKeyword: () => isSuperKeyword, - isSuperProperty: () => isSuperProperty, - isSupportedSourceFileName: () => isSupportedSourceFileName, - isSwitchStatement: () => isSwitchStatement, - isSyntaxList: () => isSyntaxList, - isSyntheticExpression: () => isSyntheticExpression, - isSyntheticReference: () => isSyntheticReference, - isTagName: () => isTagName, - isTaggedTemplateExpression: () => isTaggedTemplateExpression, - isTaggedTemplateTag: () => isTaggedTemplateTag, - isTemplateExpression: () => isTemplateExpression, - isTemplateHead: () => isTemplateHead, - isTemplateLiteral: () => isTemplateLiteral, - isTemplateLiteralKind: () => isTemplateLiteralKind, - isTemplateLiteralToken: () => isTemplateLiteralToken, - isTemplateLiteralTypeNode: () => isTemplateLiteralTypeNode, - isTemplateLiteralTypeSpan: () => isTemplateLiteralTypeSpan, - isTemplateMiddle: () => isTemplateMiddle, - isTemplateMiddleOrTemplateTail: () => isTemplateMiddleOrTemplateTail, - isTemplateSpan: () => isTemplateSpan, - isTemplateTail: () => isTemplateTail, - isTextWhiteSpaceLike: () => isTextWhiteSpaceLike, - isThis: () => isThis, - isThisContainerOrFunctionBlock: () => isThisContainerOrFunctionBlock, - isThisIdentifier: () => isThisIdentifier, - isThisInTypeQuery: () => isThisInTypeQuery, - isThisInitializedDeclaration: () => isThisInitializedDeclaration, - isThisInitializedObjectBindingExpression: () => isThisInitializedObjectBindingExpression, - isThisProperty: () => isThisProperty, - isThisTypeNode: () => isThisTypeNode, - isThisTypeParameter: () => isThisTypeParameter, - isThisTypePredicate: () => isThisTypePredicate, - isThrowStatement: () => isThrowStatement, - isToken: () => isToken, - isTokenKind: () => isTokenKind, - isTraceEnabled: () => isTraceEnabled, - isTransientSymbol: () => isTransientSymbol, - isTrivia: () => isTrivia, - isTryStatement: () => isTryStatement, - isTupleTypeNode: () => isTupleTypeNode, - isTypeAlias: () => isTypeAlias, - isTypeAliasDeclaration: () => isTypeAliasDeclaration, - isTypeAssertionExpression: () => isTypeAssertionExpression, - isTypeDeclaration: () => isTypeDeclaration, - isTypeElement: () => isTypeElement, - isTypeKeyword: () => isTypeKeyword, - isTypeKeywordTokenOrIdentifier: () => isTypeKeywordTokenOrIdentifier, - isTypeLiteralNode: () => isTypeLiteralNode, - isTypeNode: () => isTypeNode, - isTypeNodeKind: () => isTypeNodeKind, - isTypeOfExpression: () => isTypeOfExpression, - isTypeOnlyExportDeclaration: () => isTypeOnlyExportDeclaration, - isTypeOnlyImportDeclaration: () => isTypeOnlyImportDeclaration, - isTypeOnlyImportOrExportDeclaration: () => isTypeOnlyImportOrExportDeclaration, - isTypeOperatorNode: () => isTypeOperatorNode, - isTypeParameterDeclaration: () => isTypeParameterDeclaration, - isTypePredicateNode: () => isTypePredicateNode, - isTypeQueryNode: () => isTypeQueryNode, - isTypeReferenceNode: () => isTypeReferenceNode, - isTypeReferenceType: () => isTypeReferenceType, - isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName, - isUMDExportSymbol: () => isUMDExportSymbol, - isUnaryExpression: () => isUnaryExpression, - isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite, - isUnicodeIdentifierStart: () => isUnicodeIdentifierStart, - isUnionTypeNode: () => isUnionTypeNode, - isUrl: () => isUrl, - isValidBigIntString: () => isValidBigIntString, - isValidESSymbolDeclaration: () => isValidESSymbolDeclaration, - isValidTypeOnlyAliasUseSite: () => isValidTypeOnlyAliasUseSite, - isValueSignatureDeclaration: () => isValueSignatureDeclaration, - isVarAwaitUsing: () => isVarAwaitUsing, - isVarConst: () => isVarConst, - isVarConstLike: () => isVarConstLike, - isVarUsing: () => isVarUsing, - isVariableDeclaration: () => isVariableDeclaration, - isVariableDeclarationInVariableStatement: () => isVariableDeclarationInVariableStatement, - isVariableDeclarationInitializedToBareOrAccessedRequire: () => isVariableDeclarationInitializedToBareOrAccessedRequire, - isVariableDeclarationInitializedToRequire: () => isVariableDeclarationInitializedToRequire, - isVariableDeclarationList: () => isVariableDeclarationList, - isVariableLike: () => isVariableLike, - isVariableLikeOrAccessor: () => isVariableLikeOrAccessor, - isVariableStatement: () => isVariableStatement, - isVoidExpression: () => isVoidExpression, - isWatchSet: () => isWatchSet, - isWhileStatement: () => isWhileStatement, - isWhiteSpaceLike: () => isWhiteSpaceLike, - isWhiteSpaceSingleLine: () => isWhiteSpaceSingleLine, - isWithStatement: () => isWithStatement, - isWriteAccess: () => isWriteAccess, - isWriteOnlyAccess: () => isWriteOnlyAccess, - isYieldExpression: () => isYieldExpression, - jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport, - keywordPart: () => keywordPart, - last: () => last, - lastOrUndefined: () => lastOrUndefined, - length: () => length, - libMap: () => libMap, - libs: () => libs, - lineBreakPart: () => lineBreakPart, - loadModuleFromGlobalCache: () => loadModuleFromGlobalCache, - loadWithModeAwareCache: () => loadWithModeAwareCache, - makeIdentifierFromModuleName: () => makeIdentifierFromModuleName, - makeImport: () => makeImport, - makeStringLiteral: () => makeStringLiteral, - mangleScopedPackageName: () => mangleScopedPackageName, - map: () => map, - mapAllOrFail: () => mapAllOrFail, - mapDefined: () => mapDefined, - mapDefinedIterator: () => mapDefinedIterator, - mapEntries: () => mapEntries, - mapIterator: () => mapIterator, - mapOneOrMany: () => mapOneOrMany, - mapToDisplayParts: () => mapToDisplayParts, - matchFiles: () => matchFiles, - matchPatternOrExact: () => matchPatternOrExact, - matchedText: () => matchedText, - matchesExclude: () => matchesExclude, - maxBy: () => maxBy, - maybeBind: () => maybeBind, - maybeSetLocalizedDiagnosticMessages: () => maybeSetLocalizedDiagnosticMessages, - memoize: () => memoize, - memoizeOne: () => memoizeOne, - min: () => min, - minAndMax: () => minAndMax, - missingFileModifiedTime: () => missingFileModifiedTime, - modifierToFlag: () => modifierToFlag, - modifiersToFlags: () => modifiersToFlags, - moduleExportNameIsDefault: () => moduleExportNameIsDefault, - moduleExportNameTextEscaped: () => moduleExportNameTextEscaped, - moduleExportNameTextUnescaped: () => moduleExportNameTextUnescaped, - moduleOptionDeclaration: () => moduleOptionDeclaration, - moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo, - moduleResolutionNameAndModeGetter: () => moduleResolutionNameAndModeGetter, - moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations, - moduleResolutionSupportsPackageJsonExportsAndImports: () => moduleResolutionSupportsPackageJsonExportsAndImports, - moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules, - moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier, - moduleSpecifiers: () => ts_moduleSpecifiers_exports, - moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier, - moveEmitHelpers: () => moveEmitHelpers, - moveRangeEnd: () => moveRangeEnd, - moveRangePastDecorators: () => moveRangePastDecorators, - moveRangePastModifiers: () => moveRangePastModifiers, - moveRangePos: () => moveRangePos, - moveSyntheticComments: () => moveSyntheticComments, - mutateMap: () => mutateMap, - mutateMapSkippingNewValues: () => mutateMapSkippingNewValues, - needsParentheses: () => needsParentheses, - needsScopeMarker: () => needsScopeMarker, - newCaseClauseTracker: () => newCaseClauseTracker, - newPrivateEnvironment: () => newPrivateEnvironment, - noEmitNotification: () => noEmitNotification, - noEmitSubstitution: () => noEmitSubstitution, - noTransformers: () => noTransformers, - noTruncationMaximumTruncationLength: () => noTruncationMaximumTruncationLength, - nodeCanBeDecorated: () => nodeCanBeDecorated, - nodeHasName: () => nodeHasName, - nodeIsDecorated: () => nodeIsDecorated, - nodeIsMissing: () => nodeIsMissing, - nodeIsPresent: () => nodeIsPresent, - nodeIsSynthesized: () => nodeIsSynthesized, - nodeModuleNameResolver: () => nodeModuleNameResolver, - nodeModulesPathPart: () => nodeModulesPathPart, - nodeNextJsonConfigResolver: () => nodeNextJsonConfigResolver, - nodeOrChildIsDecorated: () => nodeOrChildIsDecorated, - nodeOverlapsWithStartEnd: () => nodeOverlapsWithStartEnd, - nodePosToString: () => nodePosToString, - nodeSeenTracker: () => nodeSeenTracker, - nodeStartsNewLexicalEnvironment: () => nodeStartsNewLexicalEnvironment, - noop: () => noop, - noopFileWatcher: () => noopFileWatcher, - normalizePath: () => normalizePath, - normalizeSlashes: () => normalizeSlashes, - normalizeSpans: () => normalizeSpans, - not: () => not, - notImplemented: () => notImplemented, - notImplementedResolver: () => notImplementedResolver, - nullNodeConverters: () => nullNodeConverters, - nullParenthesizerRules: () => nullParenthesizerRules, - nullTransformationContext: () => nullTransformationContext, - objectAllocator: () => objectAllocator, - operatorPart: () => operatorPart, - optionDeclarations: () => optionDeclarations, - optionMapToObject: () => optionMapToObject, - optionsAffectingProgramStructure: () => optionsAffectingProgramStructure, - optionsForBuild: () => optionsForBuild, - optionsForWatch: () => optionsForWatch, - optionsHaveChanges: () => optionsHaveChanges, - or: () => or, - orderedRemoveItem: () => orderedRemoveItem, - orderedRemoveItemAt: () => orderedRemoveItemAt, - packageIdToPackageName: () => packageIdToPackageName, - packageIdToString: () => packageIdToString, - parameterIsThisKeyword: () => parameterIsThisKeyword, - parameterNamePart: () => parameterNamePart, - parseBaseNodeFactory: () => parseBaseNodeFactory, - parseBigInt: () => parseBigInt, - parseBuildCommand: () => parseBuildCommand, - parseCommandLine: () => parseCommandLine, - parseCommandLineWorker: () => parseCommandLineWorker, - parseConfigFileTextToJson: () => parseConfigFileTextToJson, - parseConfigFileWithSystem: () => parseConfigFileWithSystem, - parseConfigHostFromCompilerHostLike: () => parseConfigHostFromCompilerHostLike, - parseCustomTypeOption: () => parseCustomTypeOption, - parseIsolatedEntityName: () => parseIsolatedEntityName, - parseIsolatedJSDocComment: () => parseIsolatedJSDocComment, - parseJSDocTypeExpressionForTests: () => parseJSDocTypeExpressionForTests, - parseJsonConfigFileContent: () => parseJsonConfigFileContent, - parseJsonSourceFileConfigFileContent: () => parseJsonSourceFileConfigFileContent, - parseJsonText: () => parseJsonText, - parseListTypeOption: () => parseListTypeOption, - parseNodeFactory: () => parseNodeFactory, - parseNodeModuleFromPath: () => parseNodeModuleFromPath, - parsePackageName: () => parsePackageName, - parsePseudoBigInt: () => parsePseudoBigInt, - parseValidBigInt: () => parseValidBigInt, - pasteEdits: () => ts_PasteEdits_exports, - patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory, - pathContainsNodeModules: () => pathContainsNodeModules, - pathIsAbsolute: () => pathIsAbsolute, - pathIsBareSpecifier: () => pathIsBareSpecifier, - pathIsRelative: () => pathIsRelative, - patternText: () => patternText, - performIncrementalCompilation: () => performIncrementalCompilation, - performance: () => ts_performance_exports, - positionBelongsToNode: () => positionBelongsToNode, - positionIsASICandidate: () => positionIsASICandidate, - positionIsSynthesized: () => positionIsSynthesized, - positionsAreOnSameLine: () => positionsAreOnSameLine, - preProcessFile: () => preProcessFile, - probablyUsesSemicolons: () => probablyUsesSemicolons, - processCommentPragmas: () => processCommentPragmas, - processPragmasIntoFields: () => processPragmasIntoFields, - processTaggedTemplateExpression: () => processTaggedTemplateExpression, - programContainsEsModules: () => programContainsEsModules, - programContainsModules: () => programContainsModules, - projectReferenceIsEqualTo: () => projectReferenceIsEqualTo, - propertyNamePart: () => propertyNamePart, - pseudoBigIntToString: () => pseudoBigIntToString, - punctuationPart: () => punctuationPart, - pushIfUnique: () => pushIfUnique, - quote: () => quote, - quotePreferenceFromString: () => quotePreferenceFromString, - rangeContainsPosition: () => rangeContainsPosition, - rangeContainsPositionExclusive: () => rangeContainsPositionExclusive, - rangeContainsRange: () => rangeContainsRange, - rangeContainsRangeExclusive: () => rangeContainsRangeExclusive, - rangeContainsStartEnd: () => rangeContainsStartEnd, - rangeEndIsOnSameLineAsRangeStart: () => rangeEndIsOnSameLineAsRangeStart, - rangeEndPositionsAreOnSameLine: () => rangeEndPositionsAreOnSameLine, - rangeEquals: () => rangeEquals, - rangeIsOnSingleLine: () => rangeIsOnSingleLine, - rangeOfNode: () => rangeOfNode, - rangeOfTypeParameters: () => rangeOfTypeParameters, - rangeOverlapsWithStartEnd: () => rangeOverlapsWithStartEnd, - rangeStartIsOnSameLineAsRangeEnd: () => rangeStartIsOnSameLineAsRangeEnd, - rangeStartPositionsAreOnSameLine: () => rangeStartPositionsAreOnSameLine, - readBuilderProgram: () => readBuilderProgram, - readConfigFile: () => readConfigFile, - readJson: () => readJson, - readJsonConfigFile: () => readJsonConfigFile, - readJsonOrUndefined: () => readJsonOrUndefined, - reduceEachLeadingCommentRange: () => reduceEachLeadingCommentRange, - reduceEachTrailingCommentRange: () => reduceEachTrailingCommentRange, - reduceLeft: () => reduceLeft, - reduceLeftIterator: () => reduceLeftIterator, - reducePathComponents: () => reducePathComponents, - refactor: () => ts_refactor_exports, - regExpEscape: () => regExpEscape, - regularExpressionFlagToCharacterCode: () => regularExpressionFlagToCharacterCode, - relativeComplement: () => relativeComplement, - removeAllComments: () => removeAllComments, - removeEmitHelper: () => removeEmitHelper, - removeExtension: () => removeExtension, - removeFileExtension: () => removeFileExtension, - removeIgnoredPath: () => removeIgnoredPath, - removeMinAndVersionNumbers: () => removeMinAndVersionNumbers, - removePrefix: () => removePrefix, - removeSuffix: () => removeSuffix, - removeTrailingDirectorySeparator: () => removeTrailingDirectorySeparator, - repeatString: () => repeatString, - replaceElement: () => replaceElement, - replaceFirstStar: () => replaceFirstStar, - resolutionExtensionIsTSOrJson: () => resolutionExtensionIsTSOrJson, - resolveConfigFileProjectName: () => resolveConfigFileProjectName, - resolveJSModule: () => resolveJSModule, - resolveLibrary: () => resolveLibrary, - resolveModuleName: () => resolveModuleName, - resolveModuleNameFromCache: () => resolveModuleNameFromCache, - resolvePackageNameToPackageJson: () => resolvePackageNameToPackageJson, - resolvePath: () => resolvePath, - resolveProjectReferencePath: () => resolveProjectReferencePath, - resolveTripleslashReference: () => resolveTripleslashReference, - resolveTypeReferenceDirective: () => resolveTypeReferenceDirective, - resolvingEmptyArray: () => resolvingEmptyArray, - returnFalse: () => returnFalse, - returnNoopFileWatcher: () => returnNoopFileWatcher, - returnTrue: () => returnTrue, - returnUndefined: () => returnUndefined, - returnsPromise: () => returnsPromise, - sameFlatMap: () => sameFlatMap, - sameMap: () => sameMap, - sameMapping: () => sameMapping, - scanTokenAtPosition: () => scanTokenAtPosition, - scanner: () => scanner, - semanticDiagnosticsOptionDeclarations: () => semanticDiagnosticsOptionDeclarations, - serializeCompilerOptions: () => serializeCompilerOptions, - server: () => ts_server_exports3, - servicesVersion: () => servicesVersion, - setCommentRange: () => setCommentRange, - setConfigFileInOptions: () => setConfigFileInOptions, - setConstantValue: () => setConstantValue, - setEmitFlags: () => setEmitFlags, - setGetSourceFileAsHashVersioned: () => setGetSourceFileAsHashVersioned, - setIdentifierAutoGenerate: () => setIdentifierAutoGenerate, - setIdentifierGeneratedImportReference: () => setIdentifierGeneratedImportReference, - setIdentifierTypeArguments: () => setIdentifierTypeArguments, - setInternalEmitFlags: () => setInternalEmitFlags, - setLocalizedDiagnosticMessages: () => setLocalizedDiagnosticMessages, - setNodeChildren: () => setNodeChildren, - setNodeFlags: () => setNodeFlags, - setObjectAllocator: () => setObjectAllocator, - setOriginalNode: () => setOriginalNode, - setParent: () => setParent, - setParentRecursive: () => setParentRecursive, - setPrivateIdentifier: () => setPrivateIdentifier, - setSnippetElement: () => setSnippetElement, - setSourceMapRange: () => setSourceMapRange, - setStackTraceLimit: () => setStackTraceLimit, - setStartsOnNewLine: () => setStartsOnNewLine, - setSyntheticLeadingComments: () => setSyntheticLeadingComments, - setSyntheticTrailingComments: () => setSyntheticTrailingComments, - setSys: () => setSys, - setSysLog: () => setSysLog, - setTextRange: () => setTextRange, - setTextRangeEnd: () => setTextRangeEnd, - setTextRangePos: () => setTextRangePos, - setTextRangePosEnd: () => setTextRangePosEnd, - setTextRangePosWidth: () => setTextRangePosWidth, - setTokenSourceMapRange: () => setTokenSourceMapRange, - setTypeNode: () => setTypeNode, - setUILocale: () => setUILocale, - setValueDeclaration: () => setValueDeclaration, - shouldAllowImportingTsExtension: () => shouldAllowImportingTsExtension, - shouldPreserveConstEnums: () => shouldPreserveConstEnums, - shouldUseUriStyleNodeCoreModules: () => shouldUseUriStyleNodeCoreModules, - showModuleSpecifier: () => showModuleSpecifier, - signatureHasRestParameter: () => signatureHasRestParameter, - signatureToDisplayParts: () => signatureToDisplayParts, - single: () => single, - singleElementArray: () => singleElementArray, - singleIterator: () => singleIterator, - singleOrMany: () => singleOrMany, - singleOrUndefined: () => singleOrUndefined, - skipAlias: () => skipAlias, - skipConstraint: () => skipConstraint, - skipOuterExpressions: () => skipOuterExpressions, - skipParentheses: () => skipParentheses, - skipPartiallyEmittedExpressions: () => skipPartiallyEmittedExpressions, - skipTrivia: () => skipTrivia, - skipTypeChecking: () => skipTypeChecking, - skipTypeCheckingIgnoringNoCheck: () => skipTypeCheckingIgnoringNoCheck, - skipTypeParentheses: () => skipTypeParentheses, - skipWhile: () => skipWhile, - sliceAfter: () => sliceAfter, - some: () => some, - sortAndDeduplicate: () => sortAndDeduplicate, - sortAndDeduplicateDiagnostics: () => sortAndDeduplicateDiagnostics, - sourceFileAffectingCompilerOptions: () => sourceFileAffectingCompilerOptions, - sourceFileMayBeEmitted: () => sourceFileMayBeEmitted, - sourceMapCommentRegExp: () => sourceMapCommentRegExp, - sourceMapCommentRegExpDontCareLineStart: () => sourceMapCommentRegExpDontCareLineStart, - spacePart: () => spacePart, - spanMap: () => spanMap, - startEndContainsRange: () => startEndContainsRange, - startEndOverlapsWithStartEnd: () => startEndOverlapsWithStartEnd, - startOnNewLine: () => startOnNewLine, - startTracing: () => startTracing, - startsWith: () => startsWith, - startsWithDirectory: () => startsWithDirectory, - startsWithUnderscore: () => startsWithUnderscore, - startsWithUseStrict: () => startsWithUseStrict, - stringContainsAt: () => stringContainsAt, - stringToToken: () => stringToToken, - stripQuotes: () => stripQuotes, - supportedDeclarationExtensions: () => supportedDeclarationExtensions, - supportedJSExtensionsFlat: () => supportedJSExtensionsFlat, - supportedLocaleDirectories: () => supportedLocaleDirectories, - supportedTSExtensionsFlat: () => supportedTSExtensionsFlat, - supportedTSImplementationExtensions: () => supportedTSImplementationExtensions, - suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia, - suppressLeadingTrivia: () => suppressLeadingTrivia, - suppressTrailingTrivia: () => suppressTrailingTrivia, - symbolEscapedNameNoDefault: () => symbolEscapedNameNoDefault, - symbolName: () => symbolName, - symbolNameNoDefault: () => symbolNameNoDefault, - symbolToDisplayParts: () => symbolToDisplayParts, - sys: () => sys, - sysLog: () => sysLog, - tagNamesAreEquivalent: () => tagNamesAreEquivalent, - takeWhile: () => takeWhile, - targetOptionDeclaration: () => targetOptionDeclaration, - testFormatSettings: () => testFormatSettings, - textChangeRangeIsUnchanged: () => textChangeRangeIsUnchanged, - textChangeRangeNewSpan: () => textChangeRangeNewSpan, - textChanges: () => ts_textChanges_exports, - textOrKeywordPart: () => textOrKeywordPart, - textPart: () => textPart, - textRangeContainsPositionInclusive: () => textRangeContainsPositionInclusive, - textRangeContainsTextSpan: () => textRangeContainsTextSpan, - textRangeIntersectsWithTextSpan: () => textRangeIntersectsWithTextSpan, - textSpanContainsPosition: () => textSpanContainsPosition, - textSpanContainsTextRange: () => textSpanContainsTextRange, - textSpanContainsTextSpan: () => textSpanContainsTextSpan, - textSpanEnd: () => textSpanEnd, - textSpanIntersection: () => textSpanIntersection, - textSpanIntersectsWith: () => textSpanIntersectsWith, - textSpanIntersectsWithPosition: () => textSpanIntersectsWithPosition, - textSpanIntersectsWithTextSpan: () => textSpanIntersectsWithTextSpan, - textSpanIsEmpty: () => textSpanIsEmpty, - textSpanOverlap: () => textSpanOverlap, - textSpanOverlapsWith: () => textSpanOverlapsWith, - textSpansEqual: () => textSpansEqual, - textToKeywordObj: () => textToKeywordObj, - timestamp: () => timestamp, - toArray: () => toArray, - toBuilderFileEmit: () => toBuilderFileEmit, - toBuilderStateFileInfoForMultiEmit: () => toBuilderStateFileInfoForMultiEmit, - toEditorSettings: () => toEditorSettings, - toFileNameLowerCase: () => toFileNameLowerCase, - toPath: () => toPath, - toProgramEmitPending: () => toProgramEmitPending, - toSorted: () => toSorted, - tokenIsIdentifierOrKeyword: () => tokenIsIdentifierOrKeyword, - tokenIsIdentifierOrKeywordOrGreaterThan: () => tokenIsIdentifierOrKeywordOrGreaterThan, - tokenToString: () => tokenToString, - trace: () => trace, - tracing: () => tracing, - tracingEnabled: () => tracingEnabled, - transferSourceFileChildren: () => transferSourceFileChildren, - transform: () => transform, - transformClassFields: () => transformClassFields, - transformDeclarations: () => transformDeclarations, - transformECMAScriptModule: () => transformECMAScriptModule, - transformES2015: () => transformES2015, - transformES2016: () => transformES2016, - transformES2017: () => transformES2017, - transformES2018: () => transformES2018, - transformES2019: () => transformES2019, - transformES2020: () => transformES2020, - transformES2021: () => transformES2021, - transformESDecorators: () => transformESDecorators, - transformESNext: () => transformESNext, - transformGenerators: () => transformGenerators, - transformImpliedNodeFormatDependentModule: () => transformImpliedNodeFormatDependentModule, - transformJsx: () => transformJsx, - transformLegacyDecorators: () => transformLegacyDecorators, - transformModule: () => transformModule, - transformNamedEvaluation: () => transformNamedEvaluation, - transformNodes: () => transformNodes, - transformSystemModule: () => transformSystemModule, - transformTypeScript: () => transformTypeScript, - transpile: () => transpile, - transpileDeclaration: () => transpileDeclaration, - transpileModule: () => transpileModule, - transpileOptionValueCompilerOptions: () => transpileOptionValueCompilerOptions, - tryAddToSet: () => tryAddToSet, - tryAndIgnoreErrors: () => tryAndIgnoreErrors, - tryCast: () => tryCast, - tryDirectoryExists: () => tryDirectoryExists, - tryExtractTSExtension: () => tryExtractTSExtension, - tryFileExists: () => tryFileExists, - tryGetClassExtendingExpressionWithTypeArguments: () => tryGetClassExtendingExpressionWithTypeArguments, - tryGetClassImplementingOrExtendingExpressionWithTypeArguments: () => tryGetClassImplementingOrExtendingExpressionWithTypeArguments, - tryGetDirectories: () => tryGetDirectories, - tryGetExtensionFromPath: () => tryGetExtensionFromPath2, - tryGetImportFromModuleSpecifier: () => tryGetImportFromModuleSpecifier, - tryGetJSDocSatisfiesTypeNode: () => tryGetJSDocSatisfiesTypeNode, - tryGetModuleNameFromFile: () => tryGetModuleNameFromFile, - tryGetModuleSpecifierFromDeclaration: () => tryGetModuleSpecifierFromDeclaration, - tryGetNativePerformanceHooks: () => tryGetNativePerformanceHooks, - tryGetPropertyAccessOrIdentifierToString: () => tryGetPropertyAccessOrIdentifierToString, - tryGetPropertyNameOfBindingOrAssignmentElement: () => tryGetPropertyNameOfBindingOrAssignmentElement, - tryGetSourceMappingURL: () => tryGetSourceMappingURL, - tryGetTextOfPropertyName: () => tryGetTextOfPropertyName, - tryParseJson: () => tryParseJson, - tryParsePattern: () => tryParsePattern, - tryParsePatterns: () => tryParsePatterns, - tryParseRawSourceMap: () => tryParseRawSourceMap, - tryReadDirectory: () => tryReadDirectory, - tryReadFile: () => tryReadFile, - tryRemoveDirectoryPrefix: () => tryRemoveDirectoryPrefix, - tryRemoveExtension: () => tryRemoveExtension, - tryRemovePrefix: () => tryRemovePrefix, - tryRemoveSuffix: () => tryRemoveSuffix, - typeAcquisitionDeclarations: () => typeAcquisitionDeclarations, - typeAliasNamePart: () => typeAliasNamePart, - typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo, - typeKeywords: () => typeKeywords, - typeParameterNamePart: () => typeParameterNamePart, - typeToDisplayParts: () => typeToDisplayParts, - unchangedPollThresholds: () => unchangedPollThresholds, - unchangedTextChangeRange: () => unchangedTextChangeRange, - unescapeLeadingUnderscores: () => unescapeLeadingUnderscores, - unmangleScopedPackageName: () => unmangleScopedPackageName, - unorderedRemoveItem: () => unorderedRemoveItem, - unreachableCodeIsError: () => unreachableCodeIsError, - unsetNodeChildren: () => unsetNodeChildren, - unusedLabelIsError: () => unusedLabelIsError, - unwrapInnermostStatementOfLabel: () => unwrapInnermostStatementOfLabel, - unwrapParenthesizedExpression: () => unwrapParenthesizedExpression, - updateErrorForNoInputFiles: () => updateErrorForNoInputFiles, - updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile, - updateMissingFilePathsWatch: () => updateMissingFilePathsWatch, - updateResolutionField: () => updateResolutionField, - updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher, - updateSourceFile: () => updateSourceFile, - updateWatchingWildcardDirectories: () => updateWatchingWildcardDirectories, - usingSingleLineStringWriter: () => usingSingleLineStringWriter, - utf16EncodeAsString: () => utf16EncodeAsString, - validateLocaleAndSetLanguage: () => validateLocaleAndSetLanguage, - version: () => version, - versionMajorMinor: () => versionMajorMinor, - visitArray: () => visitArray, - visitCommaListElements: () => visitCommaListElements, - visitEachChild: () => visitEachChild, - visitFunctionBody: () => visitFunctionBody, - visitIterationBody: () => visitIterationBody, - visitLexicalEnvironment: () => visitLexicalEnvironment, - visitNode: () => visitNode, - visitNodes: () => visitNodes2, - visitParameterList: () => visitParameterList, - walkUpBindingElementsAndPatterns: () => walkUpBindingElementsAndPatterns, - walkUpOuterExpressions: () => walkUpOuterExpressions, - walkUpParenthesizedExpressions: () => walkUpParenthesizedExpressions, - walkUpParenthesizedTypes: () => walkUpParenthesizedTypes, - walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild, - whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp, - writeCommentRange: () => writeCommentRange, - writeFile: () => writeFile, - writeFileEnsuringDirectories: () => writeFileEnsuringDirectories, - zipWith: () => zipWith -}); - -// src/deprecatedCompat/deprecate.ts -var enableDeprecationWarnings = true; -var typeScriptVersion2; -function getTypeScriptVersion() { - return typeScriptVersion2 ?? (typeScriptVersion2 = new Version(version)); -} -function formatDeprecationMessage(name, error2, errorAfter, since, message) { - let deprecationMessage = error2 ? "DeprecationError: " : "DeprecationWarning: "; - deprecationMessage += `'${name}' `; - deprecationMessage += since ? `has been deprecated since v${since}` : "is deprecated"; - deprecationMessage += error2 ? " and can no longer be used." : errorAfter ? ` and will no longer be usable after v${errorAfter}.` : "."; - deprecationMessage += message ? ` ${formatStringFromArgs(message, [name])}` : ""; - return deprecationMessage; -} -function createErrorDeprecation(name, errorAfter, since, message) { - const deprecationMessage = formatDeprecationMessage( - name, - /*error*/ - true, - errorAfter, - since, - message - ); - return () => { - throw new TypeError(deprecationMessage); - }; -} -function createWarningDeprecation(name, errorAfter, since, message) { - let hasWrittenDeprecation = false; - return () => { - if (enableDeprecationWarnings && !hasWrittenDeprecation) { - Debug.log.warn(formatDeprecationMessage( - name, - /*error*/ - false, - errorAfter, - since, - message - )); - hasWrittenDeprecation = true; - } - }; -} -function createDeprecation(name, options = {}) { - const version2 = typeof options.typeScriptVersion === "string" ? new Version(options.typeScriptVersion) : options.typeScriptVersion ?? getTypeScriptVersion(); - const errorAfter = typeof options.errorAfter === "string" ? new Version(options.errorAfter) : options.errorAfter; - const warnAfter = typeof options.warnAfter === "string" ? new Version(options.warnAfter) : options.warnAfter; - const since = typeof options.since === "string" ? new Version(options.since) : options.since ?? warnAfter; - const error2 = options.error || errorAfter && version2.compareTo(errorAfter) >= 0; - const warn = !warnAfter || version2.compareTo(warnAfter) >= 0; - return error2 ? createErrorDeprecation(name, errorAfter, since, options.message) : warn ? createWarningDeprecation(name, errorAfter, since, options.message) : noop; -} -function wrapFunction(deprecation, func) { - return function() { - deprecation(); - return func.apply(this, arguments); - }; -} -function deprecate(func, options) { - const deprecation = createDeprecation((options == null ? void 0 : options.name) ?? Debug.getFunctionName(func), options); - return wrapFunction(deprecation, func); -} - -// src/deprecatedCompat/deprecations.ts -function createOverload(name, overloads, binder2, deprecations) { - Object.defineProperty(call, "name", { ...Object.getOwnPropertyDescriptor(call, "name"), value: name }); - if (deprecations) { - for (const key of Object.keys(deprecations)) { - const index = +key; - if (!isNaN(index) && hasProperty(overloads, `${index}`)) { - overloads[index] = deprecate(overloads[index], { ...deprecations[index], name }); - } - } - } - const bind = createBinder2(overloads, binder2); - return call; - function call(...args) { - const index = bind(args); - const fn = index !== void 0 ? overloads[index] : void 0; - if (typeof fn === "function") { - return fn(...args); - } - throw new TypeError("Invalid arguments"); - } -} -function createBinder2(overloads, binder2) { - return (args) => { - for (let i = 0; hasProperty(overloads, `${i}`) && hasProperty(binder2, `${i}`); i++) { - const fn = binder2[i]; - if (fn(args)) { - return i; - } - } - }; -} -function buildOverload(name) { +function getUsageInfoRangeForPasteEdits({ file: sourceFile, range }) { + const pos = range[0].pos; + const end = range[range.length - 1].end; + const startToken = getTokenAtPosition(sourceFile, pos); + const endToken = findTokenOnLeftOfPosition(sourceFile, pos) ?? getTokenAtPosition(sourceFile, end); return { - overload: (overloads) => ({ - bind: (binder2) => ({ - finish: () => createOverload(name, overloads, binder2), - deprecate: (deprecations) => ({ - finish: () => createOverload(name, overloads, binder2, deprecations) - }) - }) - }) + pos: isIdentifier(startToken) && pos <= startToken.getStart(sourceFile) ? startToken.getFullStart() : pos, + end: isIdentifier(endToken) && end === endToken.getEnd() ? ts_textChanges_exports.getAdjustedEndPosition(sourceFile, endToken, {}) : end }; } -// src/server/_namespaces/ts.server.ts -var ts_server_exports3 = {}; -__export(ts_server_exports3, { - ActionInvalidate: () => ActionInvalidate, - ActionPackageInstalled: () => ActionPackageInstalled, - ActionSet: () => ActionSet, - ActionWatchTypingLocations: () => ActionWatchTypingLocations, - Arguments: () => Arguments, - AutoImportProviderProject: () => AutoImportProviderProject, - AuxiliaryProject: () => AuxiliaryProject, - CharRangeSection: () => CharRangeSection, - CloseFileWatcherEvent: () => CloseFileWatcherEvent, - CommandNames: () => CommandNames, - ConfigFileDiagEvent: () => ConfigFileDiagEvent, - ConfiguredProject: () => ConfiguredProject2, - ConfiguredProjectLoadKind: () => ConfiguredProjectLoadKind, - CreateDirectoryWatcherEvent: () => CreateDirectoryWatcherEvent, - CreateFileWatcherEvent: () => CreateFileWatcherEvent, - Errors: () => Errors, - EventBeginInstallTypes: () => EventBeginInstallTypes, - EventEndInstallTypes: () => EventEndInstallTypes, - EventInitializationFailed: () => EventInitializationFailed, - EventTypesRegistry: () => EventTypesRegistry, - ExternalProject: () => ExternalProject, - GcTimer: () => GcTimer, - InferredProject: () => InferredProject2, - LargeFileReferencedEvent: () => LargeFileReferencedEvent, - LineIndex: () => LineIndex, - LineLeaf: () => LineLeaf, - LineNode: () => LineNode, - LogLevel: () => LogLevel2, - Msg: () => Msg, - OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent, - Project: () => Project2, - ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent, - ProjectKind: () => ProjectKind, - ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent, - ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent, - ProjectLoadingStartEvent: () => ProjectLoadingStartEvent, - ProjectService: () => ProjectService2, - ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent, - ScriptInfo: () => ScriptInfo, - ScriptVersionCache: () => ScriptVersionCache, - Session: () => Session3, - TextStorage: () => TextStorage, - ThrottledOperations: () => ThrottledOperations, - TypingsInstallerAdapter: () => TypingsInstallerAdapter, - allFilesAreJsOrDts: () => allFilesAreJsOrDts, - allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts, - asNormalizedPath: () => asNormalizedPath, - convertCompilerOptions: () => convertCompilerOptions, - convertFormatOptions: () => convertFormatOptions, - convertScriptKindName: () => convertScriptKindName, - convertTypeAcquisition: () => convertTypeAcquisition, - convertUserPreferences: () => convertUserPreferences, - convertWatchOptions: () => convertWatchOptions, - countEachFileTypes: () => countEachFileTypes, - createInstallTypingsRequest: () => createInstallTypingsRequest, - createModuleSpecifierCache: () => createModuleSpecifierCache, - createNormalizedPathMap: () => createNormalizedPathMap, - createPackageJsonCache: () => createPackageJsonCache, - createSortedArray: () => createSortedArray2, - emptyArray: () => emptyArray2, - findArgument: () => findArgument, - formatDiagnosticToProtocol: () => formatDiagnosticToProtocol, - formatMessage: () => formatMessage2, - getBaseConfigFileName: () => getBaseConfigFileName, - getLocationInNewDocument: () => getLocationInNewDocument, - hasArgument: () => hasArgument, - hasNoTypeScriptSource: () => hasNoTypeScriptSource, - indent: () => indent2, - isBackgroundProject: () => isBackgroundProject, - isConfigFile: () => isConfigFile, - isConfiguredProject: () => isConfiguredProject, - isDynamicFileName: () => isDynamicFileName, - isExternalProject: () => isExternalProject, - isInferredProject: () => isInferredProject, - isInferredProjectName: () => isInferredProjectName, - isProjectDeferredClose: () => isProjectDeferredClose, - makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName, - makeAuxiliaryProjectName: () => makeAuxiliaryProjectName, - makeInferredProjectName: () => makeInferredProjectName, - maxFileSize: () => maxFileSize, - maxProgramSizeForNonTsFiles: () => maxProgramSizeForNonTsFiles, - normalizedPathToPath: () => normalizedPathToPath, - nowString: () => nowString, - nullCancellationToken: () => nullCancellationToken, - nullTypingsInstaller: () => nullTypingsInstaller, - protocol: () => ts_server_protocol_exports, - stringifyIndented: () => stringifyIndented, - toEvent: () => toEvent, - toNormalizedPath: () => toNormalizedPath, - tryConvertScriptKindName: () => tryConvertScriptKindName, - typingsInstaller: () => ts_server_typingsInstaller_exports, - updateProjectIfDirty: () => updateProjectIfDirty -}); - -// src/typingsInstallerCore/_namespaces/ts.server.typingsInstaller.ts -var ts_server_typingsInstaller_exports = {}; -__export(ts_server_typingsInstaller_exports, { - TypingsInstaller: () => TypingsInstaller, - getNpmCommandForInstallation: () => getNpmCommandForInstallation, - installNpmPackages: () => installNpmPackages, - typingsName: () => typingsName -}); - -// src/typingsInstallerCore/typingsInstaller.ts -var nullLog = { - isEnabled: () => false, - writeLine: noop -}; -function typingToFileName(cachePath, packageName, installTypingHost, log) { - try { - const result = resolveModuleName(packageName, combinePaths(cachePath, "index.d.ts"), { moduleResolution: 2 /* Node10 */ }, installTypingHost); - return result.resolvedModule && result.resolvedModule.resolvedFileName; - } catch (e) { - if (log.isEnabled()) { - log.writeLine(`Failed to resolve ${packageName} in folder '${cachePath}': ${e.message}`); - } - return void 0; - } -} -function installNpmPackages(npmPath, tsVersion, packageNames, install) { - let hasError = false; - for (let remaining = packageNames.length; remaining > 0; ) { - const result = getNpmCommandForInstallation(npmPath, tsVersion, packageNames, remaining); - remaining = result.remaining; - hasError = install(result.command) || hasError; - } - return hasError; -} -function getNpmCommandForInstallation(npmPath, tsVersion, packageNames, remaining) { - const sliceStart = packageNames.length - remaining; - let command, toSlice = remaining; - while (true) { - command = `${npmPath} install --ignore-scripts ${(toSlice === packageNames.length ? packageNames : packageNames.slice(sliceStart, sliceStart + toSlice)).join(" ")} --save-dev --user-agent="typesInstaller/${tsVersion}"`; - if (command.length < 8e3) { - break; - } - toSlice = toSlice - Math.floor(toSlice / 2); - } - return { command, remaining: remaining - toSlice }; -} -var TypingsInstaller = class { - constructor(installTypingHost, globalCachePath, safeListPath, typesMapLocation, throttleLimit, log = nullLog) { - this.installTypingHost = installTypingHost; - this.globalCachePath = globalCachePath; - this.safeListPath = safeListPath; - this.typesMapLocation = typesMapLocation; - this.throttleLimit = throttleLimit; - this.log = log; - this.packageNameToTypingLocation = /* @__PURE__ */ new Map(); - this.missingTypingsSet = /* @__PURE__ */ new Set(); - this.knownCachesSet = /* @__PURE__ */ new Set(); - this.projectWatchers = /* @__PURE__ */ new Map(); - this.pendingRunRequests = []; - this.installRunCount = 1; - this.inFlightRequestCount = 0; - // eslint-disable-line @typescript-eslint/unified-signatures - this.latestDistTag = "latest"; - const isLoggingEnabled = this.log.isEnabled(); - if (isLoggingEnabled) { - this.log.writeLine(`Global cache location '${globalCachePath}', safe file path '${safeListPath}', types map path ${typesMapLocation}`); - } - this.processCacheLocation(this.globalCachePath); - } - /** @internal */ - handleRequest(req) { - switch (req.kind) { - case "discover": - this.install(req); - break; - case "closeProject": - this.closeProject(req); - break; - case "typesRegistry": { - const typesRegistry = {}; - this.typesRegistry.forEach((value, key) => { - typesRegistry[key] = value; - }); - const response = { kind: EventTypesRegistry, typesRegistry }; - this.sendResponse(response); - break; - } - case "installPackage": { - this.installPackage(req); - break; - } - default: - Debug.assertNever(req); - } - } - closeProject(req) { - this.closeWatchers(req.projectName); - } - closeWatchers(projectName) { - if (this.log.isEnabled()) { - this.log.writeLine(`Closing file watchers for project '${projectName}'`); - } - const watchers = this.projectWatchers.get(projectName); - if (!watchers) { - if (this.log.isEnabled()) { - this.log.writeLine(`No watchers are registered for project '${projectName}'`); - } - return; - } - this.projectWatchers.delete(projectName); - this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files: [] }); - if (this.log.isEnabled()) { - this.log.writeLine(`Closing file watchers for project '${projectName}' - done.`); - } - } - install(req) { - if (this.log.isEnabled()) { - this.log.writeLine(`Got install request${stringifyIndented(req)}`); - } - if (req.cachePath) { - if (this.log.isEnabled()) { - this.log.writeLine(`Request specifies cache path '${req.cachePath}', loading cached information...`); - } - this.processCacheLocation(req.cachePath); - } - if (this.safeList === void 0) { - this.initializeSafeList(); - } - const discoverTypingsResult = ts_JsTyping_exports.discoverTypings( - this.installTypingHost, - this.log.isEnabled() ? (s) => this.log.writeLine(s) : void 0, - req.fileNames, - req.projectRootPath, - this.safeList, - this.packageNameToTypingLocation, - req.typeAcquisition, - req.unresolvedImports, - this.typesRegistry, - req.compilerOptions - ); - this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch); - if (discoverTypingsResult.newTypingNames.length) { - this.installTypings(req, req.cachePath || this.globalCachePath, discoverTypingsResult.cachedTypingPaths, discoverTypingsResult.newTypingNames); - } else { - this.sendResponse(this.createSetTypings(req, discoverTypingsResult.cachedTypingPaths)); - if (this.log.isEnabled()) { - this.log.writeLine(`No new typings were requested as a result of typings discovery`); - } - } - } - /** @internal */ - installPackage(req) { - const { fileName, packageName, projectName, projectRootPath, id } = req; - const cwd = forEachAncestorDirectory(getDirectoryPath(fileName), (directory) => { - if (this.installTypingHost.fileExists(combinePaths(directory, "package.json"))) { - return directory; - } - }) || projectRootPath; - if (cwd) { - this.installWorker(-1, [packageName], cwd, (success) => { - const message = success ? `Package ${packageName} installed.` : `There was an error installing ${packageName}.`; - const response = { - kind: ActionPackageInstalled, - projectName, - id, - success, - message - }; - this.sendResponse(response); - }); - } else { - const response = { - kind: ActionPackageInstalled, - projectName, - id, - success: false, - message: "Could not determine a project root path." - }; - this.sendResponse(response); - } - } - initializeSafeList() { - if (this.typesMapLocation) { - const safeListFromMap = ts_JsTyping_exports.loadTypesMap(this.installTypingHost, this.typesMapLocation); - if (safeListFromMap) { - this.log.writeLine(`Loaded safelist from types map file '${this.typesMapLocation}'`); - this.safeList = safeListFromMap; - return; - } - this.log.writeLine(`Failed to load safelist from types map file '${this.typesMapLocation}'`); - } - this.safeList = ts_JsTyping_exports.loadSafeList(this.installTypingHost, this.safeListPath); - } - processCacheLocation(cacheLocation) { - if (this.log.isEnabled()) { - this.log.writeLine(`Processing cache location '${cacheLocation}'`); - } - if (this.knownCachesSet.has(cacheLocation)) { - if (this.log.isEnabled()) { - this.log.writeLine(`Cache location was already processed...`); - } - return; - } - const packageJson = combinePaths(cacheLocation, "package.json"); - const packageLockJson = combinePaths(cacheLocation, "package-lock.json"); - if (this.log.isEnabled()) { - this.log.writeLine(`Trying to find '${packageJson}'...`); - } - if (this.installTypingHost.fileExists(packageJson) && this.installTypingHost.fileExists(packageLockJson)) { - const npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson)); - const npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson)); - if (this.log.isEnabled()) { - this.log.writeLine(`Loaded content of '${packageJson}':${stringifyIndented(npmConfig)}`); - this.log.writeLine(`Loaded content of '${packageLockJson}':${stringifyIndented(npmLock)}`); - } - if (npmConfig.devDependencies && npmLock.dependencies) { - for (const key in npmConfig.devDependencies) { - if (!hasProperty(npmLock.dependencies, key)) { - continue; - } - const packageName = getBaseFileName(key); - if (!packageName) { - continue; - } - const typingFile = typingToFileName(cacheLocation, packageName, this.installTypingHost, this.log); - if (!typingFile) { - this.missingTypingsSet.add(packageName); - continue; - } - const existingTypingFile = this.packageNameToTypingLocation.get(packageName); - if (existingTypingFile) { - if (existingTypingFile.typingLocation === typingFile) { - continue; - } - if (this.log.isEnabled()) { - this.log.writeLine(`New typing for package ${packageName} from '${typingFile}' conflicts with existing typing file '${existingTypingFile}'`); - } - } - if (this.log.isEnabled()) { - this.log.writeLine(`Adding entry into typings cache: '${packageName}' => '${typingFile}'`); - } - const info = getProperty(npmLock.dependencies, key); - const version2 = info && info.version; - if (!version2) { - continue; - } - const newTyping = { typingLocation: typingFile, version: new Version(version2) }; - this.packageNameToTypingLocation.set(packageName, newTyping); - } - } - } - if (this.log.isEnabled()) { - this.log.writeLine(`Finished processing cache location '${cacheLocation}'`); - } - this.knownCachesSet.add(cacheLocation); - } - filterTypings(typingsToInstall) { - return mapDefined(typingsToInstall, (typing) => { - const typingKey = mangleScopedPackageName(typing); - if (this.missingTypingsSet.has(typingKey)) { - if (this.log.isEnabled()) this.log.writeLine(`'${typing}':: '${typingKey}' is in missingTypingsSet - skipping...`); - return void 0; - } - const validationResult = ts_JsTyping_exports.validatePackageName(typing); - if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) { - this.missingTypingsSet.add(typingKey); - if (this.log.isEnabled()) this.log.writeLine(ts_JsTyping_exports.renderPackageNameValidationFailure(validationResult, typing)); - return void 0; - } - if (!this.typesRegistry.has(typingKey)) { - if (this.log.isEnabled()) this.log.writeLine(`'${typing}':: Entry for package '${typingKey}' does not exist in local types registry - skipping...`); - return void 0; - } - if (this.packageNameToTypingLocation.get(typingKey) && ts_JsTyping_exports.isTypingUpToDate(this.packageNameToTypingLocation.get(typingKey), this.typesRegistry.get(typingKey))) { - if (this.log.isEnabled()) this.log.writeLine(`'${typing}':: '${typingKey}' already has an up-to-date typing - skipping...`); - return void 0; - } - return typingKey; - }); - } - ensurePackageDirectoryExists(directory) { - const npmConfigPath = combinePaths(directory, "package.json"); - if (this.log.isEnabled()) { - this.log.writeLine(`Npm config file: ${npmConfigPath}`); - } - if (!this.installTypingHost.fileExists(npmConfigPath)) { - if (this.log.isEnabled()) { - this.log.writeLine(`Npm config file: '${npmConfigPath}' is missing, creating new one...`); - } - this.ensureDirectoryExists(directory, this.installTypingHost); - this.installTypingHost.writeFile(npmConfigPath, '{ "private": true }'); - } - } - installTypings(req, cachePath, currentlyCachedTypings, typingsToInstall) { - if (this.log.isEnabled()) { - this.log.writeLine(`Installing typings ${JSON.stringify(typingsToInstall)}`); - } - const filteredTypings = this.filterTypings(typingsToInstall); - if (filteredTypings.length === 0) { - if (this.log.isEnabled()) { - this.log.writeLine(`All typings are known to be missing or invalid - no need to install more typings`); - } - this.sendResponse(this.createSetTypings(req, currentlyCachedTypings)); - return; - } - this.ensurePackageDirectoryExists(cachePath); - const requestId = this.installRunCount; - this.installRunCount++; - this.sendResponse({ - kind: EventBeginInstallTypes, - eventId: requestId, - typingsInstallerVersion: version, - projectName: req.projectName - }); - const scopedTypings = filteredTypings.map(typingsName); - this.installTypingsAsync(requestId, scopedTypings, cachePath, (ok) => { - try { - if (!ok) { - if (this.log.isEnabled()) { - this.log.writeLine(`install request failed, marking packages as missing to prevent repeated requests: ${JSON.stringify(filteredTypings)}`); - } - for (const typing of filteredTypings) { - this.missingTypingsSet.add(typing); - } - return; - } - if (this.log.isEnabled()) { - this.log.writeLine(`Installed typings ${JSON.stringify(scopedTypings)}`); - } - const installedTypingFiles = []; - for (const packageName of filteredTypings) { - const typingFile = typingToFileName(cachePath, packageName, this.installTypingHost, this.log); - if (!typingFile) { - this.missingTypingsSet.add(packageName); - continue; - } - const distTags = this.typesRegistry.get(packageName); - const newVersion = new Version(distTags[`ts${versionMajorMinor}`] || distTags[this.latestDistTag]); - const newTyping = { typingLocation: typingFile, version: newVersion }; - this.packageNameToTypingLocation.set(packageName, newTyping); - installedTypingFiles.push(typingFile); - } - if (this.log.isEnabled()) { - this.log.writeLine(`Installed typing files ${JSON.stringify(installedTypingFiles)}`); - } - this.sendResponse(this.createSetTypings(req, currentlyCachedTypings.concat(installedTypingFiles))); - } finally { - const response = { - kind: EventEndInstallTypes, - eventId: requestId, - projectName: req.projectName, - packagesToInstall: scopedTypings, - installSuccess: ok, - typingsInstallerVersion: version - }; - this.sendResponse(response); - } - }); - } - ensureDirectoryExists(directory, host) { - const directoryName = getDirectoryPath(directory); - if (!host.directoryExists(directoryName)) { - this.ensureDirectoryExists(directoryName, host); - } - if (!host.directoryExists(directory)) { - host.createDirectory(directory); - } - } - watchFiles(projectName, files) { - if (!files.length) { - this.closeWatchers(projectName); - return; - } - const existing = this.projectWatchers.get(projectName); - const newSet = new Set(files); - if (!existing || forEachKey(newSet, (s) => !existing.has(s)) || forEachKey(existing, (s) => !newSet.has(s))) { - this.projectWatchers.set(projectName, newSet); - this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files }); - } else { - this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files: void 0 }); - } - } - createSetTypings(request, typings) { - return { - projectName: request.projectName, - typeAcquisition: request.typeAcquisition, - compilerOptions: request.compilerOptions, - typings, - unresolvedImports: request.unresolvedImports, - kind: ActionSet - }; - } - installTypingsAsync(requestId, packageNames, cwd, onRequestCompleted) { - this.pendingRunRequests.unshift({ requestId, packageNames, cwd, onRequestCompleted }); - this.executeWithThrottling(); - } - executeWithThrottling() { - while (this.inFlightRequestCount < this.throttleLimit && this.pendingRunRequests.length) { - this.inFlightRequestCount++; - const request = this.pendingRunRequests.pop(); - this.installWorker(request.requestId, request.packageNames, request.cwd, (ok) => { - this.inFlightRequestCount--; - request.onRequestCompleted(ok); - this.executeWithThrottling(); - }); - } - } -}; -function typingsName(packageName) { - return `@types/${packageName}@ts${versionMajorMinor}`; -} - -// src/server/utilitiesPublic.ts -var LogLevel2 = /* @__PURE__ */ ((LogLevel3) => { - LogLevel3[LogLevel3["terse"] = 0] = "terse"; - LogLevel3[LogLevel3["normal"] = 1] = "normal"; - LogLevel3[LogLevel3["requestTime"] = 2] = "requestTime"; - LogLevel3[LogLevel3["verbose"] = 3] = "verbose"; - return LogLevel3; -})(LogLevel2 || {}); -var emptyArray2 = createSortedArray2(); -var Msg = /* @__PURE__ */ ((Msg2) => { - Msg2["Err"] = "Err"; - Msg2["Info"] = "Info"; - Msg2["Perf"] = "Perf"; - return Msg2; -})(Msg || {}); -function createInstallTypingsRequest(project, typeAcquisition, unresolvedImports, cachePath) { - return { - projectName: project.getProjectName(), - fileNames: project.getFileNames( - /*excludeFilesFromExternalLibraries*/ - true, - /*excludeConfigFiles*/ - true - ).concat(project.getExcludedFiles()), - compilerOptions: project.getCompilationSettings(), - typeAcquisition, - unresolvedImports, - projectRootPath: project.getCurrentDirectory(), - cachePath, - kind: "discover" - }; -} -var Errors; -((Errors2) => { - function ThrowNoProject() { - throw new Error("No Project."); - } - Errors2.ThrowNoProject = ThrowNoProject; - function ThrowProjectLanguageServiceDisabled() { - throw new Error("The project's language service is disabled."); - } - Errors2.ThrowProjectLanguageServiceDisabled = ThrowProjectLanguageServiceDisabled; - function ThrowProjectDoesNotContainDocument(fileName, project) { - throw new Error(`Project '${project.getProjectName()}' does not contain document '${fileName}'`); - } - Errors2.ThrowProjectDoesNotContainDocument = ThrowProjectDoesNotContainDocument; -})(Errors || (Errors = {})); -function toNormalizedPath(fileName) { - return normalizePath(fileName); -} -function normalizedPathToPath(normalizedPath, currentDirectory, getCanonicalFileName) { - const f = isRootedDiskPath(normalizedPath) ? normalizedPath : getNormalizedAbsolutePath(normalizedPath, currentDirectory); - return getCanonicalFileName(f); -} -function asNormalizedPath(fileName) { - return fileName; -} -function createNormalizedPathMap() { - const map2 = /* @__PURE__ */ new Map(); - return { - get(path) { - return map2.get(path); - }, - set(path, value) { - map2.set(path, value); - }, - contains(path) { - return map2.has(path); - }, - remove(path) { - map2.delete(path); - } - }; -} -function isInferredProjectName(name) { - return /dev\/null\/inferredProject\d+\*/.test(name); -} -function makeInferredProjectName(counter) { - return `/dev/null/inferredProject${counter}*`; -} -function makeAutoImportProviderProjectName(counter) { - return `/dev/null/autoImportProviderProject${counter}*`; -} -function makeAuxiliaryProjectName(counter) { - return `/dev/null/auxiliaryProject${counter}*`; -} -function createSortedArray2() { - return []; -} - -// src/server/utilities.ts -var ThrottledOperations = class _ThrottledOperations { - constructor(host, logger) { - this.host = host; - this.pendingTimeouts = /* @__PURE__ */ new Map(); - this.logger = logger.hasLevel(3 /* verbose */) ? logger : void 0; - } - /** - * Wait `number` milliseconds and then invoke `cb`. If, while waiting, schedule - * is called again with the same `operationId`, cancel this operation in favor - * of the new one. (Note that the amount of time the canceled operation had been - * waiting does not affect the amount of time that the new operation waits.) - */ - schedule(operationId, delay, cb) { - const pendingTimeout = this.pendingTimeouts.get(operationId); - if (pendingTimeout) { - this.host.clearTimeout(pendingTimeout); - } - this.pendingTimeouts.set(operationId, this.host.setTimeout(_ThrottledOperations.run, delay, operationId, this, cb)); - if (this.logger) { - this.logger.info(`Scheduled: ${operationId}${pendingTimeout ? ", Cancelled earlier one" : ""}`); - } - } - cancel(operationId) { - const pendingTimeout = this.pendingTimeouts.get(operationId); - if (!pendingTimeout) return false; - this.host.clearTimeout(pendingTimeout); - return this.pendingTimeouts.delete(operationId); - } - static run(operationId, self, cb) { - self.pendingTimeouts.delete(operationId); - if (self.logger) { - self.logger.info(`Running: ${operationId}`); - } - cb(); - } -}; -var GcTimer = class _GcTimer { - constructor(host, delay, logger) { - this.host = host; - this.delay = delay; - this.logger = logger; - } - scheduleCollect() { - if (!this.host.gc || this.timerId !== void 0) { - return; - } - this.timerId = this.host.setTimeout(_GcTimer.run, this.delay, this); - } - static run(self) { - self.timerId = void 0; - const log = self.logger.hasLevel(2 /* requestTime */); - const before = log && self.host.getMemoryUsage(); - self.host.gc(); - if (log) { - const after = self.host.getMemoryUsage(); - self.logger.perftrc(`GC::before ${before}, after ${after}`); - } - } -}; -function getBaseConfigFileName(configFilePath) { - const base = getBaseFileName(configFilePath); - return base === "tsconfig.json" || base === "jsconfig.json" ? base : void 0; -} - -// src/server/_namespaces/ts.server.protocol.ts -var ts_server_protocol_exports = {}; -__export(ts_server_protocol_exports, { - ClassificationType: () => ClassificationType, - CommandTypes: () => CommandTypes, - CompletionTriggerKind: () => CompletionTriggerKind, - IndentStyle: () => IndentStyle2, - JsxEmit: () => JsxEmit2, - ModuleKind: () => ModuleKind2, - ModuleResolutionKind: () => ModuleResolutionKind2, - NewLineKind: () => NewLineKind2, - OrganizeImportsMode: () => OrganizeImportsMode, - PollingWatchKind: () => PollingWatchKind2, - ScriptTarget: () => ScriptTarget11, - SemicolonPreference: () => SemicolonPreference, - WatchDirectoryKind: () => WatchDirectoryKind2, - WatchFileKind: () => WatchFileKind2 -}); - -// src/server/protocol.ts -var CommandTypes = /* @__PURE__ */ ((CommandTypes2) => { - CommandTypes2["JsxClosingTag"] = "jsxClosingTag"; - CommandTypes2["LinkedEditingRange"] = "linkedEditingRange"; - CommandTypes2["Brace"] = "brace"; - CommandTypes2["BraceFull"] = "brace-full"; - CommandTypes2["BraceCompletion"] = "braceCompletion"; - CommandTypes2["GetSpanOfEnclosingComment"] = "getSpanOfEnclosingComment"; - CommandTypes2["Change"] = "change"; - CommandTypes2["Close"] = "close"; - CommandTypes2["Completions"] = "completions"; - CommandTypes2["CompletionInfo"] = "completionInfo"; - CommandTypes2["CompletionsFull"] = "completions-full"; - CommandTypes2["CompletionDetails"] = "completionEntryDetails"; - CommandTypes2["CompletionDetailsFull"] = "completionEntryDetails-full"; - CommandTypes2["CompileOnSaveAffectedFileList"] = "compileOnSaveAffectedFileList"; - CommandTypes2["CompileOnSaveEmitFile"] = "compileOnSaveEmitFile"; - CommandTypes2["Configure"] = "configure"; - CommandTypes2["Definition"] = "definition"; - CommandTypes2["DefinitionFull"] = "definition-full"; - CommandTypes2["DefinitionAndBoundSpan"] = "definitionAndBoundSpan"; - CommandTypes2["DefinitionAndBoundSpanFull"] = "definitionAndBoundSpan-full"; - CommandTypes2["Implementation"] = "implementation"; - CommandTypes2["ImplementationFull"] = "implementation-full"; - CommandTypes2["EmitOutput"] = "emit-output"; - CommandTypes2["Exit"] = "exit"; - CommandTypes2["FileReferences"] = "fileReferences"; - CommandTypes2["FileReferencesFull"] = "fileReferences-full"; - CommandTypes2["Format"] = "format"; - CommandTypes2["Formatonkey"] = "formatonkey"; - CommandTypes2["FormatFull"] = "format-full"; - CommandTypes2["FormatonkeyFull"] = "formatonkey-full"; - CommandTypes2["FormatRangeFull"] = "formatRange-full"; - CommandTypes2["Geterr"] = "geterr"; - CommandTypes2["GeterrForProject"] = "geterrForProject"; - CommandTypes2["SemanticDiagnosticsSync"] = "semanticDiagnosticsSync"; - CommandTypes2["SyntacticDiagnosticsSync"] = "syntacticDiagnosticsSync"; - CommandTypes2["SuggestionDiagnosticsSync"] = "suggestionDiagnosticsSync"; - CommandTypes2["NavBar"] = "navbar"; - CommandTypes2["NavBarFull"] = "navbar-full"; - CommandTypes2["Navto"] = "navto"; - CommandTypes2["NavtoFull"] = "navto-full"; - CommandTypes2["NavTree"] = "navtree"; - CommandTypes2["NavTreeFull"] = "navtree-full"; - CommandTypes2["DocumentHighlights"] = "documentHighlights"; - CommandTypes2["DocumentHighlightsFull"] = "documentHighlights-full"; - CommandTypes2["Open"] = "open"; - CommandTypes2["Quickinfo"] = "quickinfo"; - CommandTypes2["QuickinfoFull"] = "quickinfo-full"; - CommandTypes2["References"] = "references"; - CommandTypes2["ReferencesFull"] = "references-full"; - CommandTypes2["Reload"] = "reload"; - CommandTypes2["Rename"] = "rename"; - CommandTypes2["RenameInfoFull"] = "rename-full"; - CommandTypes2["RenameLocationsFull"] = "renameLocations-full"; - CommandTypes2["Saveto"] = "saveto"; - CommandTypes2["SignatureHelp"] = "signatureHelp"; - CommandTypes2["SignatureHelpFull"] = "signatureHelp-full"; - CommandTypes2["FindSourceDefinition"] = "findSourceDefinition"; - CommandTypes2["Status"] = "status"; - CommandTypes2["TypeDefinition"] = "typeDefinition"; - CommandTypes2["ProjectInfo"] = "projectInfo"; - CommandTypes2["ReloadProjects"] = "reloadProjects"; - CommandTypes2["Unknown"] = "unknown"; - CommandTypes2["OpenExternalProject"] = "openExternalProject"; - CommandTypes2["OpenExternalProjects"] = "openExternalProjects"; - CommandTypes2["CloseExternalProject"] = "closeExternalProject"; - CommandTypes2["SynchronizeProjectList"] = "synchronizeProjectList"; - CommandTypes2["ApplyChangedToOpenFiles"] = "applyChangedToOpenFiles"; - CommandTypes2["UpdateOpen"] = "updateOpen"; - CommandTypes2["EncodedSyntacticClassificationsFull"] = "encodedSyntacticClassifications-full"; - CommandTypes2["EncodedSemanticClassificationsFull"] = "encodedSemanticClassifications-full"; - CommandTypes2["Cleanup"] = "cleanup"; - CommandTypes2["GetOutliningSpans"] = "getOutliningSpans"; - CommandTypes2["GetOutliningSpansFull"] = "outliningSpans"; - CommandTypes2["TodoComments"] = "todoComments"; - CommandTypes2["Indentation"] = "indentation"; - CommandTypes2["DocCommentTemplate"] = "docCommentTemplate"; - CommandTypes2["CompilerOptionsDiagnosticsFull"] = "compilerOptionsDiagnostics-full"; - CommandTypes2["NameOrDottedNameSpan"] = "nameOrDottedNameSpan"; - CommandTypes2["BreakpointStatement"] = "breakpointStatement"; - CommandTypes2["CompilerOptionsForInferredProjects"] = "compilerOptionsForInferredProjects"; - CommandTypes2["GetCodeFixes"] = "getCodeFixes"; - CommandTypes2["GetCodeFixesFull"] = "getCodeFixes-full"; - CommandTypes2["GetCombinedCodeFix"] = "getCombinedCodeFix"; - CommandTypes2["GetCombinedCodeFixFull"] = "getCombinedCodeFix-full"; - CommandTypes2["ApplyCodeActionCommand"] = "applyCodeActionCommand"; - CommandTypes2["GetSupportedCodeFixes"] = "getSupportedCodeFixes"; - CommandTypes2["GetApplicableRefactors"] = "getApplicableRefactors"; - CommandTypes2["GetEditsForRefactor"] = "getEditsForRefactor"; - CommandTypes2["GetMoveToRefactoringFileSuggestions"] = "getMoveToRefactoringFileSuggestions"; - CommandTypes2["GetPasteEdits"] = "getPasteEdits"; - CommandTypes2["GetEditsForRefactorFull"] = "getEditsForRefactor-full"; - CommandTypes2["OrganizeImports"] = "organizeImports"; - CommandTypes2["OrganizeImportsFull"] = "organizeImports-full"; - CommandTypes2["GetEditsForFileRename"] = "getEditsForFileRename"; - CommandTypes2["GetEditsForFileRenameFull"] = "getEditsForFileRename-full"; - CommandTypes2["ConfigurePlugin"] = "configurePlugin"; - CommandTypes2["SelectionRange"] = "selectionRange"; - CommandTypes2["SelectionRangeFull"] = "selectionRange-full"; - CommandTypes2["ToggleLineComment"] = "toggleLineComment"; - CommandTypes2["ToggleLineCommentFull"] = "toggleLineComment-full"; - CommandTypes2["ToggleMultilineComment"] = "toggleMultilineComment"; - CommandTypes2["ToggleMultilineCommentFull"] = "toggleMultilineComment-full"; - CommandTypes2["CommentSelection"] = "commentSelection"; - CommandTypes2["CommentSelectionFull"] = "commentSelection-full"; - CommandTypes2["UncommentSelection"] = "uncommentSelection"; - CommandTypes2["UncommentSelectionFull"] = "uncommentSelection-full"; - CommandTypes2["PrepareCallHierarchy"] = "prepareCallHierarchy"; - CommandTypes2["ProvideCallHierarchyIncomingCalls"] = "provideCallHierarchyIncomingCalls"; - CommandTypes2["ProvideCallHierarchyOutgoingCalls"] = "provideCallHierarchyOutgoingCalls"; - CommandTypes2["ProvideInlayHints"] = "provideInlayHints"; - CommandTypes2["WatchChange"] = "watchChange"; - CommandTypes2["MapCode"] = "mapCode"; - return CommandTypes2; -})(CommandTypes || {}); -var WatchFileKind2 = /* @__PURE__ */ ((WatchFileKind3) => { - WatchFileKind3["FixedPollingInterval"] = "FixedPollingInterval"; - WatchFileKind3["PriorityPollingInterval"] = "PriorityPollingInterval"; - WatchFileKind3["DynamicPriorityPolling"] = "DynamicPriorityPolling"; - WatchFileKind3["FixedChunkSizePolling"] = "FixedChunkSizePolling"; - WatchFileKind3["UseFsEvents"] = "UseFsEvents"; - WatchFileKind3["UseFsEventsOnParentDirectory"] = "UseFsEventsOnParentDirectory"; - return WatchFileKind3; -})(WatchFileKind2 || {}); -var WatchDirectoryKind2 = /* @__PURE__ */ ((WatchDirectoryKind3) => { - WatchDirectoryKind3["UseFsEvents"] = "UseFsEvents"; - WatchDirectoryKind3["FixedPollingInterval"] = "FixedPollingInterval"; - WatchDirectoryKind3["DynamicPriorityPolling"] = "DynamicPriorityPolling"; - WatchDirectoryKind3["FixedChunkSizePolling"] = "FixedChunkSizePolling"; - return WatchDirectoryKind3; -})(WatchDirectoryKind2 || {}); -var PollingWatchKind2 = /* @__PURE__ */ ((PollingWatchKind3) => { - PollingWatchKind3["FixedInterval"] = "FixedInterval"; - PollingWatchKind3["PriorityInterval"] = "PriorityInterval"; - PollingWatchKind3["DynamicPriority"] = "DynamicPriority"; - PollingWatchKind3["FixedChunkSize"] = "FixedChunkSize"; - return PollingWatchKind3; -})(PollingWatchKind2 || {}); -var IndentStyle2 = /* @__PURE__ */ ((IndentStyle3) => { - IndentStyle3["None"] = "None"; - IndentStyle3["Block"] = "Block"; - IndentStyle3["Smart"] = "Smart"; - return IndentStyle3; -})(IndentStyle2 || {}); -var JsxEmit2 = /* @__PURE__ */ ((JsxEmit3) => { - JsxEmit3["None"] = "none"; - JsxEmit3["Preserve"] = "preserve"; - JsxEmit3["ReactNative"] = "react-native"; - JsxEmit3["React"] = "react"; - JsxEmit3["ReactJSX"] = "react-jsx"; - JsxEmit3["ReactJSXDev"] = "react-jsxdev"; - return JsxEmit3; -})(JsxEmit2 || {}); -var ModuleKind2 = /* @__PURE__ */ ((ModuleKind3) => { - ModuleKind3["None"] = "none"; - ModuleKind3["CommonJS"] = "commonjs"; - ModuleKind3["AMD"] = "amd"; - ModuleKind3["UMD"] = "umd"; - ModuleKind3["System"] = "system"; - ModuleKind3["ES6"] = "es6"; - ModuleKind3["ES2015"] = "es2015"; - ModuleKind3["ES2020"] = "es2020"; - ModuleKind3["ES2022"] = "es2022"; - ModuleKind3["ESNext"] = "esnext"; - ModuleKind3["Node16"] = "node16"; - ModuleKind3["NodeNext"] = "nodenext"; - ModuleKind3["Preserve"] = "preserve"; - return ModuleKind3; -})(ModuleKind2 || {}); -var ModuleResolutionKind2 = /* @__PURE__ */ ((ModuleResolutionKind3) => { - ModuleResolutionKind3["Classic"] = "classic"; - ModuleResolutionKind3["Node"] = "node"; - ModuleResolutionKind3["NodeJs"] = "node"; - ModuleResolutionKind3["Node10"] = "node10"; - ModuleResolutionKind3["Node16"] = "node16"; - ModuleResolutionKind3["NodeNext"] = "nodenext"; - ModuleResolutionKind3["Bundler"] = "bundler"; - return ModuleResolutionKind3; -})(ModuleResolutionKind2 || {}); -var NewLineKind2 = /* @__PURE__ */ ((NewLineKind3) => { - NewLineKind3["Crlf"] = "Crlf"; - NewLineKind3["Lf"] = "Lf"; - return NewLineKind3; -})(NewLineKind2 || {}); -var ScriptTarget11 = /* @__PURE__ */ ((ScriptTarget12) => { - ScriptTarget12["ES3"] = "es3"; - ScriptTarget12["ES5"] = "es5"; - ScriptTarget12["ES6"] = "es6"; - ScriptTarget12["ES2015"] = "es2015"; - ScriptTarget12["ES2016"] = "es2016"; - ScriptTarget12["ES2017"] = "es2017"; - ScriptTarget12["ES2018"] = "es2018"; - ScriptTarget12["ES2019"] = "es2019"; - ScriptTarget12["ES2020"] = "es2020"; - ScriptTarget12["ES2021"] = "es2021"; - ScriptTarget12["ES2022"] = "es2022"; - ScriptTarget12["ES2023"] = "es2023"; - ScriptTarget12["ESNext"] = "esnext"; - ScriptTarget12["JSON"] = "json"; - ScriptTarget12["Latest"] = "esnext" /* ESNext */; - return ScriptTarget12; -})(ScriptTarget11 || {}); -{ -} - -// src/server/scriptInfo.ts -var TextStorage = class { - constructor(host, info, initialVersion) { - this.host = host; - this.info = info; - /** - * True if the text is for the file thats open in the editor - */ - this.isOpen = false; - /** - * True if the text present is the text from the file on the disk - */ - this.ownFileText = false; - /** - * True when reloading contents of file from the disk is pending - */ - this.pendingReloadFromDisk = false; - this.version = initialVersion || 0; - } - getVersion() { - return this.svc ? `SVC-${this.version}-${this.svc.getSnapshotVersion()}` : `Text-${this.version}`; - } - hasScriptVersionCache_TestOnly() { - return this.svc !== void 0; - } - resetSourceMapInfo() { - this.info.sourceFileLike = void 0; - this.info.closeSourceMapFileWatcher(); - this.info.sourceMapFilePath = void 0; - this.info.declarationInfoPath = void 0; - this.info.sourceInfos = void 0; - this.info.documentPositionMapper = void 0; - } - /** Public for testing */ - useText(newText) { - this.svc = void 0; - this.text = newText; - this.textSnapshot = void 0; - this.lineMap = void 0; - this.fileSize = void 0; - this.resetSourceMapInfo(); - this.version++; - } - edit(start, end, newText) { - this.switchToScriptVersionCache().edit(start, end - start, newText); - this.ownFileText = false; - this.text = void 0; - this.textSnapshot = void 0; - this.lineMap = void 0; - this.fileSize = void 0; - this.resetSourceMapInfo(); - } - /** - * Set the contents as newText - * returns true if text changed - */ - reload(newText) { - Debug.assert(newText !== void 0); - this.pendingReloadFromDisk = false; - if (!this.text && this.svc) { - this.text = getSnapshotText(this.svc.getSnapshot()); - } - if (this.text !== newText) { - this.useText(newText); - this.ownFileText = false; - return true; - } - return false; - } - /** - * Reads the contents from tempFile(if supplied) or own file and sets it as contents - * returns true if text changed - */ - reloadWithFileText(tempFileName) { - const { text: newText, fileSize } = tempFileName || !this.info.isDynamicOrHasMixedContent() ? this.getFileTextAndSize(tempFileName) : { text: "", fileSize: void 0 }; - const reloaded = this.reload(newText); - this.fileSize = fileSize; - this.ownFileText = !tempFileName || tempFileName === this.info.fileName; - if (this.ownFileText && this.info.mTime === missingFileModifiedTime.getTime()) { - this.info.mTime = (this.host.getModifiedTime(this.info.fileName) || missingFileModifiedTime).getTime(); - } - return reloaded; - } - /** - * Schedule reload from the disk if its not already scheduled and its not own text - * returns true when scheduling reload - */ - scheduleReloadIfNeeded() { - return !this.pendingReloadFromDisk && !this.ownFileText ? this.pendingReloadFromDisk = true : false; - } - delayReloadFromFileIntoText() { - this.pendingReloadFromDisk = true; - } - /** - * For telemetry purposes, we would like to be able to report the size of the file. - * However, we do not want telemetry to require extra file I/O so we report a size - * that may be stale (e.g. may not reflect change made on disk since the last reload). - * NB: Will read from disk if the file contents have never been loaded because - * telemetry falsely indicating size 0 would be counter-productive. - */ - getTelemetryFileSize() { - return !!this.fileSize ? this.fileSize : !!this.text ? this.text.length : !!this.svc ? this.svc.getSnapshot().getLength() : this.getSnapshot().getLength(); - } - getSnapshot() { - var _a; - return ((_a = this.tryUseScriptVersionCache()) == null ? void 0 : _a.getSnapshot()) || (this.textSnapshot ?? (this.textSnapshot = ScriptSnapshot.fromString(Debug.checkDefined(this.text)))); - } - getAbsolutePositionAndLineText(oneBasedLine) { - const svc = this.tryUseScriptVersionCache(); - if (svc) return svc.getAbsolutePositionAndLineText(oneBasedLine); - const lineMap = this.getLineMap(); - return oneBasedLine <= lineMap.length ? { - absolutePosition: lineMap[oneBasedLine - 1], - lineText: this.text.substring(lineMap[oneBasedLine - 1], lineMap[oneBasedLine]) - } : { - absolutePosition: this.text.length, - lineText: void 0 - }; - } - /** - * @param line 0 based index - */ - lineToTextSpan(line) { - const svc = this.tryUseScriptVersionCache(); - if (svc) return svc.lineToTextSpan(line); - const lineMap = this.getLineMap(); - const start = lineMap[line]; - const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length; - return createTextSpanFromBounds(start, end); - } - /** - * @param line 1 based index - * @param offset 1 based index - */ - lineOffsetToPosition(line, offset, allowEdits) { - const svc = this.tryUseScriptVersionCache(); - return svc ? svc.lineOffsetToPosition(line, offset) : computePositionOfLineAndCharacter(this.getLineMap(), line - 1, offset - 1, this.text, allowEdits); - } - positionToLineOffset(position) { - const svc = this.tryUseScriptVersionCache(); - if (svc) return svc.positionToLineOffset(position); - const { line, character } = computeLineAndCharacterOfPosition(this.getLineMap(), position); - return { line: line + 1, offset: character + 1 }; - } - getFileTextAndSize(tempFileName) { - let text; - const fileName = tempFileName || this.info.fileName; - const getText = () => text === void 0 ? text = this.host.readFile(fileName) || "" : text; - if (!hasTSFileExtension(this.info.fileName)) { - const fileSize = this.host.getFileSize ? this.host.getFileSize(fileName) : getText().length; - if (fileSize > maxFileSize) { - Debug.assert(!!this.info.containingProjects.length); - const service = this.info.containingProjects[0].projectService; - service.logger.info(`Skipped loading contents of large file ${fileName} for info ${this.info.fileName}: fileSize: ${fileSize}`); - this.info.containingProjects[0].projectService.sendLargeFileReferencedEvent(fileName, fileSize); - return { text: "", fileSize }; - } - } - return { text: getText() }; - } - /** @internal */ - switchToScriptVersionCache() { - if (!this.svc || this.pendingReloadFromDisk) { - this.svc = ScriptVersionCache.fromString(this.getOrLoadText()); - this.textSnapshot = void 0; - this.version++; - } - return this.svc; - } - tryUseScriptVersionCache() { - if (!this.svc || this.pendingReloadFromDisk) { - this.getOrLoadText(); - } - if (this.isOpen) { - if (!this.svc && !this.textSnapshot) { - this.svc = ScriptVersionCache.fromString(Debug.checkDefined(this.text)); - this.textSnapshot = void 0; - } - return this.svc; - } - return this.svc; - } - getOrLoadText() { - if (this.text === void 0 || this.pendingReloadFromDisk) { - Debug.assert(!this.svc || this.pendingReloadFromDisk, "ScriptVersionCache should not be set when reloading from disk"); - this.reloadWithFileText(); - } - return this.text; - } - getLineMap() { - Debug.assert(!this.svc, "ScriptVersionCache should not be set"); - return this.lineMap || (this.lineMap = computeLineStarts(Debug.checkDefined(this.text))); - } - getLineInfo() { - const svc = this.tryUseScriptVersionCache(); - if (svc) { - return { - getLineCount: () => svc.getLineCount(), - getLineText: (line) => svc.getAbsolutePositionAndLineText(line + 1).lineText - }; - } - const lineMap = this.getLineMap(); - return getLineInfo(this.text, lineMap); - } -}; -function isDynamicFileName(fileName) { - return fileName[0] === "^" || (fileName.includes("walkThroughSnippet:/") || fileName.includes("untitled:/")) && getBaseFileName(fileName)[0] === "^" || fileName.includes(":^") && !fileName.includes(directorySeparator); -} -var ScriptInfo = class { - constructor(host, fileName, scriptKind, hasMixedContent, path, initialVersion) { - this.host = host; - this.fileName = fileName; - this.scriptKind = scriptKind; - this.hasMixedContent = hasMixedContent; - this.path = path; - /** - * All projects that include this file - */ - this.containingProjects = []; - this.isDynamic = isDynamicFileName(fileName); - this.textStorage = new TextStorage(host, this, initialVersion); - if (hasMixedContent || this.isDynamic) { - this.realpath = this.path; - } - this.scriptKind = scriptKind ? scriptKind : getScriptKindFromFileName(fileName); - } - /** @internal */ - isDynamicOrHasMixedContent() { - return this.hasMixedContent || this.isDynamic; - } - isScriptOpen() { - return this.textStorage.isOpen; - } - open(newText) { - this.textStorage.isOpen = true; - if (newText !== void 0 && this.textStorage.reload(newText)) { - this.markContainingProjectsAsDirty(); - } - } - close(fileExists = true) { - this.textStorage.isOpen = false; - if (fileExists && this.textStorage.scheduleReloadIfNeeded()) { - this.markContainingProjectsAsDirty(); - } - } - getSnapshot() { - return this.textStorage.getSnapshot(); - } - ensureRealPath() { - if (this.realpath === void 0) { - this.realpath = this.path; - if (this.host.realpath) { - Debug.assert(!!this.containingProjects.length); - const project = this.containingProjects[0]; - const realpath = this.host.realpath(this.path); - if (realpath) { - this.realpath = project.toPath(realpath); - if (this.realpath !== this.path) { - project.projectService.realpathToScriptInfos.add(this.realpath, this); - } - } - } - } - } - /** @internal */ - getRealpathIfDifferent() { - return this.realpath && this.realpath !== this.path ? this.realpath : void 0; - } - /** - * @internal - * Does not compute realpath; uses precomputed result. Use `ensureRealPath` - * first if a definite result is needed. - */ - isSymlink() { - return this.realpath && this.realpath !== this.path; - } - getFormatCodeSettings() { - return this.formatSettings; - } - getPreferences() { - return this.preferences; - } - attachToProject(project) { - const isNew = !this.isAttached(project); - if (isNew) { - this.containingProjects.push(project); - if (!project.getCompilerOptions().preserveSymlinks) { - this.ensureRealPath(); - } - project.onFileAddedOrRemoved(this.isSymlink()); - } - return isNew; - } - isAttached(project) { - switch (this.containingProjects.length) { - case 0: - return false; - case 1: - return this.containingProjects[0] === project; - case 2: - return this.containingProjects[0] === project || this.containingProjects[1] === project; - default: - return contains(this.containingProjects, project); - } - } - detachFromProject(project) { - switch (this.containingProjects.length) { - case 0: - return; - case 1: - if (this.containingProjects[0] === project) { - project.onFileAddedOrRemoved(this.isSymlink()); - this.containingProjects.pop(); - } - break; - case 2: - if (this.containingProjects[0] === project) { - project.onFileAddedOrRemoved(this.isSymlink()); - this.containingProjects[0] = this.containingProjects.pop(); - } else if (this.containingProjects[1] === project) { - project.onFileAddedOrRemoved(this.isSymlink()); - this.containingProjects.pop(); - } - break; - default: - if (orderedRemoveItem(this.containingProjects, project)) { - project.onFileAddedOrRemoved(this.isSymlink()); - } - break; - } - } - detachAllProjects() { - for (const p of this.containingProjects) { - if (isConfiguredProject(p)) { - p.getCachedDirectoryStructureHost().addOrDeleteFile(this.fileName, this.path, 2 /* Deleted */); - } - const existingRoot = p.getRootFilesMap().get(this.path); - p.removeFile( - this, - /*fileExists*/ - false, - /*detachFromProject*/ - false - ); - p.onFileAddedOrRemoved(this.isSymlink()); - if (existingRoot && !isInferredProject(p)) { - p.addMissingFileRoot(existingRoot.fileName); - } - } - clear(this.containingProjects); - } - getDefaultProject() { - switch (this.containingProjects.length) { - case 0: - return Errors.ThrowNoProject(); - case 1: - return isProjectDeferredClose(this.containingProjects[0]) || isBackgroundProject(this.containingProjects[0]) ? Errors.ThrowNoProject() : this.containingProjects[0]; - default: - let firstConfiguredProject; - let firstInferredProject; - let firstNonSourceOfProjectReferenceRedirect; - let defaultConfiguredProject; - for (let index = 0; index < this.containingProjects.length; index++) { - const project = this.containingProjects[index]; - if (isConfiguredProject(project)) { - if (project.deferredClose) continue; - if (!project.isSourceOfProjectReferenceRedirect(this.fileName)) { - if (defaultConfiguredProject === void 0 && index !== this.containingProjects.length - 1) { - defaultConfiguredProject = project.projectService.findDefaultConfiguredProject(this) || false; - } - if (defaultConfiguredProject === project) return project; - if (!firstNonSourceOfProjectReferenceRedirect) firstNonSourceOfProjectReferenceRedirect = project; - } - if (!firstConfiguredProject) firstConfiguredProject = project; - } else if (isExternalProject(project)) { - return project; - } else if (!firstInferredProject && isInferredProject(project)) { - firstInferredProject = project; - } - } - return (defaultConfiguredProject || firstNonSourceOfProjectReferenceRedirect || firstConfiguredProject || firstInferredProject) ?? Errors.ThrowNoProject(); - } - } - registerFileUpdate() { - for (const p of this.containingProjects) { - p.registerFileUpdate(this.path); - } - } - setOptions(formatSettings, preferences) { - if (formatSettings) { - if (!this.formatSettings) { - this.formatSettings = getDefaultFormatCodeSettings(this.host.newLine); - assign(this.formatSettings, formatSettings); - } else { - this.formatSettings = { ...this.formatSettings, ...formatSettings }; - } - } - if (preferences) { - if (!this.preferences) { - this.preferences = emptyOptions; - } - this.preferences = { ...this.preferences, ...preferences }; - } - } - getLatestVersion() { - this.textStorage.getSnapshot(); - return this.textStorage.getVersion(); - } - saveTo(fileName) { - this.host.writeFile(fileName, getSnapshotText(this.textStorage.getSnapshot())); - } - /** @internal */ - delayReloadNonMixedContentFile() { - Debug.assert(!this.isDynamicOrHasMixedContent()); - this.textStorage.delayReloadFromFileIntoText(); - this.markContainingProjectsAsDirty(); - } - reloadFromFile(tempFileName) { - if (this.textStorage.reloadWithFileText(tempFileName)) { - this.markContainingProjectsAsDirty(); - return true; - } - return false; - } - editContent(start, end, newText) { - this.textStorage.edit(start, end, newText); - this.markContainingProjectsAsDirty(); - } - markContainingProjectsAsDirty() { - for (const p of this.containingProjects) { - p.markFileAsDirty(this.path); - } - } - isOrphan() { - return this.deferredDelete || !forEach(this.containingProjects, (p) => !p.isOrphan()); - } - /** @internal */ - isContainedByBackgroundProject() { - return some( - this.containingProjects, - isBackgroundProject - ); - } - /** - * @param line 1 based index - */ - lineToTextSpan(line) { - return this.textStorage.lineToTextSpan(line); - } - // eslint-disable-line @typescript-eslint/unified-signatures - lineOffsetToPosition(line, offset, allowEdits) { - return this.textStorage.lineOffsetToPosition(line, offset, allowEdits); - } - positionToLineOffset(position) { - failIfInvalidPosition(position); - const location = this.textStorage.positionToLineOffset(position); - failIfInvalidLocation(location); - return location; - } - isJavaScript() { - return this.scriptKind === 1 /* JS */ || this.scriptKind === 2 /* JSX */; - } - /** @internal */ - closeSourceMapFileWatcher() { - if (this.sourceMapFilePath && !isString(this.sourceMapFilePath)) { - closeFileWatcherOf(this.sourceMapFilePath); - this.sourceMapFilePath = void 0; - } - } -}; -function failIfInvalidPosition(position) { - Debug.assert(typeof position === "number", `Expected position ${position} to be a number.`); - Debug.assert(position >= 0, `Expected position to be non-negative.`); -} -function failIfInvalidLocation(location) { - Debug.assert(typeof location.line === "number", `Expected line ${location.line} to be a number.`); - Debug.assert(typeof location.offset === "number", `Expected offset ${location.offset} to be a number.`); - Debug.assert(location.line > 0, `Expected line to be non-${location.line === 0 ? "zero" : "negative"}`); - Debug.assert(location.offset > 0, `Expected offset to be non-${location.offset === 0 ? "zero" : "negative"}`); -} - -// src/server/project.ts -var ProjectKind = /* @__PURE__ */ ((ProjectKind2) => { - ProjectKind2[ProjectKind2["Inferred"] = 0] = "Inferred"; - ProjectKind2[ProjectKind2["Configured"] = 1] = "Configured"; - ProjectKind2[ProjectKind2["External"] = 2] = "External"; - ProjectKind2[ProjectKind2["AutoImportProvider"] = 3] = "AutoImportProvider"; - ProjectKind2[ProjectKind2["Auxiliary"] = 4] = "Auxiliary"; - return ProjectKind2; -})(ProjectKind || {}); -function countEachFileTypes(infos, includeSizes = false) { - const result = { - js: 0, - jsSize: 0, - jsx: 0, - jsxSize: 0, - ts: 0, - tsSize: 0, - tsx: 0, - tsxSize: 0, - dts: 0, - dtsSize: 0, - deferred: 0, - deferredSize: 0 - }; - for (const info of infos) { - const fileSize = includeSizes ? info.textStorage.getTelemetryFileSize() : 0; - switch (info.scriptKind) { - case 1 /* JS */: - result.js += 1; - result.jsSize += fileSize; - break; - case 2 /* JSX */: - result.jsx += 1; - result.jsxSize += fileSize; - break; - case 3 /* TS */: - if (isDeclarationFileName(info.fileName)) { - result.dts += 1; - result.dtsSize += fileSize; - } else { - result.ts += 1; - result.tsSize += fileSize; - } - break; - case 4 /* TSX */: - result.tsx += 1; - result.tsxSize += fileSize; - break; - case 7 /* Deferred */: - result.deferred += 1; - result.deferredSize += fileSize; - break; - } - } - return result; -} -function hasOneOrMoreJsAndNoTsFiles(project) { - const counts2 = countEachFileTypes(project.getScriptInfos()); - return counts2.js > 0 && counts2.ts === 0 && counts2.tsx === 0; -} -function allRootFilesAreJsOrDts(project) { - const counts2 = countEachFileTypes(project.getRootScriptInfos()); - return counts2.ts === 0 && counts2.tsx === 0; -} -function allFilesAreJsOrDts(project) { - const counts2 = countEachFileTypes(project.getScriptInfos()); - return counts2.ts === 0 && counts2.tsx === 0; -} -function hasNoTypeScriptSource(fileNames) { - return !fileNames.some((fileName) => fileExtensionIs(fileName, ".ts" /* Ts */) && !isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".tsx" /* Tsx */)); -} -function isGeneratedFileWatcher(watch) { - return watch.generatedFilePath !== void 0; -} -function setIsEqualTo(arr1, arr2) { - if (arr1 === arr2) { - return true; - } - if ((arr1 || emptyArray2).length === 0 && (arr2 || emptyArray2).length === 0) { - return true; - } - const set = /* @__PURE__ */ new Map(); - let unique = 0; - for (const v of arr1) { - if (set.get(v) !== true) { - set.set(v, true); - unique++; - } - } - for (const v of arr2) { - const isSet = set.get(v); - if (isSet === void 0) { - return false; - } - if (isSet === true) { - set.set(v, false); - unique--; - } - } - return unique === 0; -} -function typeAcquisitionChanged(opt1, opt2) { - return opt1.enable !== opt2.enable || !setIsEqualTo(opt1.include, opt2.include) || !setIsEqualTo(opt1.exclude, opt2.exclude); -} -function compilerOptionsChanged(opt1, opt2) { - return getAllowJSCompilerOption(opt1) !== getAllowJSCompilerOption(opt2); -} -function unresolvedImportsChanged(imports1, imports2) { - if (imports1 === imports2) { - return false; - } - return !arrayIsEqualTo(imports1, imports2); -} -var Project2 = class _Project { - /** @internal */ - constructor(projectName, projectKind, projectService, documentRegistry, hasExplicitListOfFiles, lastFileExceededProgramSize, compilerOptions, compileOnSaveEnabled, watchOptions, directoryStructureHost, currentDirectory) { - this.projectKind = projectKind; - this.projectService = projectService; - this.documentRegistry = documentRegistry; - this.compilerOptions = compilerOptions; - this.compileOnSaveEnabled = compileOnSaveEnabled; - this.watchOptions = watchOptions; - this.rootFilesMap = /* @__PURE__ */ new Map(); - /** @internal */ - this.plugins = []; - /** - * This is map from files to unresolved imports in it - * Maop does not contain entries for files that do not have unresolved imports - * This helps in containing the set of files to invalidate - * - * @internal - */ - this.cachedUnresolvedImportsPerFile = /* @__PURE__ */ new Map(); - this.hasAddedorRemovedFiles = false; - this.hasAddedOrRemovedSymlinks = false; - /** - * Last version that was reported. - */ - this.lastReportedVersion = 0; - /** - * Current project's program version. (incremented everytime new program is created that is not complete reuse from the old one) - * This property is changed in 'updateGraph' based on the set of files in program - * @internal - */ - this.projectProgramVersion = 0; - /** - * Current version of the project state. It is changed when: - * - new root file was added/removed - * - edit happen in some file that is currently included in the project. - * This property is different from projectStructureVersion since in most cases edits don't affect set of files in the project - * @internal - */ - this.projectStateVersion = 0; - this.isInitialLoadPending = returnFalse; - /** @internal */ - this.dirty = false; - /** @internal */ - this.typingFiles = emptyArray2; - this.moduleSpecifierCache = createModuleSpecifierCache(this); - /** @internal */ - this.createHash = maybeBind(this.projectService.host, this.projectService.host.createHash); - /** @internal */ - this.globalCacheResolutionModuleName = ts_JsTyping_exports.nonRelativeModuleNameForTypingCache; - /** @internal */ - this.updateFromProjectInProgress = false; - this.projectName = projectName; - this.directoryStructureHost = directoryStructureHost; - this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory); - this.getCanonicalFileName = this.projectService.toCanonicalFileName; - this.jsDocParsingMode = this.projectService.jsDocParsingMode; - this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds); - if (!this.compilerOptions) { - this.compilerOptions = getDefaultCompilerOptions2(); - this.compilerOptions.allowNonTsExtensions = true; - this.compilerOptions.allowJs = true; - } else if (hasExplicitListOfFiles || getAllowJSCompilerOption(this.compilerOptions) || this.projectService.hasDeferredExtension()) { - this.compilerOptions.allowNonTsExtensions = true; - } - switch (projectService.serverMode) { - case 0 /* Semantic */: - this.languageServiceEnabled = true; - break; - case 1 /* PartialSemantic */: - this.languageServiceEnabled = true; - this.compilerOptions.noResolve = true; - this.compilerOptions.types = []; - break; - case 2 /* Syntactic */: - this.languageServiceEnabled = false; - this.compilerOptions.noResolve = true; - this.compilerOptions.types = []; - break; - default: - Debug.assertNever(projectService.serverMode); - } - this.setInternalCompilerOptionsForEmittingJsFiles(); - const host = this.projectService.host; - if (this.projectService.logger.loggingEnabled()) { - this.trace = (s) => this.writeLog(s); - } else if (host.trace) { - this.trace = (s) => host.trace(s); - } - this.realpath = maybeBind(host, host.realpath); - this.preferNonRecursiveWatch = this.projectService.canUseWatchEvents || host.preferNonRecursiveWatch; - this.resolutionCache = createResolutionCache( - this, - this.currentDirectory, - /*logChangesWhenResolvingModule*/ - true - ); - this.languageService = createLanguageService(this, this.documentRegistry, this.projectService.serverMode); - if (lastFileExceededProgramSize) { - this.disableLanguageService(lastFileExceededProgramSize); - } - this.markAsDirty(); - if (!isBackgroundProject(this)) { - this.projectService.pendingEnsureProjectForOpenFiles = true; - } - this.projectService.onProjectCreation(this); - } - /** @internal */ - getResolvedProjectReferenceToRedirect(_fileName) { - return void 0; - } - isNonTsProject() { - updateProjectIfDirty(this); - return allFilesAreJsOrDts(this); - } - isJsOnlyProject() { - updateProjectIfDirty(this); - return hasOneOrMoreJsAndNoTsFiles(this); - } - static resolveModule(moduleName, initialDir, host, log) { - return _Project.importServicePluginSync({ name: moduleName }, [initialDir], host, log).resolvedModule; - } - /** @internal */ - static importServicePluginSync(pluginConfigEntry, searchPaths, host, log) { - Debug.assertIsDefined(host.require); - let errorLogs; - let resolvedModule; - for (const initialDir of searchPaths) { - const resolvedPath = normalizeSlashes(host.resolvePath(combinePaths(initialDir, "node_modules"))); - log(`Loading ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`); - const result = host.require(resolvedPath, pluginConfigEntry.name); - if (!result.error) { - resolvedModule = result.module; - break; - } - const err = result.error.stack || result.error.message || JSON.stringify(result.error); - (errorLogs ?? (errorLogs = [])).push(`Failed to load module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`); - } - return { pluginConfigEntry, resolvedModule, errorLogs }; - } - /** @internal */ - static async importServicePluginAsync(pluginConfigEntry, searchPaths, host, log) { - Debug.assertIsDefined(host.importPlugin); - let errorLogs; - let resolvedModule; - for (const initialDir of searchPaths) { - const resolvedPath = combinePaths(initialDir, "node_modules"); - log(`Dynamically importing ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`); - let result; - try { - result = await host.importPlugin(resolvedPath, pluginConfigEntry.name); - } catch (e) { - result = { module: void 0, error: e }; - } - if (!result.error) { - resolvedModule = result.module; - break; - } - const err = result.error.stack || result.error.message || JSON.stringify(result.error); - (errorLogs ?? (errorLogs = [])).push(`Failed to dynamically import module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`); - } - return { pluginConfigEntry, resolvedModule, errorLogs }; - } - isKnownTypesPackageName(name) { - return this.projectService.typingsInstaller.isKnownTypesPackageName(name); - } - installPackage(options) { - return this.projectService.typingsInstaller.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) }); - } - /** @internal */ - getGlobalTypingsCacheLocation() { - return this.getGlobalCache(); - } - /** @internal */ - getSymlinkCache() { - if (!this.symlinks) { - this.symlinks = createSymlinkCache(this.getCurrentDirectory(), this.getCanonicalFileName); - } - if (this.program && !this.symlinks.hasProcessedResolutions()) { - this.symlinks.setSymlinksFromResolutions( - this.program.forEachResolvedModule, - this.program.forEachResolvedTypeReferenceDirective, - this.program.getAutomaticTypeDirectiveResolutions() - ); - } - return this.symlinks; - } - // Method of LanguageServiceHost - getCompilationSettings() { - return this.compilerOptions; - } - // Method to support public API - getCompilerOptions() { - return this.getCompilationSettings(); - } - getNewLine() { - return this.projectService.host.newLine; - } - getProjectVersion() { - return this.projectStateVersion.toString(); - } - getProjectReferences() { - return void 0; - } - getScriptFileNames() { - if (!this.rootFilesMap.size) { - return emptyArray; - } - let result; - this.rootFilesMap.forEach((value) => { - if (this.languageServiceEnabled || value.info && value.info.isScriptOpen()) { - (result || (result = [])).push(value.fileName); - } - }); - return addRange(result, this.typingFiles) || emptyArray; - } - getOrCreateScriptInfoAndAttachToProject(fileName) { - const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient( - fileName, - this.currentDirectory, - this.directoryStructureHost, - /*deferredDeleteOk*/ - false - ); - if (scriptInfo) { - const existingValue = this.rootFilesMap.get(scriptInfo.path); - if (existingValue && existingValue.info !== scriptInfo) { - existingValue.info = scriptInfo; - } - scriptInfo.attachToProject(this); - } - return scriptInfo; - } - getScriptKind(fileName) { - const info = this.projectService.getScriptInfoForPath(this.toPath(fileName)); - return info && info.scriptKind; - } - getScriptVersion(filename) { - const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient( - filename, - this.currentDirectory, - this.directoryStructureHost, - /*deferredDeleteOk*/ - false - ); - return info && info.getLatestVersion(); - } - getScriptSnapshot(filename) { - const scriptInfo = this.getOrCreateScriptInfoAndAttachToProject(filename); - if (scriptInfo) { - return scriptInfo.getSnapshot(); - } - } - getCancellationToken() { - return this.cancellationToken; - } - getCurrentDirectory() { - return this.currentDirectory; - } - getDefaultLibFileName() { - const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath())); - return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions)); - } - useCaseSensitiveFileNames() { - return this.projectService.host.useCaseSensitiveFileNames; - } - readDirectory(path, extensions, exclude, include, depth) { - return this.directoryStructureHost.readDirectory(path, extensions, exclude, include, depth); - } - readFile(fileName) { - return this.projectService.host.readFile(fileName); - } - writeFile(fileName, content) { - return this.projectService.host.writeFile(fileName, content); - } - fileExists(file) { - const path = this.toPath(file); - return !!this.projectService.getScriptInfoForPath(path) || !this.isWatchedMissingFile(path) && this.directoryStructureHost.fileExists(file); - } - /** @internal */ - resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) { - return this.resolutionCache.resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames); - } - /** @internal */ - getModuleResolutionCache() { - return this.resolutionCache.getModuleResolutionCache(); - } - /** @internal */ - resolveTypeReferenceDirectiveReferences(typeDirectiveReferences, containingFile, redirectedReference, options, containingSourceFile, reusedNames) { - return this.resolutionCache.resolveTypeReferenceDirectiveReferences( - typeDirectiveReferences, - containingFile, - redirectedReference, - options, - containingSourceFile, - reusedNames - ); - } - /** @internal */ - resolveLibrary(libraryName, resolveFrom, options, libFileName) { - return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName); - } - directoryExists(path) { - return this.directoryStructureHost.directoryExists(path); - } - getDirectories(path) { - return this.directoryStructureHost.getDirectories(path); - } - /** @internal */ - getCachedDirectoryStructureHost() { - return void 0; - } - /** @internal */ - toPath(fileName) { - return toPath(fileName, this.currentDirectory, this.projectService.toCanonicalFileName); - } - /** @internal */ - watchDirectoryOfFailedLookupLocation(directory, cb, flags) { - return this.projectService.watchFactory.watchDirectory( - directory, - cb, - flags, - this.projectService.getWatchOptions(this), - WatchType.FailedLookupLocations, - this - ); - } - /** @internal */ - watchAffectingFileLocation(file, cb) { - return this.projectService.watchFactory.watchFile( - file, - cb, - 2e3 /* High */, - this.projectService.getWatchOptions(this), - WatchType.AffectingFileLocation, - this - ); - } - /** @internal */ - clearInvalidateResolutionOfFailedLookupTimer() { - return this.projectService.throttledOperations.cancel(`${this.getProjectName()}FailedLookupInvalidation`); - } - /** @internal */ - scheduleInvalidateResolutionsOfFailedLookupLocations() { - this.projectService.throttledOperations.schedule( - `${this.getProjectName()}FailedLookupInvalidation`, - /*delay*/ - 1e3, - () => { - if (this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) { - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - } - } - ); - } - /** @internal */ - invalidateResolutionsOfFailedLookupLocations() { - if (this.clearInvalidateResolutionOfFailedLookupTimer() && this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) { - this.markAsDirty(); - this.projectService.delayEnsureProjectForOpenFiles(); - } - } - /** @internal */ - onInvalidatedResolution() { - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - } - /** @internal */ - watchTypeRootsDirectory(directory, cb, flags) { - return this.projectService.watchFactory.watchDirectory( - directory, - cb, - flags, - this.projectService.getWatchOptions(this), - WatchType.TypeRoots, - this - ); - } - /** @internal */ - hasChangedAutomaticTypeDirectiveNames() { - return this.resolutionCache.hasChangedAutomaticTypeDirectiveNames(); - } - /** @internal */ - onChangedAutomaticTypeDirectiveNames() { - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - } - /** @internal */ - getGlobalCache() { - return this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : void 0; - } - /** @internal */ - fileIsOpen(filePath) { - return this.projectService.openFiles.has(filePath); - } - /** @internal */ - writeLog(s) { - this.projectService.logger.info(s); - } - log(s) { - this.writeLog(s); - } - error(s) { - this.projectService.logger.msg(s, "Err" /* Err */); - } - setInternalCompilerOptionsForEmittingJsFiles() { - if (this.projectKind === 0 /* Inferred */ || this.projectKind === 2 /* External */) { - this.compilerOptions.noEmitForJsFiles = true; - } - } - /** - * Get the errors that dont have any file name associated - */ - getGlobalProjectErrors() { - return filter(this.projectErrors, (diagnostic) => !diagnostic.file) || emptyArray2; - } - /** - * Get all the project errors - */ - getAllProjectErrors() { - return this.projectErrors || emptyArray2; - } - setProjectErrors(projectErrors) { - this.projectErrors = projectErrors; - } - getLanguageService(ensureSynchronized = true) { - if (ensureSynchronized) { - updateProjectIfDirty(this); - } - return this.languageService; - } - /** @internal */ - getSourceMapper() { - return this.getLanguageService().getSourceMapper(); - } - /** @internal */ - clearSourceMapperCache() { - this.languageService.clearSourceMapperCache(); - } - /** @internal */ - getDocumentPositionMapper(generatedFileName, sourceFileName) { - return this.projectService.getDocumentPositionMapper(this, generatedFileName, sourceFileName); - } - /** @internal */ - getSourceFileLike(fileName) { - return this.projectService.getSourceFileLike(fileName, this); - } - /** @internal */ - shouldEmitFile(scriptInfo) { - return scriptInfo && !scriptInfo.isDynamicOrHasMixedContent() && !this.program.isSourceOfProjectReferenceRedirect(scriptInfo.path); - } - getCompileOnSaveAffectedFileList(scriptInfo) { - if (!this.languageServiceEnabled) { - return []; - } - updateProjectIfDirty(this); - this.builderState = BuilderState.create( - this.program, - this.builderState, - /*disableUseFileVersionAsSignature*/ - true - ); - return mapDefined( - BuilderState.getFilesAffectedBy( - this.builderState, - this.program, - scriptInfo.path, - this.cancellationToken, - this.projectService.host - ), - (sourceFile) => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : void 0 - ); - } - /** - * Returns true if emit was conducted - */ - emitFile(scriptInfo, writeFile2) { - if (!this.languageServiceEnabled || !this.shouldEmitFile(scriptInfo)) { - return { emitSkipped: true, diagnostics: emptyArray2 }; - } - const { emitSkipped, diagnostics, outputFiles } = this.getLanguageService().getEmitOutput(scriptInfo.fileName); - if (!emitSkipped) { - for (const outputFile of outputFiles) { - const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, this.currentDirectory); - writeFile2(outputFileAbsoluteFileName, outputFile.text, outputFile.writeByteOrderMark); - } - if (this.builderState && getEmitDeclarations(this.compilerOptions)) { - const dtsFiles = outputFiles.filter((f) => isDeclarationFileName(f.name)); - if (dtsFiles.length === 1) { - const sourceFile = this.program.getSourceFile(scriptInfo.fileName); - const signature = this.projectService.host.createHash ? this.projectService.host.createHash(dtsFiles[0].text) : generateDjb2Hash(dtsFiles[0].text); - BuilderState.updateSignatureOfFile(this.builderState, signature, sourceFile.resolvedPath); - } - } - } - return { emitSkipped, diagnostics }; - } - enableLanguageService() { - if (this.languageServiceEnabled || this.projectService.serverMode === 2 /* Syntactic */) { - return; - } - this.languageServiceEnabled = true; - this.lastFileExceededProgramSize = void 0; - this.projectService.onUpdateLanguageServiceStateForProject( - this, - /*languageServiceEnabled*/ - true - ); - } - /** @internal */ - cleanupProgram() { - if (this.program) { - for (const f of this.program.getSourceFiles()) { - this.detachScriptInfoIfNotRoot(f.fileName); - } - this.program.forEachResolvedProjectReference((ref) => this.detachScriptInfoFromProject(ref.sourceFile.fileName)); - this.program = void 0; - } - } - disableLanguageService(lastFileExceededProgramSize) { - if (!this.languageServiceEnabled) { - return; - } - Debug.assert(this.projectService.serverMode !== 2 /* Syntactic */); - this.languageService.cleanupSemanticCache(); - this.languageServiceEnabled = false; - this.cleanupProgram(); - this.lastFileExceededProgramSize = lastFileExceededProgramSize; - this.builderState = void 0; - if (this.autoImportProviderHost) { - this.autoImportProviderHost.close(); - } - this.autoImportProviderHost = void 0; - this.resolutionCache.closeTypeRootsWatch(); - this.clearGeneratedFileWatch(); - this.projectService.verifyDocumentRegistry(); - this.projectService.onUpdateLanguageServiceStateForProject( - this, - /*languageServiceEnabled*/ - false - ); - } - getProjectName() { - return this.projectName; - } - removeLocalTypingsFromTypeAcquisition(newTypeAcquisition) { - if (!newTypeAcquisition.enable || !newTypeAcquisition.include) { - return newTypeAcquisition; - } - return { ...newTypeAcquisition, include: this.removeExistingTypings(newTypeAcquisition.include) }; - } - getExternalFiles(updateLevel) { - return toSorted(flatMap(this.plugins, (plugin) => { - if (typeof plugin.module.getExternalFiles !== "function") return; - try { - return plugin.module.getExternalFiles(this, updateLevel || 0 /* Update */); - } catch (e) { - this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${e}`); - if (e.stack) { - this.projectService.logger.info(e.stack); - } - } - })); - } - getSourceFile(path) { - if (!this.program) { - return void 0; - } - return this.program.getSourceFileByPath(path); - } - /** @internal */ - getSourceFileOrConfigFile(path) { - const options = this.program.getCompilerOptions(); - return path === options.configFilePath ? options.configFile : this.getSourceFile(path); - } - close() { - var _a; - if (this.typingsCache) this.projectService.typingsInstaller.onProjectClosed(this); - this.typingsCache = void 0; - this.closeWatchingTypingLocations(); - this.cleanupProgram(); - forEach(this.externalFiles, (externalFile) => this.detachScriptInfoIfNotRoot(externalFile)); - this.rootFilesMap.forEach((root) => { - var _a2; - return (_a2 = root.info) == null ? void 0 : _a2.detachFromProject(this); - }); - this.projectService.pendingEnsureProjectForOpenFiles = true; - this.rootFilesMap = void 0; - this.externalFiles = void 0; - this.program = void 0; - this.builderState = void 0; - this.resolutionCache.clear(); - this.resolutionCache = void 0; - this.cachedUnresolvedImportsPerFile = void 0; - (_a = this.packageJsonWatches) == null ? void 0 : _a.forEach((watcher) => { - watcher.projects.delete(this); - watcher.close(); - }); - this.packageJsonWatches = void 0; - this.moduleSpecifierCache.clear(); - this.moduleSpecifierCache = void 0; - this.directoryStructureHost = void 0; - this.exportMapCache = void 0; - this.projectErrors = void 0; - this.plugins.length = 0; - if (this.missingFilesMap) { - clearMap(this.missingFilesMap, closeFileWatcher); - this.missingFilesMap = void 0; - } - this.clearGeneratedFileWatch(); - this.clearInvalidateResolutionOfFailedLookupTimer(); - if (this.autoImportProviderHost) { - this.autoImportProviderHost.close(); - } - this.autoImportProviderHost = void 0; - if (this.noDtsResolutionProject) { - this.noDtsResolutionProject.close(); - } - this.noDtsResolutionProject = void 0; - this.languageService.dispose(); - this.languageService = void 0; - } - detachScriptInfoIfNotRoot(uncheckedFilename) { - const info = this.projectService.getScriptInfo(uncheckedFilename); - if (info && !this.isRoot(info)) { - info.detachFromProject(this); - } - } - isClosed() { - return this.rootFilesMap === void 0; - } - hasRoots() { - var _a; - return !!((_a = this.rootFilesMap) == null ? void 0 : _a.size); - } - /** @internal */ - isOrphan() { - return false; - } - getRootFiles() { - return this.rootFilesMap && arrayFrom(mapDefinedIterator(this.rootFilesMap.values(), (value) => { - var _a; - return (_a = value.info) == null ? void 0 : _a.fileName; - })); - } - /** @internal */ - getRootFilesMap() { - return this.rootFilesMap; - } - getRootScriptInfos() { - return arrayFrom(mapDefinedIterator(this.rootFilesMap.values(), (value) => value.info)); - } - getScriptInfos() { - if (!this.languageServiceEnabled) { - return this.getRootScriptInfos(); - } - return map(this.program.getSourceFiles(), (sourceFile) => { - const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.resolvedPath); - Debug.assert(!!scriptInfo, "getScriptInfo", () => `scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' / '${sourceFile.resolvedPath}' is missing.`); - return scriptInfo; - }); - } - getExcludedFiles() { - return emptyArray2; - } - getFileNames(excludeFilesFromExternalLibraries, excludeConfigFiles) { - if (!this.program) { - return []; - } - if (!this.languageServiceEnabled) { - let rootFiles = this.getRootFiles(); - if (this.compilerOptions) { - const defaultLibrary = getDefaultLibFilePath(this.compilerOptions); - if (defaultLibrary) { - (rootFiles || (rootFiles = [])).push(asNormalizedPath(defaultLibrary)); - } - } - return rootFiles; - } - const result = []; - for (const f of this.program.getSourceFiles()) { - if (excludeFilesFromExternalLibraries && this.program.isSourceFileFromExternalLibrary(f)) { - continue; - } - result.push(asNormalizedPath(f.fileName)); - } - if (!excludeConfigFiles) { - const configFile = this.program.getCompilerOptions().configFile; - if (configFile) { - result.push(asNormalizedPath(configFile.fileName)); - if (configFile.extendedSourceFiles) { - for (const f of configFile.extendedSourceFiles) { - result.push(asNormalizedPath(f)); - } - } - } - } - return result; - } - /** @internal */ - getFileNamesWithRedirectInfo(includeProjectReferenceRedirectInfo) { - return this.getFileNames().map((fileName) => ({ - fileName, - isSourceOfProjectReferenceRedirect: includeProjectReferenceRedirectInfo && this.isSourceOfProjectReferenceRedirect(fileName) - })); - } - hasConfigFile(configFilePath) { - if (this.program && this.languageServiceEnabled) { - const configFile = this.program.getCompilerOptions().configFile; - if (configFile) { - if (configFilePath === asNormalizedPath(configFile.fileName)) { - return true; - } - if (configFile.extendedSourceFiles) { - for (const f of configFile.extendedSourceFiles) { - if (configFilePath === asNormalizedPath(f)) { - return true; - } - } - } - } - } - return false; - } - containsScriptInfo(info) { - if (this.isRoot(info)) return true; - if (!this.program) return false; - const file = this.program.getSourceFileByPath(info.path); - return !!file && file.resolvedPath === info.path; - } - containsFile(filename, requireOpen) { - const info = this.projectService.getScriptInfoForNormalizedPath(filename); - if (info && (info.isScriptOpen() || !requireOpen)) { - return this.containsScriptInfo(info); - } - return false; - } - isRoot(info) { - var _a, _b; - return ((_b = (_a = this.rootFilesMap) == null ? void 0 : _a.get(info.path)) == null ? void 0 : _b.info) === info; - } - // add a root file to project - addRoot(info, fileName) { - Debug.assert(!this.isRoot(info)); - this.rootFilesMap.set(info.path, { fileName: fileName || info.fileName, info }); - info.attachToProject(this); - this.markAsDirty(); - } - // add a root file that doesnt exist on host - addMissingFileRoot(fileName) { - const path = this.projectService.toPath(fileName); - this.rootFilesMap.set(path, { fileName }); - this.markAsDirty(); - } - removeFile(info, fileExists, detachFromProject) { - if (this.isRoot(info)) { - this.removeRoot(info); - } - if (fileExists) { - this.resolutionCache.removeResolutionsOfFile(info.path); - } else { - this.resolutionCache.invalidateResolutionOfFile(info.path); - } - this.cachedUnresolvedImportsPerFile.delete(info.path); - if (detachFromProject) { - info.detachFromProject(this); - } - this.markAsDirty(); - } - registerFileUpdate(fileName) { - (this.updatedFileNames || (this.updatedFileNames = /* @__PURE__ */ new Set())).add(fileName); - } - /** @internal */ - markFileAsDirty(changedFile) { - this.markAsDirty(); - if (this.exportMapCache && !this.exportMapCache.isEmpty()) { - (this.changedFilesForExportMapCache || (this.changedFilesForExportMapCache = /* @__PURE__ */ new Set())).add(changedFile); - } - } - /** @internal */ - markAsDirty() { - if (!this.dirty) { - this.projectStateVersion++; - this.dirty = true; - } - } - /** @internal */ - markAutoImportProviderAsDirty() { - var _a; - if (!this.autoImportProviderHost) this.autoImportProviderHost = void 0; - (_a = this.autoImportProviderHost) == null ? void 0 : _a.markAsDirty(); - } - /** @internal */ - onAutoImportProviderSettingsChanged() { - var _a; - if (this.autoImportProviderHost === false) { - this.autoImportProviderHost = void 0; - } else { - (_a = this.autoImportProviderHost) == null ? void 0 : _a.markAsDirty(); - } - } - /** @internal */ - onPackageJsonChange() { - this.moduleSpecifierCache.clear(); - if (this.autoImportProviderHost) { - this.autoImportProviderHost.markAsDirty(); - } - } - /** @internal */ - onFileAddedOrRemoved(isSymlink) { - this.hasAddedorRemovedFiles = true; - if (isSymlink) { - this.hasAddedOrRemovedSymlinks = true; - } - } - /** @internal */ - onDiscoveredSymlink() { - this.hasAddedOrRemovedSymlinks = true; - } - /** @internal */ - onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath, newSourceFileByResolvedPath) { - if (!newSourceFileByResolvedPath || oldSourceFile.resolvedPath === oldSourceFile.path && newSourceFileByResolvedPath.resolvedPath !== oldSourceFile.path) { - this.detachScriptInfoFromProject(oldSourceFile.fileName, hasSourceFileByPath); - } - } - /** @internal */ - updateFromProject() { - updateProjectIfDirty(this); - } - /** - * Updates set of files that contribute to this project - * @returns: true if set of files in the project stays the same and false - otherwise. - */ - updateGraph() { - var _a, _b; - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "updateGraph", { name: this.projectName, kind: ProjectKind[this.projectKind] }); - this.resolutionCache.startRecordingFilesWithChangedResolutions(); - const hasNewProgram = this.updateGraphWorker(); - const hasAddedorRemovedFiles = this.hasAddedorRemovedFiles; - this.hasAddedorRemovedFiles = false; - this.hasAddedOrRemovedSymlinks = false; - const changedFiles = this.resolutionCache.finishRecordingFilesWithChangedResolutions() || emptyArray2; - for (const file of changedFiles) { - this.cachedUnresolvedImportsPerFile.delete(file); - } - if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */ && !this.isOrphan()) { - if (hasNewProgram || changedFiles.length) { - this.lastCachedUnresolvedImportsList = getUnresolvedImports(this.program, this.cachedUnresolvedImportsPerFile); - } - this.enqueueInstallTypingsForProject(hasAddedorRemovedFiles); - } else { - this.lastCachedUnresolvedImportsList = void 0; - } - const isFirstProgramLoad = this.projectProgramVersion === 0 && hasNewProgram; - if (hasNewProgram) { - this.projectProgramVersion++; - } - if (hasAddedorRemovedFiles) { - this.markAutoImportProviderAsDirty(); - } - if (isFirstProgramLoad) { - this.getPackageJsonAutoImportProvider(); - } - (_b = tracing) == null ? void 0 : _b.pop(); - return !hasNewProgram; - } - /** @internal */ - enqueueInstallTypingsForProject(forceRefresh) { - const typeAcquisition = this.getTypeAcquisition(); - if (!typeAcquisition || !typeAcquisition.enable || this.projectService.typingsInstaller === nullTypingsInstaller) { - return; - } - const entry = this.typingsCache; - if (forceRefresh || !entry || typeAcquisitionChanged(typeAcquisition, entry.typeAcquisition) || compilerOptionsChanged(this.getCompilationSettings(), entry.compilerOptions) || unresolvedImportsChanged(this.lastCachedUnresolvedImportsList, entry.unresolvedImports)) { - this.typingsCache = { - compilerOptions: this.getCompilationSettings(), - typeAcquisition, - unresolvedImports: this.lastCachedUnresolvedImportsList - }; - this.projectService.typingsInstaller.enqueueInstallTypingsRequest(this, typeAcquisition, this.lastCachedUnresolvedImportsList); - } - } - /** @internal */ - updateTypingFiles(compilerOptions, typeAcquisition, unresolvedImports, newTypings) { - this.typingsCache = { - compilerOptions, - typeAcquisition, - unresolvedImports - }; - const typingFiles = !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : toSorted(newTypings); - if (enumerateInsertsAndDeletes( - typingFiles, - this.typingFiles, - getStringComparer(!this.useCaseSensitiveFileNames()), - /*inserted*/ - noop, - (removed) => this.detachScriptInfoFromProject(removed) - )) { - this.typingFiles = typingFiles; - this.resolutionCache.setFilesWithInvalidatedNonRelativeUnresolvedImports(this.cachedUnresolvedImportsPerFile); - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - } - } - closeWatchingTypingLocations() { - if (this.typingWatchers) clearMap(this.typingWatchers, closeFileWatcher); - this.typingWatchers = void 0; - } - onTypingInstallerWatchInvoke() { - this.typingWatchers.isInvoked = true; - this.projectService.updateTypingsForProject({ projectName: this.getProjectName(), kind: ActionInvalidate }); - } - /** @internal */ - watchTypingLocations(files) { - if (!files) { - this.typingWatchers.isInvoked = false; - return; - } - if (!files.length) { - this.closeWatchingTypingLocations(); - return; - } - const toRemove = new Map(this.typingWatchers); - if (!this.typingWatchers) this.typingWatchers = /* @__PURE__ */ new Map(); - this.typingWatchers.isInvoked = false; - const createProjectWatcher = (path, typingsWatcherType) => { - const canonicalPath = this.toPath(path); - toRemove.delete(canonicalPath); - if (!this.typingWatchers.has(canonicalPath)) { - this.typingWatchers.set( - canonicalPath, - typingsWatcherType === "FileWatcher" /* FileWatcher */ ? this.projectService.watchFactory.watchFile( - path, - () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`), - 2e3 /* High */, - this.projectService.getWatchOptions(this), - WatchType.TypingInstallerLocationFile, - this - ) : this.projectService.watchFactory.watchDirectory( - path, - (f) => { - if (this.typingWatchers.isInvoked) return this.writeLog(`TypingWatchers already invoked`); - if (!fileExtensionIs(f, ".json" /* Json */)) return this.writeLog(`Ignoring files that are not *.json`); - if (comparePaths(f, combinePaths(this.projectService.typingsInstaller.globalTypingsCacheLocation, "package.json"), !this.useCaseSensitiveFileNames())) return this.writeLog(`Ignoring package.json change at global typings location`); - this.onTypingInstallerWatchInvoke(); - }, - 1 /* Recursive */, - this.projectService.getWatchOptions(this), - WatchType.TypingInstallerLocationDirectory, - this - ) - ); - } - }; - for (const file of files) { - const basename = getBaseFileName(file); - if (basename === "package.json" || basename === "bower.json") { - createProjectWatcher(file, "FileWatcher" /* FileWatcher */); - continue; - } - if (containsPath(this.currentDirectory, file, this.currentDirectory, !this.useCaseSensitiveFileNames())) { - const subDirectory = file.indexOf(directorySeparator, this.currentDirectory.length + 1); - if (subDirectory !== -1) { - createProjectWatcher(file.substr(0, subDirectory), "DirectoryWatcher" /* DirectoryWatcher */); - } else { - createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */); - } - continue; - } - if (containsPath(this.projectService.typingsInstaller.globalTypingsCacheLocation, file, this.currentDirectory, !this.useCaseSensitiveFileNames())) { - createProjectWatcher(this.projectService.typingsInstaller.globalTypingsCacheLocation, "DirectoryWatcher" /* DirectoryWatcher */); - continue; - } - createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */); - } - toRemove.forEach((watch, path) => { - watch.close(); - this.typingWatchers.delete(path); - }); - } - /** @internal */ - getCurrentProgram() { - return this.program; - } - removeExistingTypings(include) { - if (!include.length) return include; - const existing = getAutomaticTypeDirectiveNames(this.getCompilerOptions(), this.directoryStructureHost); - return filter(include, (i) => !existing.includes(i)); - } - updateGraphWorker() { - var _a, _b; - const oldProgram = this.languageService.getCurrentProgram(); - Debug.assert(oldProgram === this.program); - Debug.assert(!this.isClosed(), "Called update graph worker of closed project"); - this.writeLog(`Starting updateGraphWorker: Project: ${this.getProjectName()}`); - const start = timestamp(); - const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = this.resolutionCache.createHasInvalidatedResolutions(returnFalse, returnFalse); - this.hasInvalidatedResolutions = hasInvalidatedResolutions; - this.hasInvalidatedLibResolutions = hasInvalidatedLibResolutions; - this.resolutionCache.startCachingPerDirectoryResolution(); - this.dirty = false; - this.updateFromProjectInProgress = true; - this.program = this.languageService.getProgram(); - this.updateFromProjectInProgress = false; - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "finishCachingPerDirectoryResolution"); - this.resolutionCache.finishCachingPerDirectoryResolution(this.program, oldProgram); - (_b = tracing) == null ? void 0 : _b.pop(); - Debug.assert(oldProgram === void 0 || this.program !== void 0); - let hasNewProgram = false; - if (this.program && (!oldProgram || this.program !== oldProgram && this.program.structureIsReused !== 2 /* Completely */)) { - hasNewProgram = true; - this.rootFilesMap.forEach((value, path) => { - var _a2; - const file = this.program.getSourceFileByPath(path); - const info = value.info; - if (!file || ((_a2 = value.info) == null ? void 0 : _a2.path) === file.resolvedPath) return; - value.info = this.projectService.getScriptInfo(file.fileName); - Debug.assert(value.info.isAttached(this)); - info == null ? void 0 : info.detachFromProject(this); - }); - updateMissingFilePathsWatch( - this.program, - this.missingFilesMap || (this.missingFilesMap = /* @__PURE__ */ new Map()), - // Watch the missing files - (missingFilePath, missingFileName) => this.addMissingFileWatcher(missingFilePath, missingFileName) - ); - if (this.generatedFilesMap) { - const outPath = this.compilerOptions.outFile; - if (isGeneratedFileWatcher(this.generatedFilesMap)) { - if (!outPath || !this.isValidGeneratedFileWatcher( - removeFileExtension(outPath) + ".d.ts" /* Dts */, - this.generatedFilesMap - )) { - this.clearGeneratedFileWatch(); - } - } else { - if (outPath) { - this.clearGeneratedFileWatch(); - } else { - this.generatedFilesMap.forEach((watcher, source) => { - const sourceFile = this.program.getSourceFileByPath(source); - if (!sourceFile || sourceFile.resolvedPath !== source || !this.isValidGeneratedFileWatcher( - getDeclarationEmitOutputFilePathWorker(sourceFile.fileName, this.compilerOptions, this.program), - watcher - )) { - closeFileWatcherOf(watcher); - this.generatedFilesMap.delete(source); - } - }); - } - } - } - if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */) { - this.resolutionCache.updateTypeRootsWatch(); - } - } - this.projectService.verifyProgram(this); - if (this.exportMapCache && !this.exportMapCache.isEmpty()) { - this.exportMapCache.releaseSymbols(); - if (this.hasAddedorRemovedFiles || oldProgram && !this.program.structureIsReused) { - this.exportMapCache.clear(); - } else if (this.changedFilesForExportMapCache && oldProgram && this.program) { - forEachKey(this.changedFilesForExportMapCache, (fileName) => { - const oldSourceFile = oldProgram.getSourceFileByPath(fileName); - const sourceFile = this.program.getSourceFileByPath(fileName); - if (!oldSourceFile || !sourceFile) { - this.exportMapCache.clear(); - return true; - } - return this.exportMapCache.onFileChanged(oldSourceFile, sourceFile, !!this.getTypeAcquisition().enable); - }); - } - } - if (this.changedFilesForExportMapCache) { - this.changedFilesForExportMapCache.clear(); - } - if (this.hasAddedOrRemovedSymlinks || this.program && !this.program.structureIsReused && this.getCompilerOptions().preserveSymlinks) { - this.symlinks = void 0; - this.moduleSpecifierCache.clear(); - } - const oldExternalFiles = this.externalFiles || emptyArray2; - this.externalFiles = this.getExternalFiles(); - enumerateInsertsAndDeletes( - this.externalFiles, - oldExternalFiles, - getStringComparer(!this.useCaseSensitiveFileNames()), - // Ensure a ScriptInfo is created for new external files. This is performed indirectly - // by the host for files in the program when the program is retrieved above but - // the program doesn't contain external files so this must be done explicitly. - (inserted) => { - const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient( - inserted, - this.currentDirectory, - this.directoryStructureHost, - /*deferredDeleteOk*/ - false - ); - scriptInfo == null ? void 0 : scriptInfo.attachToProject(this); - }, - (removed) => this.detachScriptInfoFromProject(removed) - ); - const elapsed = timestamp() - start; - this.sendPerformanceEvent("UpdateGraph", elapsed); - this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} projectStateVersion: ${this.projectStateVersion} projectProgramVersion: ${this.projectProgramVersion} structureChanged: ${hasNewProgram}${this.program ? ` structureIsReused:: ${StructureIsReused[this.program.structureIsReused]}` : ""} Elapsed: ${elapsed}ms`); - if (this.projectService.logger.isTestLogger) { - if (this.program !== oldProgram) { - this.print( - /*writeProjectFileNames*/ - true, - this.hasAddedorRemovedFiles, - /*writeFileVersionAndText*/ - true - ); - } else { - this.writeLog(`Same program as before`); - } - } else if (this.hasAddedorRemovedFiles) { - this.print( - /*writeProjectFileNames*/ - true, - /*writeFileExplaination*/ - true, - /*writeFileVersionAndText*/ - false - ); - } else if (this.program !== oldProgram) { - this.writeLog(`Different program with same set of files`); - } - this.projectService.verifyDocumentRegistry(); - return hasNewProgram; - } - /** @internal */ - sendPerformanceEvent(kind, durationMs) { - this.projectService.sendPerformanceEvent(kind, durationMs); - } - detachScriptInfoFromProject(uncheckedFileName, noRemoveResolution) { - const scriptInfoToDetach = this.projectService.getScriptInfo(uncheckedFileName); - if (scriptInfoToDetach) { - scriptInfoToDetach.detachFromProject(this); - if (!noRemoveResolution) { - this.resolutionCache.removeResolutionsOfFile(scriptInfoToDetach.path); - } - } - } - addMissingFileWatcher(missingFilePath, missingFileName) { - var _a; - if (isConfiguredProject(this)) { - const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(missingFilePath); - if ((_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config) == null ? void 0 : _a.projects.has(this.canonicalConfigFilePath)) return noopFileWatcher; - } - const fileWatcher = this.projectService.watchFactory.watchFile( - getNormalizedAbsolutePath(missingFileName, this.currentDirectory), - (fileName, eventKind) => { - if (isConfiguredProject(this)) { - this.getCachedDirectoryStructureHost().addOrDeleteFile(fileName, missingFilePath, eventKind); - } - if (eventKind === 0 /* Created */ && this.missingFilesMap.has(missingFilePath)) { - this.missingFilesMap.delete(missingFilePath); - fileWatcher.close(); - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - } - }, - 500 /* Medium */, - this.projectService.getWatchOptions(this), - WatchType.MissingFile, - this - ); - return fileWatcher; - } - isWatchedMissingFile(path) { - return !!this.missingFilesMap && this.missingFilesMap.has(path); - } - /** @internal */ - addGeneratedFileWatch(generatedFile, sourceFile) { - if (this.compilerOptions.outFile) { - if (!this.generatedFilesMap) { - this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile); - } - } else { - const path = this.toPath(sourceFile); - if (this.generatedFilesMap) { - if (isGeneratedFileWatcher(this.generatedFilesMap)) { - Debug.fail(`${this.projectName} Expected to not have --out watcher for generated file with options: ${JSON.stringify(this.compilerOptions)}`); - return; - } - if (this.generatedFilesMap.has(path)) return; - } else { - this.generatedFilesMap = /* @__PURE__ */ new Map(); - } - this.generatedFilesMap.set(path, this.createGeneratedFileWatcher(generatedFile)); - } - } - createGeneratedFileWatcher(generatedFile) { - return { - generatedFilePath: this.toPath(generatedFile), - watcher: this.projectService.watchFactory.watchFile( - generatedFile, - () => { - this.clearSourceMapperCache(); - this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this); - }, - 2e3 /* High */, - this.projectService.getWatchOptions(this), - WatchType.MissingGeneratedFile, - this - ) - }; - } - isValidGeneratedFileWatcher(generateFile, watcher) { - return this.toPath(generateFile) === watcher.generatedFilePath; - } - clearGeneratedFileWatch() { - if (this.generatedFilesMap) { - if (isGeneratedFileWatcher(this.generatedFilesMap)) { - closeFileWatcherOf(this.generatedFilesMap); - } else { - clearMap(this.generatedFilesMap, closeFileWatcherOf); - } - this.generatedFilesMap = void 0; - } - } - getScriptInfoForNormalizedPath(fileName) { - const scriptInfo = this.projectService.getScriptInfoForPath(this.toPath(fileName)); - if (scriptInfo && !scriptInfo.isAttached(this)) { - return Errors.ThrowProjectDoesNotContainDocument(fileName, this); - } - return scriptInfo; - } - getScriptInfo(uncheckedFileName) { - return this.projectService.getScriptInfo(uncheckedFileName); - } - filesToString(writeProjectFileNames) { - return this.filesToStringWorker( - writeProjectFileNames, - /*writeFileExplaination*/ - true, - /*writeFileVersionAndText*/ - false - ); - } - filesToStringWorker(writeProjectFileNames, writeFileExplaination, writeFileVersionAndText) { - if (this.isInitialLoadPending()) return " Files (0) InitialLoadPending\n"; - if (!this.program) return " Files (0) NoProgram\n"; - const sourceFiles = this.program.getSourceFiles(); - let strBuilder = ` Files (${sourceFiles.length}) -`; - if (writeProjectFileNames) { - for (const file of sourceFiles) { - strBuilder += ` ${file.fileName}${writeFileVersionAndText ? ` ${file.version} ${JSON.stringify(file.text)}` : ""} -`; - } - if (writeFileExplaination) { - strBuilder += "\n\n"; - explainFiles(this.program, (s) => strBuilder += ` ${s} -`); - } - } - return strBuilder; - } - /** @internal */ - print(writeProjectFileNames, writeFileExplaination, writeFileVersionAndText) { - var _a; - this.writeLog(`Project '${this.projectName}' (${ProjectKind[this.projectKind]})`); - this.writeLog(this.filesToStringWorker( - writeProjectFileNames && this.projectService.logger.hasLevel(3 /* verbose */), - writeFileExplaination && this.projectService.logger.hasLevel(3 /* verbose */), - writeFileVersionAndText && this.projectService.logger.hasLevel(3 /* verbose */) - )); - this.writeLog("-----------------------------------------------"); - if (this.autoImportProviderHost) { - this.autoImportProviderHost.print( - /*writeProjectFileNames*/ - false, - /*writeFileExplaination*/ - false, - /*writeFileVersionAndText*/ - false - ); - } - (_a = this.noDtsResolutionProject) == null ? void 0 : _a.print( - /*writeProjectFileNames*/ - false, - /*writeFileExplaination*/ - false, - /*writeFileVersionAndText*/ - false - ); - } - setCompilerOptions(compilerOptions) { - var _a; - if (compilerOptions) { - compilerOptions.allowNonTsExtensions = true; - const oldOptions = this.compilerOptions; - this.compilerOptions = compilerOptions; - this.setInternalCompilerOptionsForEmittingJsFiles(); - (_a = this.noDtsResolutionProject) == null ? void 0 : _a.setCompilerOptions(this.getCompilerOptionsForNoDtsResolutionProject()); - if (changesAffectModuleResolution(oldOptions, compilerOptions)) { - this.cachedUnresolvedImportsPerFile.clear(); - this.lastCachedUnresolvedImportsList = void 0; - this.resolutionCache.onChangesAffectModuleResolution(); - this.moduleSpecifierCache.clear(); - } - this.markAsDirty(); - } - } - /** @internal */ - setWatchOptions(watchOptions) { - this.watchOptions = watchOptions; - } - /** @internal */ - getWatchOptions() { - return this.watchOptions; - } - setTypeAcquisition(newTypeAcquisition) { - if (newTypeAcquisition) { - this.typeAcquisition = this.removeLocalTypingsFromTypeAcquisition(newTypeAcquisition); - } - } - getTypeAcquisition() { - return this.typeAcquisition || {}; - } - /** @internal */ - getChangesSinceVersion(lastKnownVersion, includeProjectReferenceRedirectInfo) { - var _a, _b; - const includeProjectReferenceRedirectInfoIfRequested = includeProjectReferenceRedirectInfo ? (files) => arrayFrom(files.entries(), ([fileName, isSourceOfProjectReferenceRedirect]) => ({ - fileName, - isSourceOfProjectReferenceRedirect - })) : (files) => arrayFrom(files.keys()); - if (!this.isInitialLoadPending()) { - updateProjectIfDirty(this); - } - const info = { - projectName: this.getProjectName(), - version: this.projectProgramVersion, - isInferred: isInferredProject(this), - options: this.getCompilationSettings(), - languageServiceDisabled: !this.languageServiceEnabled, - lastFileExceededProgramSize: this.lastFileExceededProgramSize - }; - const updatedFileNames = this.updatedFileNames; - this.updatedFileNames = void 0; - if (this.lastReportedFileNames && lastKnownVersion === this.lastReportedVersion) { - if (this.projectProgramVersion === this.lastReportedVersion && !updatedFileNames) { - return { info, projectErrors: this.getGlobalProjectErrors() }; - } - const lastReportedFileNames = this.lastReportedFileNames; - const externalFiles = ((_a = this.externalFiles) == null ? void 0 : _a.map((f) => ({ - fileName: toNormalizedPath(f), - isSourceOfProjectReferenceRedirect: false - }))) || emptyArray2; - const currentFiles = arrayToMap( - this.getFileNamesWithRedirectInfo(!!includeProjectReferenceRedirectInfo).concat(externalFiles), - (info2) => info2.fileName, - (info2) => info2.isSourceOfProjectReferenceRedirect - ); - const added = /* @__PURE__ */ new Map(); - const removed = /* @__PURE__ */ new Map(); - const updated = updatedFileNames ? arrayFrom(updatedFileNames.keys()) : []; - const updatedRedirects = []; - forEachEntry(currentFiles, (isSourceOfProjectReferenceRedirect, fileName) => { - if (!lastReportedFileNames.has(fileName)) { - added.set(fileName, isSourceOfProjectReferenceRedirect); - } else if (includeProjectReferenceRedirectInfo && isSourceOfProjectReferenceRedirect !== lastReportedFileNames.get(fileName)) { - updatedRedirects.push({ - fileName, - isSourceOfProjectReferenceRedirect - }); - } - }); - forEachEntry(lastReportedFileNames, (isSourceOfProjectReferenceRedirect, fileName) => { - if (!currentFiles.has(fileName)) { - removed.set(fileName, isSourceOfProjectReferenceRedirect); - } - }); - this.lastReportedFileNames = currentFiles; - this.lastReportedVersion = this.projectProgramVersion; - return { - info, - changes: { - added: includeProjectReferenceRedirectInfoIfRequested(added), - removed: includeProjectReferenceRedirectInfoIfRequested(removed), - updated: includeProjectReferenceRedirectInfo ? updated.map((fileName) => ({ - fileName, - isSourceOfProjectReferenceRedirect: this.isSourceOfProjectReferenceRedirect(fileName) - })) : updated, - updatedRedirects: includeProjectReferenceRedirectInfo ? updatedRedirects : void 0 - }, - projectErrors: this.getGlobalProjectErrors() - }; - } else { - const projectFileNames = this.getFileNamesWithRedirectInfo(!!includeProjectReferenceRedirectInfo); - const externalFiles = ((_b = this.externalFiles) == null ? void 0 : _b.map((f) => ({ - fileName: toNormalizedPath(f), - isSourceOfProjectReferenceRedirect: false - }))) || emptyArray2; - const allFiles = projectFileNames.concat(externalFiles); - this.lastReportedFileNames = arrayToMap( - allFiles, - (info2) => info2.fileName, - (info2) => info2.isSourceOfProjectReferenceRedirect - ); - this.lastReportedVersion = this.projectProgramVersion; - return { - info, - files: includeProjectReferenceRedirectInfo ? allFiles : allFiles.map((f) => f.fileName), - projectErrors: this.getGlobalProjectErrors() - }; - } - } - // remove a root file from project - removeRoot(info) { - this.rootFilesMap.delete(info.path); - } - /** @internal */ - isSourceOfProjectReferenceRedirect(fileName) { - return !!this.program && this.program.isSourceOfProjectReferenceRedirect(fileName); - } - /** @internal */ - getGlobalPluginSearchPaths() { - return [ - ...this.projectService.pluginProbeLocations, - // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/ - combinePaths(this.projectService.getExecutingFilePath(), "../../..") - ]; - } - enableGlobalPlugins(options) { - if (!this.projectService.globalPlugins.length) return; - const host = this.projectService.host; - if (!host.require && !host.importPlugin) { - this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); - return; - } - const searchPaths = this.getGlobalPluginSearchPaths(); - for (const globalPluginName of this.projectService.globalPlugins) { - if (!globalPluginName) continue; - if (options.plugins && options.plugins.some((p) => p.name === globalPluginName)) continue; - this.projectService.logger.info(`Loading global plugin ${globalPluginName}`); - this.enablePlugin({ name: globalPluginName, global: true }, searchPaths); - } - } - enablePlugin(pluginConfigEntry, searchPaths) { - this.projectService.requestEnablePlugin(this, pluginConfigEntry, searchPaths); - } - /** @internal */ - enableProxy(pluginModuleFactory, configEntry) { - try { - if (typeof pluginModuleFactory !== "function") { - this.projectService.logger.info(`Skipped loading plugin ${configEntry.name} because it did not expose a proper factory function`); - return; - } - const info = { - config: configEntry, - project: this, - languageService: this.languageService, - languageServiceHost: this, - serverHost: this.projectService.host, - session: this.projectService.session - }; - const pluginModule = pluginModuleFactory({ typescript: ts_exports2 }); - const newLS = pluginModule.create(info); - for (const k of Object.keys(this.languageService)) { - if (!(k in newLS)) { - this.projectService.logger.info(`Plugin activation warning: Missing proxied method ${k} in created LS. Patching.`); - newLS[k] = this.languageService[k]; - } - } - this.projectService.logger.info(`Plugin validation succeeded`); - this.languageService = newLS; - this.plugins.push({ name: configEntry.name, module: pluginModule }); - } catch (e) { - this.projectService.logger.info(`Plugin activation failed: ${e}`); - } - } - /** @internal */ - onPluginConfigurationChanged(pluginName, configuration) { - this.plugins.filter((plugin) => plugin.name === pluginName).forEach((plugin) => { - if (plugin.module.onConfigurationChanged) { - plugin.module.onConfigurationChanged(configuration); - } - }); - } - /** Starts a new check for diagnostics. Call this if some file has updated that would cause diagnostics to be changed. */ - refreshDiagnostics() { - this.projectService.sendProjectsUpdatedInBackgroundEvent(); - } - /** @internal */ - getPackageJsonsVisibleToFile(fileName, rootDir) { - if (this.projectService.serverMode !== 0 /* Semantic */) return emptyArray2; - return this.projectService.getPackageJsonsVisibleToFile(fileName, this, rootDir); - } - /** @internal */ - getNearestAncestorDirectoryWithPackageJson(fileName) { - return this.projectService.getNearestAncestorDirectoryWithPackageJson(fileName); - } - /** @internal */ - getPackageJsonsForAutoImport(rootDir) { - return this.getPackageJsonsVisibleToFile(combinePaths(this.currentDirectory, inferredTypesContainingFile), rootDir); - } - /** @internal */ - getPackageJsonCache() { - return this.projectService.packageJsonCache; - } - /** @internal */ - getCachedExportInfoMap() { - return this.exportMapCache || (this.exportMapCache = createCacheableExportInfoMap(this)); - } - /** @internal */ - clearCachedExportInfoMap() { - var _a; - (_a = this.exportMapCache) == null ? void 0 : _a.clear(); - } - /** @internal */ - getModuleSpecifierCache() { - return this.moduleSpecifierCache; - } - /** @internal */ - includePackageJsonAutoImports() { - if (this.projectService.includePackageJsonAutoImports() === 0 /* Off */ || !this.languageServiceEnabled || isInsideNodeModules(this.currentDirectory) || !this.isDefaultProjectForOpenFiles()) { - return 0 /* Off */; - } - return this.projectService.includePackageJsonAutoImports(); - } - /** @internal */ - getHostForAutoImportProvider() { - var _a, _b; - if (this.program) { - return { - fileExists: this.program.fileExists, - directoryExists: this.program.directoryExists, - realpath: this.program.realpath || ((_a = this.projectService.host.realpath) == null ? void 0 : _a.bind(this.projectService.host)), - getCurrentDirectory: this.getCurrentDirectory.bind(this), - readFile: this.projectService.host.readFile.bind(this.projectService.host), - getDirectories: this.projectService.host.getDirectories.bind(this.projectService.host), - trace: (_b = this.projectService.host.trace) == null ? void 0 : _b.bind(this.projectService.host), - useCaseSensitiveFileNames: this.program.useCaseSensitiveFileNames(), - readDirectory: this.projectService.host.readDirectory.bind(this.projectService.host) - }; - } - return this.projectService.host; - } - /** @internal */ - getPackageJsonAutoImportProvider() { - var _a, _b, _c; - if (this.autoImportProviderHost === false) { - return void 0; - } - if (this.projectService.serverMode !== 0 /* Semantic */) { - this.autoImportProviderHost = false; - return void 0; - } - if (this.autoImportProviderHost) { - updateProjectIfDirty(this.autoImportProviderHost); - if (this.autoImportProviderHost.isEmpty()) { - this.autoImportProviderHost.close(); - this.autoImportProviderHost = void 0; - return void 0; - } - return this.autoImportProviderHost.getCurrentProgram(); - } - const dependencySelection = this.includePackageJsonAutoImports(); - if (dependencySelection) { - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "getPackageJsonAutoImportProvider"); - const start = timestamp(); - this.autoImportProviderHost = AutoImportProviderProject.create(dependencySelection, this, this.getHostForAutoImportProvider(), this.documentRegistry); - if (this.autoImportProviderHost) { - updateProjectIfDirty(this.autoImportProviderHost); - this.sendPerformanceEvent("CreatePackageJsonAutoImportProvider", timestamp() - start); - (_b = tracing) == null ? void 0 : _b.pop(); - return this.autoImportProviderHost.getCurrentProgram(); - } - (_c = tracing) == null ? void 0 : _c.pop(); - } - } - isDefaultProjectForOpenFiles() { - return !!forEachEntry( - this.projectService.openFiles, - (_projectRootPath, path) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path)) === this - ); - } - /** @internal */ - watchNodeModulesForPackageJsonChanges(directoryPath) { - return this.projectService.watchPackageJsonsInNodeModules(directoryPath, this); - } - /** @internal */ - getIncompleteCompletionsCache() { - return this.projectService.getIncompleteCompletionsCache(); - } - /** @internal */ - getNoDtsResolutionProject(rootFile) { - Debug.assert(this.projectService.serverMode === 0 /* Semantic */); - if (!this.noDtsResolutionProject) { - this.noDtsResolutionProject = new AuxiliaryProject(this.projectService, this.documentRegistry, this.getCompilerOptionsForNoDtsResolutionProject(), this.currentDirectory); - } - if (this.noDtsResolutionProject.rootFile !== rootFile) { - this.projectService.setFileNamesOfAutpImportProviderOrAuxillaryProject(this.noDtsResolutionProject, [rootFile]); - this.noDtsResolutionProject.rootFile = rootFile; - } - return this.noDtsResolutionProject; - } - /** @internal */ - runWithTemporaryFileUpdate(rootFile, updatedText, cb) { - var _a, _b, _c, _d; - const originalProgram = this.program; - const rootSourceFile = Debug.checkDefined((_a = this.program) == null ? void 0 : _a.getSourceFile(rootFile), "Expected file to be part of program"); - const originalText = Debug.checkDefined(rootSourceFile.getFullText()); - (_b = this.getScriptInfo(rootFile)) == null ? void 0 : _b.editContent(0, originalText.length, updatedText); - this.updateGraph(); - try { - cb(this.program, originalProgram, (_c = this.program) == null ? void 0 : _c.getSourceFile(rootFile)); - } finally { - (_d = this.getScriptInfo(rootFile)) == null ? void 0 : _d.editContent(0, updatedText.length, originalText); - } - } - getCompilerOptionsForNoDtsResolutionProject() { - return { - ...this.getCompilerOptions(), - noDtsResolution: true, - allowJs: true, - maxNodeModuleJsDepth: 3, - diagnostics: false, - skipLibCheck: true, - sourceMap: false, - types: emptyArray, - lib: emptyArray, - noLib: true - }; - } -}; -function getUnresolvedImports(program, cachedUnresolvedImportsPerFile) { - var _a, _b; - const sourceFiles = program.getSourceFiles(); - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "getUnresolvedImports", { count: sourceFiles.length }); - const ambientModules = program.getTypeChecker().getAmbientModules().map((mod) => stripQuotes(mod.getName())); - const result = sortAndDeduplicate(flatMap(sourceFiles, (sourceFile) => extractUnresolvedImportsFromSourceFile( - program, - sourceFile, - ambientModules, - cachedUnresolvedImportsPerFile - ))); - (_b = tracing) == null ? void 0 : _b.pop(); - return result; -} -function extractUnresolvedImportsFromSourceFile(program, file, ambientModules, cachedUnresolvedImportsPerFile) { - return getOrUpdate(cachedUnresolvedImportsPerFile, file.path, () => { - let unresolvedImports; - program.forEachResolvedModule(({ resolvedModule }, name) => { - if ((!resolvedModule || !resolutionExtensionIsTSOrJson(resolvedModule.extension)) && !isExternalModuleNameRelative(name) && !ambientModules.some((m) => m === name)) { - unresolvedImports = append(unresolvedImports, parsePackageName(name).packageName); - } - }, file); - return unresolvedImports || emptyArray2; - }); -} -var InferredProject2 = class extends Project2 { - /** @internal */ - constructor(projectService, documentRegistry, compilerOptions, watchOptions, projectRootPath, currentDirectory, typeAcquisition) { - super( - projectService.newInferredProjectName(), - 0 /* Inferred */, - projectService, - documentRegistry, - // TODO: GH#18217 - /*files*/ - void 0, - /*lastFileExceededProgramSize*/ - void 0, - compilerOptions, - /*compileOnSaveEnabled*/ - false, - watchOptions, - projectService.host, - currentDirectory - ); - this._isJsInferredProject = false; - this.typeAcquisition = typeAcquisition; - this.projectRootPath = projectRootPath && projectService.toCanonicalFileName(projectRootPath); - if (!projectRootPath && !projectService.useSingleInferredProject) { - this.canonicalCurrentDirectory = projectService.toCanonicalFileName(this.currentDirectory); - } - this.enableGlobalPlugins(this.getCompilerOptions()); - } - toggleJsInferredProject(isJsInferredProject) { - if (isJsInferredProject !== this._isJsInferredProject) { - this._isJsInferredProject = isJsInferredProject; - this.setCompilerOptions(); - } - } - setCompilerOptions(options) { - if (!options && !this.getCompilationSettings()) { - return; - } - const newOptions = cloneCompilerOptions(options || this.getCompilationSettings()); - if (this._isJsInferredProject && typeof newOptions.maxNodeModuleJsDepth !== "number") { - newOptions.maxNodeModuleJsDepth = 2; - } else if (!this._isJsInferredProject) { - newOptions.maxNodeModuleJsDepth = void 0; - } - newOptions.allowJs = true; - super.setCompilerOptions(newOptions); - } - addRoot(info) { - Debug.assert(info.isScriptOpen()); - this.projectService.startWatchingConfigFilesForInferredProjectRoot(info); - if (!this._isJsInferredProject && info.isJavaScript()) { - this.toggleJsInferredProject( - /*isJsInferredProject*/ - true - ); - } else if (this.isOrphan() && this._isJsInferredProject && !info.isJavaScript()) { - this.toggleJsInferredProject( - /*isJsInferredProject*/ - false - ); - } - super.addRoot(info); - } - removeRoot(info) { - this.projectService.stopWatchingConfigFilesForScriptInfo(info); - super.removeRoot(info); - if (!this.isOrphan() && this._isJsInferredProject && info.isJavaScript()) { - if (every(this.getRootScriptInfos(), (rootInfo) => !rootInfo.isJavaScript())) { - this.toggleJsInferredProject( - /*isJsInferredProject*/ - false - ); - } - } - } - /** @internal */ - isOrphan() { - return !this.hasRoots(); - } - isProjectWithSingleRoot() { - return !this.projectRootPath && !this.projectService.useSingleInferredProject || this.getRootScriptInfos().length === 1; - } - close() { - forEach(this.getRootScriptInfos(), (info) => this.projectService.stopWatchingConfigFilesForScriptInfo(info)); - super.close(); - } - getTypeAcquisition() { - return this.typeAcquisition || { - enable: allRootFilesAreJsOrDts(this), - include: emptyArray, - exclude: emptyArray - }; - } -}; -var AuxiliaryProject = class extends Project2 { - constructor(projectService, documentRegistry, compilerOptions, currentDirectory) { - super( - projectService.newAuxiliaryProjectName(), - 4 /* Auxiliary */, - projectService, - documentRegistry, - /*hasExplicitListOfFiles*/ - false, - /*lastFileExceededProgramSize*/ - void 0, - compilerOptions, - /*compileOnSaveEnabled*/ - false, - /*watchOptions*/ - void 0, - projectService.host, - currentDirectory - ); - } - isOrphan() { - return true; - } - scheduleInvalidateResolutionsOfFailedLookupLocations() { - return; - } -}; -var _AutoImportProviderProject = class _AutoImportProviderProject extends Project2 { - /** @internal */ - constructor(hostProject, initialRootNames, documentRegistry, compilerOptions) { - super( - hostProject.projectService.newAutoImportProviderProjectName(), - 3 /* AutoImportProvider */, - hostProject.projectService, - documentRegistry, - /*hasExplicitListOfFiles*/ - false, - /*lastFileExceededProgramSize*/ - void 0, - compilerOptions, - /*compileOnSaveEnabled*/ - false, - hostProject.getWatchOptions(), - hostProject.projectService.host, - hostProject.currentDirectory - ); - this.hostProject = hostProject; - this.rootFileNames = initialRootNames; - this.useSourceOfProjectReferenceRedirect = maybeBind(this.hostProject, this.hostProject.useSourceOfProjectReferenceRedirect); - this.getParsedCommandLine = maybeBind(this.hostProject, this.hostProject.getParsedCommandLine); - } - /** @internal */ - static getRootFileNames(dependencySelection, hostProject, host, compilerOptions) { - var _a, _b; - if (!dependencySelection) { - return emptyArray; - } - const program = hostProject.getCurrentProgram(); - if (!program) { - return emptyArray; - } - const start = timestamp(); - let dependencyNames; - let rootNames; - const rootFileName = combinePaths(hostProject.currentDirectory, inferredTypesContainingFile); - const packageJsons = hostProject.getPackageJsonsForAutoImport(combinePaths(hostProject.currentDirectory, rootFileName)); - for (const packageJson of packageJsons) { - (_a = packageJson.dependencies) == null ? void 0 : _a.forEach((_, dependenyName) => addDependency(dependenyName)); - (_b = packageJson.peerDependencies) == null ? void 0 : _b.forEach((_, dependencyName) => addDependency(dependencyName)); - } - let dependenciesAdded = 0; - if (dependencyNames) { - const symlinkCache = hostProject.getSymlinkCache(); - for (const name of arrayFrom(dependencyNames.keys())) { - if (dependencySelection === 2 /* Auto */ && dependenciesAdded > this.maxDependencies) { - hostProject.log(`AutoImportProviderProject: attempted to add more than ${this.maxDependencies} dependencies. Aborting.`); - return emptyArray; - } - const packageJson = resolvePackageNameToPackageJson( - name, - hostProject.currentDirectory, - compilerOptions, - host, - program.getModuleResolutionCache() - ); - if (packageJson) { - const entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache); - if (entrypoints) { - dependenciesAdded += addRootNames(entrypoints); - continue; - } - } - const done = forEach([hostProject.currentDirectory, hostProject.getGlobalTypingsCacheLocation()], (directory) => { - if (directory) { - const typesPackageJson = resolvePackageNameToPackageJson( - `@types/${name}`, - directory, - compilerOptions, - host, - program.getModuleResolutionCache() - ); - if (typesPackageJson) { - const entrypoints = getRootNamesFromPackageJson(typesPackageJson, program, symlinkCache); - dependenciesAdded += addRootNames(entrypoints); - return true; - } - } - }); - if (done) continue; - if (packageJson && compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) { - const entrypoints = getRootNamesFromPackageJson( - packageJson, - program, - symlinkCache, - /*resolveJs*/ - true - ); - dependenciesAdded += addRootNames(entrypoints); - } - } - } - const references = program.getResolvedProjectReferences(); - let referencesAddded = 0; - if ((references == null ? void 0 : references.length) && hostProject.projectService.getHostPreferences().includeCompletionsForModuleExports) { - references.forEach((ref) => { - if (ref == null ? void 0 : ref.commandLine.options.outFile) { - referencesAddded += addRootNames(filterEntrypoints([ - changeExtension(ref.commandLine.options.outFile, ".d.ts") - ])); - } else if (ref) { - const getCommonSourceDirectory2 = memoize( - () => getCommonSourceDirectoryOfConfig( - ref.commandLine, - !hostProject.useCaseSensitiveFileNames() - ) - ); - referencesAddded += addRootNames(filterEntrypoints(mapDefined( - ref.commandLine.fileNames, - (fileName) => !isDeclarationFileName(fileName) && !fileExtensionIs(fileName, ".json" /* Json */) && !program.getSourceFile(fileName) ? getOutputDeclarationFileName( - fileName, - ref.commandLine, - !hostProject.useCaseSensitiveFileNames(), - getCommonSourceDirectory2 - ) : void 0 - ))); - } - }); - } - if (rootNames == null ? void 0 : rootNames.size) { - hostProject.log(`AutoImportProviderProject: found ${rootNames.size} root files in ${dependenciesAdded} dependencies ${referencesAddded} referenced projects in ${timestamp() - start} ms`); - } - return rootNames ? arrayFrom(rootNames.values()) : emptyArray; - function addRootNames(entrypoints) { - if (!(entrypoints == null ? void 0 : entrypoints.length)) return 0; - rootNames ?? (rootNames = /* @__PURE__ */ new Set()); - entrypoints.forEach((entry) => rootNames.add(entry)); - return 1; - } - function addDependency(dependency) { - if (!startsWith(dependency, "@types/")) { - (dependencyNames || (dependencyNames = /* @__PURE__ */ new Set())).add(dependency); - } - } - function getRootNamesFromPackageJson(packageJson, program2, symlinkCache, resolveJs) { - var _a2; - const entrypoints = getEntrypointsFromPackageJsonInfo( - packageJson, - compilerOptions, - host, - program2.getModuleResolutionCache(), - resolveJs - ); - if (entrypoints) { - const real = (_a2 = host.realpath) == null ? void 0 : _a2.call(host, packageJson.packageDirectory); - const realPath2 = real ? hostProject.toPath(real) : void 0; - const isSymlink = realPath2 && realPath2 !== hostProject.toPath(packageJson.packageDirectory); - if (isSymlink) { - symlinkCache.setSymlinkedDirectory(packageJson.packageDirectory, { - real: ensureTrailingDirectorySeparator(real), - realPath: ensureTrailingDirectorySeparator(realPath2) - }); - } - return filterEntrypoints(entrypoints, isSymlink ? (entrypoint) => entrypoint.replace(packageJson.packageDirectory, real) : void 0); - } - } - function filterEntrypoints(entrypoints, symlinkName) { - return mapDefined(entrypoints, (entrypoint) => { - const resolvedFileName = symlinkName ? symlinkName(entrypoint) : entrypoint; - if (!program.getSourceFile(resolvedFileName) && !(symlinkName && program.getSourceFile(entrypoint))) { - return resolvedFileName; - } - }); - } - } - /** @internal */ - static create(dependencySelection, hostProject, host, documentRegistry) { - if (dependencySelection === 0 /* Off */) { - return void 0; - } - const compilerOptions = { - ...hostProject.getCompilerOptions(), - ...this.compilerOptionsOverrides - }; - const rootNames = this.getRootFileNames(dependencySelection, hostProject, host, compilerOptions); - if (!rootNames.length) { - return void 0; - } - return new _AutoImportProviderProject(hostProject, rootNames, documentRegistry, compilerOptions); - } - /** @internal */ - isEmpty() { - return !some(this.rootFileNames); - } - /** @internal */ - isOrphan() { - return true; - } - updateGraph() { - let rootFileNames = this.rootFileNames; - if (!rootFileNames) { - rootFileNames = _AutoImportProviderProject.getRootFileNames( - this.hostProject.includePackageJsonAutoImports(), - this.hostProject, - this.hostProject.getHostForAutoImportProvider(), - this.getCompilationSettings() - ); - } - this.projectService.setFileNamesOfAutpImportProviderOrAuxillaryProject(this, rootFileNames); - this.rootFileNames = rootFileNames; - const oldProgram = this.getCurrentProgram(); - const hasSameSetOfFiles = super.updateGraph(); - if (oldProgram && oldProgram !== this.getCurrentProgram()) { - this.hostProject.clearCachedExportInfoMap(); - } - return hasSameSetOfFiles; - } - /** @internal */ - scheduleInvalidateResolutionsOfFailedLookupLocations() { - return; - } - hasRoots() { - var _a; - return !!((_a = this.rootFileNames) == null ? void 0 : _a.length); - } - /** @internal */ - markAsDirty() { - this.rootFileNames = void 0; - super.markAsDirty(); - } - getScriptFileNames() { - return this.rootFileNames || emptyArray; - } - getLanguageService() { - throw new Error("AutoImportProviderProject language service should never be used. To get the program, use `project.getCurrentProgram()`."); - } - /** @internal */ - onAutoImportProviderSettingsChanged() { - throw new Error("AutoImportProviderProject is an auto import provider; use `markAsDirty()` instead."); - } - /** @internal */ - onPackageJsonChange() { - throw new Error("package.json changes should be notified on an AutoImportProvider's host project"); - } - getHostForAutoImportProvider() { - throw new Error("AutoImportProviderProject cannot provide its own host; use `hostProject.getModuleResolutionHostForAutomImportProvider()` instead."); - } - getProjectReferences() { - return this.hostProject.getProjectReferences(); - } - /** @internal */ - includePackageJsonAutoImports() { - return 0 /* Off */; - } - /** @internal */ - getSymlinkCache() { - return this.hostProject.getSymlinkCache(); - } - /** @internal */ - getModuleResolutionCache() { - var _a; - return (_a = this.hostProject.getCurrentProgram()) == null ? void 0 : _a.getModuleResolutionCache(); - } -}; -_AutoImportProviderProject.maxDependencies = 10; -/** @internal */ -_AutoImportProviderProject.compilerOptionsOverrides = { - diagnostics: false, - skipLibCheck: true, - sourceMap: false, - types: emptyArray, - lib: emptyArray, - noLib: true -}; -var AutoImportProviderProject = _AutoImportProviderProject; -var ConfiguredProject2 = class extends Project2 { - /** @internal */ - constructor(configFileName, canonicalConfigFilePath, projectService, documentRegistry, cachedDirectoryStructureHost, pendingUpdateReason) { - super( - configFileName, - 1 /* Configured */, - projectService, - documentRegistry, - /*hasExplicitListOfFiles*/ - false, - /*lastFileExceededProgramSize*/ - void 0, - /*compilerOptions*/ - {}, - /*compileOnSaveEnabled*/ - false, - /*watchOptions*/ - void 0, - cachedDirectoryStructureHost, - getDirectoryPath(configFileName) - ); - this.canonicalConfigFilePath = canonicalConfigFilePath; - /** @internal */ - this.openFileWatchTriggered = /* @__PURE__ */ new Map(); - /** @internal */ - this.canConfigFileJsonReportNoInputFiles = false; - /** @internal */ - this.isInitialLoadPending = returnTrue; - /** @internal */ - this.sendLoadingProjectFinish = false; - this.pendingUpdateLevel = 2 /* Full */; - this.pendingUpdateReason = pendingUpdateReason; - } - /** @internal */ - setCompilerHost(host) { - this.compilerHost = host; - } - /** @internal */ - getCompilerHost() { - return this.compilerHost; - } - /** @internal */ - useSourceOfProjectReferenceRedirect() { - return this.languageServiceEnabled; - } - /** @internal */ - getParsedCommandLine(fileName) { - const configFileName = asNormalizedPath(normalizePath(fileName)); - const canonicalConfigFilePath = asNormalizedPath(this.projectService.toCanonicalFileName(configFileName)); - let configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo) { - this.projectService.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo = { exists: this.projectService.host.fileExists(configFileName) }); - } - this.projectService.ensureParsedConfigUptoDate(configFileName, canonicalConfigFilePath, configFileExistenceInfo, this); - if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */) { - this.projectService.watchWildcards(configFileName, configFileExistenceInfo, this); - } - return configFileExistenceInfo.exists ? configFileExistenceInfo.config.parsedCommandLine : void 0; - } - /** @internal */ - onReleaseParsedCommandLine(fileName) { - this.releaseParsedConfig(asNormalizedPath(this.projectService.toCanonicalFileName(asNormalizedPath(normalizePath(fileName))))); - } - releaseParsedConfig(canonicalConfigFilePath) { - this.projectService.stopWatchingWildCards(canonicalConfigFilePath, this); - this.projectService.releaseParsedConfig(canonicalConfigFilePath, this); - } - /** - * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph - * @returns: true if set of files in the project stays the same and false - otherwise. - */ - updateGraph() { - if (this.deferredClose) return false; - const isDirty = this.dirty; - this.isInitialLoadPending = returnFalse; - const updateLevel = this.pendingUpdateLevel; - this.pendingUpdateLevel = 0 /* Update */; - let result; - switch (updateLevel) { - case 1 /* RootNamesAndUpdate */: - this.openFileWatchTriggered.clear(); - result = this.projectService.reloadFileNamesOfConfiguredProject(this); - break; - case 2 /* Full */: - this.openFileWatchTriggered.clear(); - const reason = Debug.checkDefined(this.pendingUpdateReason); - this.projectService.reloadConfiguredProject(this, reason); - result = true; - break; - default: - result = super.updateGraph(); - } - this.compilerHost = void 0; - this.projectService.sendProjectLoadingFinishEvent(this); - this.projectService.sendProjectTelemetry(this); - if (updateLevel === 2 /* Full */ || // Already sent event through reload - result && // Not new program - (!isDirty || !this.triggerFileForConfigFileDiag || this.getCurrentProgram().structureIsReused === 2 /* Completely */)) { - this.triggerFileForConfigFileDiag = void 0; - } else if (!this.triggerFileForConfigFileDiag) { - this.projectService.sendConfigFileDiagEvent( - this, - /*triggerFile*/ - void 0, - /*force*/ - false - ); - } - return result; - } - /** @internal */ - getCachedDirectoryStructureHost() { - return this.directoryStructureHost; - } - getConfigFilePath() { - return asNormalizedPath(this.getProjectName()); - } - getProjectReferences() { - return this.projectReferences; - } - updateReferences(refs) { - this.projectReferences = refs; - this.potentialProjectReferences = void 0; - } - /** @internal */ - setPotentialProjectReference(canonicalConfigPath) { - Debug.assert(this.isInitialLoadPending()); - (this.potentialProjectReferences || (this.potentialProjectReferences = /* @__PURE__ */ new Set())).add(canonicalConfigPath); - } - /** @internal */ - getResolvedProjectReferenceToRedirect(fileName) { - const program = this.getCurrentProgram(); - return program && program.getResolvedProjectReferenceToRedirect(fileName); - } - /** @internal */ - forEachResolvedProjectReference(cb) { - var _a; - return (_a = this.getCurrentProgram()) == null ? void 0 : _a.forEachResolvedProjectReference(cb); - } - /** @internal */ - enablePluginsWithOptions(options) { - var _a; - this.plugins.length = 0; - if (!((_a = options.plugins) == null ? void 0 : _a.length) && !this.projectService.globalPlugins.length) return; - const host = this.projectService.host; - if (!host.require && !host.importPlugin) { - this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); - return; - } - const searchPaths = this.getGlobalPluginSearchPaths(); - if (this.projectService.allowLocalPluginLoads) { - const local = getDirectoryPath(this.canonicalConfigFilePath); - this.projectService.logger.info(`Local plugin loading enabled; adding ${local} to search paths`); - searchPaths.unshift(local); - } - if (options.plugins) { - for (const pluginConfigEntry of options.plugins) { - this.enablePlugin(pluginConfigEntry, searchPaths); - } - } - return this.enableGlobalPlugins(options); - } - /** - * Get the errors that dont have any file name associated - */ - getGlobalProjectErrors() { - return filter(this.projectErrors, (diagnostic) => !diagnostic.file) || emptyArray2; - } - /** - * Get all the project errors - */ - getAllProjectErrors() { - return this.projectErrors || emptyArray2; - } - setProjectErrors(projectErrors) { - this.projectErrors = projectErrors; - } - close() { - this.projectService.configFileExistenceInfoCache.forEach((_configFileExistenceInfo, canonicalConfigFilePath) => this.releaseParsedConfig(canonicalConfigFilePath)); - this.projectErrors = void 0; - this.openFileWatchTriggered.clear(); - this.compilerHost = void 0; - super.close(); - } - /** @internal */ - markAsDirty() { - if (this.deferredClose) return; - super.markAsDirty(); - } - /** @internal */ - isSolution() { - return this.getRootFilesMap().size === 0 && !this.canConfigFileJsonReportNoInputFiles; - } - /** @internal */ - isOrphan() { - return !!this.deferredClose; - } - getEffectiveTypeRoots() { - return getEffectiveTypeRoots(this.getCompilationSettings(), this) || []; - } - /** @internal */ - updateErrorOnNoInputFiles(fileNames) { - updateErrorForNoInputFiles(fileNames, this.getConfigFilePath(), this.getCompilerOptions().configFile.configFileSpecs, this.projectErrors, this.canConfigFileJsonReportNoInputFiles); - } -}; -var ExternalProject = class extends Project2 { - /** @internal */ - constructor(externalProjectName, projectService, documentRegistry, compilerOptions, lastFileExceededProgramSize, compileOnSaveEnabled, projectFilePath, watchOptions) { - super( - externalProjectName, - 2 /* External */, - projectService, - documentRegistry, - /*hasExplicitListOfFiles*/ - true, - lastFileExceededProgramSize, - compilerOptions, - compileOnSaveEnabled, - watchOptions, - projectService.host, - getDirectoryPath(projectFilePath || normalizeSlashes(externalProjectName)) - ); - this.externalProjectName = externalProjectName; - this.compileOnSaveEnabled = compileOnSaveEnabled; - this.excludedFiles = []; - this.enableGlobalPlugins(this.getCompilerOptions()); - } - updateGraph() { - const result = super.updateGraph(); - this.projectService.sendProjectTelemetry(this); - return result; - } - getExcludedFiles() { - return this.excludedFiles; - } -}; -function isInferredProject(project) { - return project.projectKind === 0 /* Inferred */; -} -function isConfiguredProject(project) { - return project.projectKind === 1 /* Configured */; -} -function isExternalProject(project) { - return project.projectKind === 2 /* External */; -} -function isBackgroundProject(project) { - return project.projectKind === 3 /* AutoImportProvider */ || project.projectKind === 4 /* Auxiliary */; -} -function isProjectDeferredClose(project) { - return isConfiguredProject(project) && !!project.deferredClose; -} - -// src/server/editorServices.ts -var maxProgramSizeForNonTsFiles = 20 * 1024 * 1024; -var maxFileSize = 4 * 1024 * 1024; -var ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground"; -var ProjectLoadingStartEvent = "projectLoadingStart"; -var ProjectLoadingFinishEvent = "projectLoadingFinish"; -var LargeFileReferencedEvent = "largeFileReferenced"; -var ConfigFileDiagEvent = "configFileDiag"; -var ProjectLanguageServiceStateEvent = "projectLanguageServiceState"; -var ProjectInfoTelemetryEvent = "projectInfo"; -var OpenFileInfoTelemetryEvent = "openFileInfo"; -var CreateFileWatcherEvent = "createFileWatcher"; -var CreateDirectoryWatcherEvent = "createDirectoryWatcher"; -var CloseFileWatcherEvent = "closeFileWatcher"; -var ensureProjectForOpenFileSchedule = "*ensureProjectForOpenFiles*"; -function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions) { - const map2 = /* @__PURE__ */ new Map(); - for (const option of commandLineOptions) { - if (typeof option.type === "object") { - const optionMap = option.type; - optionMap.forEach((value) => { - Debug.assert(typeof value === "number"); - }); - map2.set(option.name, optionMap); - } - } - return map2; -} -var compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations); -var watchOptionsConverters = prepareConvertersForEnumLikeCompilerOptions(optionsForWatch); -var indentStyle = new Map(Object.entries({ - none: 0 /* None */, - block: 1 /* Block */, - smart: 2 /* Smart */ -})); -var defaultTypeSafeList = { - "jquery": { - // jquery files can have names like "jquery-1.10.2.min.js" (or "jquery.intellisense.js") - match: /jquery(-[\d.]+)?(\.intellisense)?(\.min)?\.js$/i, - types: ["jquery"] - }, - "WinJS": { - // e.g. c:/temp/UWApp1/lib/winjs-4.0.1/js/base.js - match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i, - // If the winjs/base.js file is found.. - exclude: [["^", 1, "/.*"]], - // ..then exclude all files under the winjs folder - types: ["winjs"] - // And fetch the @types package for WinJS - }, - "Kendo": { - // e.g. /Kendo3/wwwroot/lib/kendo/kendo.all.min.js - match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i, - exclude: [["^", 1, "/.*"]], - types: ["kendo-ui"] - }, - "Office Nuget": { - // e.g. /scripts/Office/1/excel-15.debug.js - match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i, - // Office NuGet package is installed under a "1/office" folder - exclude: [["^", 1, "/.*"]], - // Exclude that whole folder if the file indicated above is found in it - types: ["office"] - // @types package to fetch instead - }, - "References": { - match: /^(.*\/_references\.js)$/i, - exclude: [["^", 1, "$"]] - } -}; -function convertFormatOptions(protocolOptions) { - if (isString(protocolOptions.indentStyle)) { - protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase()); - Debug.assert(protocolOptions.indentStyle !== void 0); - } - return protocolOptions; -} -function convertCompilerOptions(protocolOptions) { - compilerOptionConverters.forEach((mappedValues, id) => { - const propertyValue = protocolOptions[id]; - if (isString(propertyValue)) { - protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase()); - } - }); - return protocolOptions; -} -function convertWatchOptions(protocolOptions, currentDirectory) { - let watchOptions; - let errors; - optionsForWatch.forEach((option) => { - const propertyValue = protocolOptions[option.name]; - if (propertyValue === void 0) return; - const mappedValues = watchOptionsConverters.get(option.name); - (watchOptions || (watchOptions = {}))[option.name] = mappedValues ? isString(propertyValue) ? mappedValues.get(propertyValue.toLowerCase()) : propertyValue : convertJsonOption(option, propertyValue, currentDirectory || "", errors || (errors = [])); - }); - return watchOptions && { watchOptions, errors }; -} -function convertTypeAcquisition(protocolOptions) { - let result; - typeAcquisitionDeclarations.forEach((option) => { - const propertyValue = protocolOptions[option.name]; - if (propertyValue === void 0) return; - (result || (result = {}))[option.name] = propertyValue; - }); - return result; -} -function tryConvertScriptKindName(scriptKindName) { - return isString(scriptKindName) ? convertScriptKindName(scriptKindName) : scriptKindName; -} -function convertScriptKindName(scriptKindName) { - switch (scriptKindName) { - case "JS": - return 1 /* JS */; - case "JSX": - return 2 /* JSX */; - case "TS": - return 3 /* TS */; - case "TSX": - return 4 /* TSX */; - default: - return 0 /* Unknown */; - } -} -function convertUserPreferences(preferences) { - const { lazyConfiguredProjectsFromExternalProject: _, ...userPreferences } = preferences; - return userPreferences; -} -var fileNamePropertyReader = { - getFileName: (x) => x, - getScriptKind: (fileName, extraFileExtensions) => { - let result; - if (extraFileExtensions) { - const fileExtension = getAnyExtensionFromPath(fileName); - if (fileExtension) { - some(extraFileExtensions, (info) => { - if (info.extension === fileExtension) { - result = info.scriptKind; - return true; - } - return false; - }); - } - } - return result; - }, - hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, (ext) => ext.isMixedContent && fileExtensionIs(fileName, ext.extension)) -}; -var externalFilePropertyReader = { - getFileName: (x) => x.fileName, - getScriptKind: (x) => tryConvertScriptKindName(x.scriptKind), - // TODO: GH#18217 - hasMixedContent: (x) => !!x.hasMixedContent -}; -function findProjectByName(projectName, projects) { - for (const proj of projects) { - if (proj.getProjectName() === projectName) { - return proj; - } - } -} -var nullTypingsInstaller = { - isKnownTypesPackageName: returnFalse, - // Should never be called because we never provide a types registry. - installPackage: notImplemented, - enqueueInstallTypingsRequest: noop, - attach: noop, - onProjectClosed: noop, - globalTypingsCacheLocation: void 0 - // TODO: GH#18217 -}; -var noopConfigFileWatcher = { close: noop }; -function getConfigFileNameFromCache(info, cache) { - if (!cache || isAncestorConfigFileInfo(info)) return void 0; - return cache.get(info.path); -} -function isOpenScriptInfo(infoOrFileNameOrConfig) { - return !!infoOrFileNameOrConfig.containingProjects; -} -function isAncestorConfigFileInfo(infoOrFileNameOrConfig) { - return !!infoOrFileNameOrConfig.configFileInfo; -} -var ConfiguredProjectLoadKind = /* @__PURE__ */ ((ConfiguredProjectLoadKind2) => { - ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Find"] = 0] = "Find"; - ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Create"] = 1] = "Create"; - ConfiguredProjectLoadKind2[ConfiguredProjectLoadKind2["Reload"] = 2] = "Reload"; - return ConfiguredProjectLoadKind2; -})(ConfiguredProjectLoadKind || {}); -function forEachAncestorProject(info, project, cb, kind, reason, allowDeferredClosed, reloadedProjects, delayReloadedConfiguredProjects) { - while (true) { - if (!project.isInitialLoadPending() && (!project.getCompilerOptions().composite || project.getCompilerOptions().disableSolutionSearching)) return; - const configFileName = project.projectService.getConfigFileNameForFile({ - fileName: project.getConfigFilePath(), - path: info.path, - configFileInfo: true - }, kind === 0 /* Find */); - if (!configFileName) return; - const ancestor = project.projectService.findCreateOrReloadConfiguredProject( - configFileName, - kind, - reason, - allowDeferredClosed, - /*triggerFile*/ - void 0, - reloadedProjects, - /*delayLoad*/ - true, - delayReloadedConfiguredProjects - ); - if (!ancestor) return; - if (ancestor.project.isInitialLoadPending() && project.getCompilerOptions().composite) { - ancestor.project.setPotentialProjectReference(project.canonicalConfigFilePath); - } - const result = cb(ancestor.project); - if (result) return result; - project = ancestor.project; - } -} -function forEachResolvedProjectReferenceProject(project, fileName, cb, kind, reason, allowDeferredClosed, triggerFile, reloadedProjects) { - var _a; - const resolvedRefs = (_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(); - if (!resolvedRefs) return void 0; - const possibleDefaultRef = fileName ? project.getResolvedProjectReferenceToRedirect(fileName) : void 0; - if (possibleDefaultRef) { - const configFileName = toNormalizedPath(possibleDefaultRef.sourceFile.fileName); - const child = project.projectService.findConfiguredProjectByProjectName( - configFileName, - allowDeferredClosed - ); - if (child) { - const result = callbackWithProjectFoundUsingFind(child); - if (result) return result; - } else if (kind !== 0 /* Find */) { - const result = forEachResolvedProjectReferenceProjectWorker( - resolvedRefs, - project.getCompilerOptions(), - (ref, loadKind) => possibleDefaultRef === ref ? callback(ref, loadKind) : void 0, - kind, - project.projectService - ); - if (result) return result; - } - } - return forEachResolvedProjectReferenceProjectWorker( - resolvedRefs, - project.getCompilerOptions(), - (ref, loadKind) => possibleDefaultRef !== ref ? callback(ref, loadKind) : void 0, - kind, - project.projectService - ); - function callback(ref, loadKind) { - const result = project.projectService.findCreateOrReloadConfiguredProject( - toNormalizedPath(ref.sourceFile.fileName), - loadKind, - reason, - allowDeferredClosed, - triggerFile, - reloadedProjects - ); - return result && (loadKind === kind ? cb(result.project, result.sentConfigFileDiag) : callbackWithProjectFoundUsingFind(result.project)); - } - function callbackWithProjectFoundUsingFind(child) { - let sentConfigFileDiag = false; - switch (kind) { - case 1 /* Create */: - sentConfigFileDiag = updateConfiguredProject(child, triggerFile); - break; - case 2 /* Reload */: - sentConfigFileDiag = child.projectService.reloadConfiguredProjectClearingSemanticCache(child, reason, reloadedProjects); - break; - case 0 /* Find */: - break; - default: - Debug.assertNever(kind); - } - const result = cb(child, sentConfigFileDiag); - if (result) return result; - } -} -function forEachResolvedProjectReferenceProjectWorker(resolvedProjectReferences, parentOptions, cb, kind, projectService, seenResolvedRefs) { - const loadKind = parentOptions.disableReferencedProjectLoad ? 0 /* Find */ : kind; - return forEach(resolvedProjectReferences, (ref) => { - if (!ref) return void 0; - const configFileName = toNormalizedPath(ref.sourceFile.fileName); - const canonicalPath = projectService.toCanonicalFileName(configFileName); - const seenValue = seenResolvedRefs == null ? void 0 : seenResolvedRefs.get(canonicalPath); - if (seenValue !== void 0 && seenValue >= loadKind) { - return void 0; - } - const result = cb(ref, loadKind); - if (result) { - return result; - } - (seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Map())).set(canonicalPath, loadKind); - return ref.references && forEachResolvedProjectReferenceProjectWorker(ref.references, ref.commandLine.options, cb, loadKind, projectService, seenResolvedRefs); - }); -} -function forEachPotentialProjectReference(project, cb) { - return project.potentialProjectReferences && forEachKey(project.potentialProjectReferences, cb); -} -function forEachAnyProjectReferenceKind(project, cb, cbProjectRef, cbPotentialProjectRef) { - return project.getCurrentProgram() ? project.forEachResolvedProjectReference(cb) : project.isInitialLoadPending() ? forEachPotentialProjectReference(project, cbPotentialProjectRef) : forEach(project.getProjectReferences(), cbProjectRef); -} -function callbackRefProject(project, cb, refPath) { - const refProject = refPath && project.projectService.configuredProjects.get(refPath); - return refProject && cb(refProject); -} -function forEachReferencedProject(project, cb) { - return forEachAnyProjectReferenceKind( - project, - (resolvedRef) => callbackRefProject(project, cb, resolvedRef.sourceFile.path), - (projectRef) => callbackRefProject(project, cb, project.toPath(resolveProjectReferencePath(projectRef))), - (potentialProjectRef) => callbackRefProject(project, cb, potentialProjectRef) - ); -} -function getDetailWatchInfo(watchType, project) { - return `${isString(project) ? `Config: ${project} ` : project ? `Project: ${project.getProjectName()} ` : ""}WatchType: ${watchType}`; -} -function isScriptInfoWatchedFromNodeModules(info) { - return !info.isScriptOpen() && info.mTime !== void 0; -} -function updateProjectIfDirty(project) { - project.invalidateResolutionsOfFailedLookupLocations(); - return project.dirty && !project.updateGraph(); -} -function updateWithTriggerFile(project, triggerFile, isReload) { - if (!isReload) { - project.invalidateResolutionsOfFailedLookupLocations(); - if (!project.dirty) return false; - } - project.triggerFileForConfigFileDiag = triggerFile; - const updateLevel = project.pendingUpdateLevel; - project.updateGraph(); - if (!project.triggerFileForConfigFileDiag && !isReload) return updateLevel === 2 /* Full */; - const sent = project.projectService.sendConfigFileDiagEvent(project, triggerFile, isReload); - project.triggerFileForConfigFileDiag = void 0; - return sent; -} -function updateConfiguredProject(project, triggerFile) { - if (triggerFile) { - if (updateWithTriggerFile( - project, - triggerFile, - /*isReload*/ - false - )) return true; - } else { - updateProjectIfDirty(project); - } - return false; -} -function fileOpenReason(info) { - return `Creating possible configured project for ${info.fileName} to open`; -} -function reloadReason(reason) { - return `User requested reload projects: ${reason}`; -} -function setProjectOptionsUsed(project) { - if (isConfiguredProject(project)) { - project.projectOptions = true; - } -} -function createProjectNameFactoryWithCounter(nameFactory) { - let nextId = 1; - return () => nameFactory(nextId++); -} -function getHostWatcherMap() { - return { idToCallbacks: /* @__PURE__ */ new Map(), pathToId: /* @__PURE__ */ new Map() }; -} -function getCanUseWatchEvents(service, canUseWatchEvents) { - return !!canUseWatchEvents && !!service.eventHandler && !!service.session; -} -function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) { - if (!getCanUseWatchEvents(service, canUseWatchEvents)) return void 0; - const watchedFiles = getHostWatcherMap(); - const watchedDirectories = getHostWatcherMap(); - const watchedDirectoriesRecursive = getHostWatcherMap(); - let ids = 1; - service.session.addProtocolHandler("watchChange" /* WatchChange */, (req) => { - onWatchChange(req.arguments); - return { responseRequired: false }; - }); - return { - watchFile: watchFile2, - watchDirectory, - getCurrentDirectory: () => service.host.getCurrentDirectory(), - useCaseSensitiveFileNames: service.host.useCaseSensitiveFileNames - }; - function watchFile2(path, callback) { - return getOrCreateFileWatcher( - watchedFiles, - path, - callback, - (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path } }) - ); - } - function watchDirectory(path, callback, recursive) { - return getOrCreateFileWatcher( - recursive ? watchedDirectoriesRecursive : watchedDirectories, - path, - callback, - (id) => ({ - eventName: CreateDirectoryWatcherEvent, - data: { - id, - path, - recursive: !!recursive, - // Special case node_modules as we watch it for changes to closed script infos as well - ignoreUpdate: !path.endsWith("/node_modules") ? true : void 0 - } - }) - ); - } - function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path, callback, event) { - const key = service.toPath(path); - let id = pathToId.get(key); - if (!id) pathToId.set(key, id = ids++); - let callbacks = idToCallbacks.get(id); - if (!callbacks) { - idToCallbacks.set(id, callbacks = /* @__PURE__ */ new Set()); - service.eventHandler(event(id)); - } - callbacks.add(callback); - return { - close() { - const callbacks2 = idToCallbacks.get(id); - if (!(callbacks2 == null ? void 0 : callbacks2.delete(callback))) return; - if (callbacks2.size) return; - idToCallbacks.delete(id); - pathToId.delete(key); - service.eventHandler({ eventName: CloseFileWatcherEvent, data: { id } }); - } - }; - } - function onWatchChange(args) { - if (isArray(args)) args.forEach(onWatchChangeRequestArgs); - else onWatchChangeRequestArgs(args); - } - function onWatchChangeRequestArgs({ id, created, deleted, updated }) { - onWatchEventType(id, created, 0 /* Created */); - onWatchEventType(id, deleted, 2 /* Deleted */); - onWatchEventType(id, updated, 1 /* Changed */); - } - function onWatchEventType(id, paths, eventKind) { - if (!(paths == null ? void 0 : paths.length)) return; - forEachCallback(watchedFiles, id, paths, (callback, eventPath) => callback(eventPath, eventKind)); - forEachCallback(watchedDirectories, id, paths, (callback, eventPath) => callback(eventPath)); - forEachCallback(watchedDirectoriesRecursive, id, paths, (callback, eventPath) => callback(eventPath)); - } - function forEachCallback(hostWatcherMap, id, eventPaths, cb) { - var _a; - (_a = hostWatcherMap.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => { - eventPaths.forEach((eventPath) => cb(callback, normalizeSlashes(eventPath))); - }); - } -} -var _ProjectService = class _ProjectService { - constructor(opts) { - /** - * Container of all known scripts - * - * @internal - */ - this.filenameToScriptInfo = /* @__PURE__ */ new Map(); - this.nodeModulesWatchers = /* @__PURE__ */ new Map(); - /** - * Contains all the deleted script info's version information so that - * it does not reset when creating script info again - * (and could have potentially collided with version where contents mismatch) - */ - this.filenameToScriptInfoVersion = /* @__PURE__ */ new Map(); - // Set of all '.js' files ever opened. - this.allJsFilesForOpenFileTelemetry = /* @__PURE__ */ new Map(); - /** - * maps external project file name to list of config files that were the part of this project - */ - this.externalProjectToConfiguredProjectMap = /* @__PURE__ */ new Map(); - /** - * external projects (configuration and list of root files is not controlled by tsserver) - */ - this.externalProjects = []; - /** - * projects built from openFileRoots - */ - this.inferredProjects = []; - /** - * projects specified by a tsconfig.json file - */ - this.configuredProjects = /* @__PURE__ */ new Map(); - /** @internal */ - this.newInferredProjectName = createProjectNameFactoryWithCounter(makeInferredProjectName); - /** @internal */ - this.newAutoImportProviderProjectName = createProjectNameFactoryWithCounter(makeAutoImportProviderProjectName); - /** @internal */ - this.newAuxiliaryProjectName = createProjectNameFactoryWithCounter(makeAuxiliaryProjectName); - /** - * Open files: with value being project root path, and key being Path of the file that is open - */ - this.openFiles = /* @__PURE__ */ new Map(); - /** Config files looked up and cached config files for open script info */ - this.configFileForOpenFiles = /* @__PURE__ */ new Map(); - /** Set of open script infos that are root of inferred project */ - this.rootOfInferredProjects = /* @__PURE__ */ new Set(); - /** - * Map of open files that are opened without complete path but have projectRoot as current directory - */ - this.openFilesWithNonRootedDiskPath = /* @__PURE__ */ new Map(); - this.compilerOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(); - this.watchOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(); - this.typeAcquisitionForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map(); - /** - * Project size for configured or external projects - */ - this.projectToSizeMap = /* @__PURE__ */ new Map(); - /** - * This is a map of config file paths existence that doesnt need query to disk - * - The entry can be present because there is inferred project that needs to watch addition of config file to directory - * In this case the exists could be true/false based on config file is present or not - * - Or it is present if we have configured project open with config file at that location - * In this case the exists property is always true - * - * @internal - */ - this.configFileExistenceInfoCache = /* @__PURE__ */ new Map(); - this.safelist = defaultTypeSafeList; - this.legacySafelist = /* @__PURE__ */ new Map(); - this.pendingProjectUpdates = /* @__PURE__ */ new Map(); - /** @internal */ - this.pendingEnsureProjectForOpenFiles = false; - /** Tracks projects that we have already sent telemetry for. */ - this.seenProjects = /* @__PURE__ */ new Map(); - this.sharedExtendedConfigFileWatchers = /* @__PURE__ */ new Map(); - this.extendedConfigCache = /* @__PURE__ */ new Map(); - /** @internal */ - this.baseline = noop; - /** @internal */ - this.verifyDocumentRegistry = noop; - /** @internal */ - this.verifyProgram = noop; - /** @internal */ - this.onProjectCreation = noop; - var _a; - this.host = opts.host; - this.logger = opts.logger; - this.cancellationToken = opts.cancellationToken; - this.useSingleInferredProject = opts.useSingleInferredProject; - this.useInferredProjectPerProjectRoot = opts.useInferredProjectPerProjectRoot; - this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller; - this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds; - this.eventHandler = opts.eventHandler; - this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents; - this.globalPlugins = opts.globalPlugins || emptyArray2; - this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray2; - this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads; - this.typesMapLocation = opts.typesMapLocation === void 0 ? combinePaths(getDirectoryPath(this.getExecutingFilePath()), "typesMap.json") : opts.typesMapLocation; - this.session = opts.session; - this.jsDocParsingMode = opts.jsDocParsingMode; - if (opts.serverMode !== void 0) { - this.serverMode = opts.serverMode; - } else { - this.serverMode = 0 /* Semantic */; - } - if (this.host.realpath) { - this.realpathToScriptInfos = createMultiMap(); - } - this.currentDirectory = toNormalizedPath(this.host.getCurrentDirectory()); - this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames); - this.globalCacheLocationDirectoryPath = this.typingsInstaller.globalTypingsCacheLocation ? ensureTrailingDirectorySeparator(this.toPath(this.typingsInstaller.globalTypingsCacheLocation)) : void 0; - this.throttledOperations = new ThrottledOperations(this.host, this.logger); - if (this.typesMapLocation) { - this.loadTypesMap(); - } else { - this.logger.info("No types map provided; using the default"); - } - this.typingsInstaller.attach(this); - this.hostConfiguration = { - formatCodeOptions: getDefaultFormatCodeSettings(this.host.newLine), - preferences: emptyOptions, - hostInfo: "Unknown host", - extraFileExtensions: [] - }; - this.documentRegistry = createDocumentRegistryInternal(this.host.useCaseSensitiveFileNames, this.currentDirectory, this.jsDocParsingMode, this); - const watchLogLevel = this.logger.hasLevel(3 /* verbose */) ? 2 /* Verbose */ : this.logger.loggingEnabled() ? 1 /* TriggerOnly */ : 0 /* None */; - const log = watchLogLevel !== 0 /* None */ ? (s) => this.logger.info(s) : noop; - this.packageJsonCache = createPackageJsonCache(this); - this.watchFactory = this.serverMode !== 0 /* Semantic */ ? { - watchFile: returnNoopFileWatcher, - watchDirectory: returnNoopFileWatcher - } : getWatchFactory( - createWatchFactoryHostUsingWatchEvents(this, opts.canUseWatchEvents) || this.host, - watchLogLevel, - log, - getDetailWatchInfo - ); - this.canUseWatchEvents = getCanUseWatchEvents(this, opts.canUseWatchEvents); - (_a = opts.incrementalVerifier) == null ? void 0 : _a.call(opts, this); - } - toPath(fileName) { - return toPath(fileName, this.currentDirectory, this.toCanonicalFileName); - } - /** @internal */ - getExecutingFilePath() { - return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath()); - } - /** @internal */ - getNormalizedAbsolutePath(fileName) { - return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory()); - } - /** @internal */ - setDocument(key, path, sourceFile) { - const info = Debug.checkDefined(this.getScriptInfoForPath(path)); - info.cacheSourceFile = { key, sourceFile }; - } - /** @internal */ - getDocument(key, path) { - const info = this.getScriptInfoForPath(path); - return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0; - } - /** @internal */ - ensureInferredProjectsUpToDate_TestOnly() { - this.ensureProjectStructuresUptoDate(); - } - /** @internal */ - getCompilerOptionsForInferredProjects() { - return this.compilerOptionsForInferredProjects; - } - /** @internal */ - onUpdateLanguageServiceStateForProject(project, languageServiceEnabled) { - if (!this.eventHandler) { - return; - } - const event = { - eventName: ProjectLanguageServiceStateEvent, - data: { project, languageServiceEnabled } - }; - this.eventHandler(event); - } - loadTypesMap() { - try { - const fileContent = this.host.readFile(this.typesMapLocation); - if (fileContent === void 0) { - this.logger.info(`Provided types map file "${this.typesMapLocation}" doesn't exist`); - return; - } - const raw = JSON.parse(fileContent); - for (const k of Object.keys(raw.typesMap)) { - raw.typesMap[k].match = new RegExp(raw.typesMap[k].match, "i"); - } - this.safelist = raw.typesMap; - for (const key in raw.simpleMap) { - if (hasProperty(raw.simpleMap, key)) { - this.legacySafelist.set(key, raw.simpleMap[key].toLowerCase()); - } - } - } catch (e) { - this.logger.info(`Error loading types map: ${e}`); - this.safelist = defaultTypeSafeList; - this.legacySafelist.clear(); - } - } - // eslint-disable-line @typescript-eslint/unified-signatures - updateTypingsForProject(response) { - const project = this.findProject(response.projectName); - if (!project) { - return; - } - switch (response.kind) { - case ActionSet: - project.updateTypingFiles( - response.compilerOptions, - response.typeAcquisition, - response.unresolvedImports, - response.typings - ); - return; - case ActionInvalidate: - project.enqueueInstallTypingsForProject( - /*forceRefresh*/ - true - ); - return; - } - } - /** @internal */ - watchTypingLocations(response) { - var _a; - (_a = this.findProject(response.projectName)) == null ? void 0 : _a.watchTypingLocations(response.files); - } - /** @internal */ - delayEnsureProjectForOpenFiles() { - if (!this.openFiles.size) return; - this.pendingEnsureProjectForOpenFiles = true; - this.throttledOperations.schedule( - ensureProjectForOpenFileSchedule, - /*delay*/ - 2500, - () => { - if (this.pendingProjectUpdates.size !== 0) { - this.delayEnsureProjectForOpenFiles(); - } else { - if (this.pendingEnsureProjectForOpenFiles) { - this.ensureProjectForOpenFiles(); - this.sendProjectsUpdatedInBackgroundEvent(); - } - } - } - ); - } - delayUpdateProjectGraph(project) { - if (isProjectDeferredClose(project)) return; - project.markAsDirty(); - if (isBackgroundProject(project)) return; - const projectName = project.getProjectName(); - this.pendingProjectUpdates.set(projectName, project); - this.throttledOperations.schedule( - projectName, - /*delay*/ - 250, - () => { - if (this.pendingProjectUpdates.delete(projectName)) { - updateProjectIfDirty(project); - } - } - ); - } - /** @internal */ - hasPendingProjectUpdate(project) { - return this.pendingProjectUpdates.has(project.getProjectName()); - } - /** @internal */ - sendProjectsUpdatedInBackgroundEvent() { - if (!this.eventHandler) { - return; - } - const event = { - eventName: ProjectsUpdatedInBackgroundEvent, - data: { - openFiles: arrayFrom(this.openFiles.keys(), (path) => this.getScriptInfoForPath(path).fileName) - } - }; - this.eventHandler(event); - } - /** @internal */ - sendLargeFileReferencedEvent(file, fileSize) { - if (!this.eventHandler) { - return; - } - const event = { - eventName: LargeFileReferencedEvent, - data: { file, fileSize, maxFileSize } - }; - this.eventHandler(event); - } - /** @internal */ - sendProjectLoadingStartEvent(project, reason) { - if (!this.eventHandler) { - return; - } - project.sendLoadingProjectFinish = true; - const event = { - eventName: ProjectLoadingStartEvent, - data: { project, reason } - }; - this.eventHandler(event); - } - /** @internal */ - sendProjectLoadingFinishEvent(project) { - if (!this.eventHandler || !project.sendLoadingProjectFinish) { - return; - } - project.sendLoadingProjectFinish = false; - const event = { - eventName: ProjectLoadingFinishEvent, - data: { project } - }; - this.eventHandler(event); - } - /** @internal */ - sendPerformanceEvent(kind, durationMs) { - if (this.performanceEventHandler) { - this.performanceEventHandler({ kind, durationMs }); - } - } - /** @internal */ - delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project) { - this.delayUpdateProjectGraph(project); - this.delayEnsureProjectForOpenFiles(); - } - delayUpdateProjectGraphs(projects, clearSourceMapperCache) { - if (projects.length) { - for (const project of projects) { - if (clearSourceMapperCache) project.clearSourceMapperCache(); - this.delayUpdateProjectGraph(project); - } - this.delayEnsureProjectForOpenFiles(); - } - } - setCompilerOptionsForInferredProjects(projectCompilerOptions, projectRootPath) { - Debug.assert(projectRootPath === void 0 || this.useInferredProjectPerProjectRoot, "Setting compiler options per project root path is only supported when useInferredProjectPerProjectRoot is enabled"); - const compilerOptions = convertCompilerOptions(projectCompilerOptions); - const watchOptions = convertWatchOptions(projectCompilerOptions, projectRootPath); - const typeAcquisition = convertTypeAcquisition(projectCompilerOptions); - compilerOptions.allowNonTsExtensions = true; - const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath); - if (canonicalProjectRootPath) { - this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions); - this.watchOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, watchOptions || false); - this.typeAcquisitionForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, typeAcquisition); - } else { - this.compilerOptionsForInferredProjects = compilerOptions; - this.watchOptionsForInferredProjects = watchOptions; - this.typeAcquisitionForInferredProjects = typeAcquisition; - } - for (const project of this.inferredProjects) { - if (canonicalProjectRootPath ? project.projectRootPath === canonicalProjectRootPath : !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) { - project.setCompilerOptions(compilerOptions); - project.setTypeAcquisition(typeAcquisition); - project.setWatchOptions(watchOptions == null ? void 0 : watchOptions.watchOptions); - project.setProjectErrors(watchOptions == null ? void 0 : watchOptions.errors); - project.compileOnSaveEnabled = compilerOptions.compileOnSave; - project.markAsDirty(); - this.delayUpdateProjectGraph(project); - } - } - this.delayEnsureProjectForOpenFiles(); - } - findProject(projectName) { - if (projectName === void 0) { - return void 0; - } - if (isInferredProjectName(projectName)) { - return findProjectByName(projectName, this.inferredProjects); - } - return this.findExternalProjectByProjectName(projectName) || this.findConfiguredProjectByProjectName(toNormalizedPath(projectName)); - } - /** @internal */ - forEachProject(cb) { - this.externalProjects.forEach(cb); - this.configuredProjects.forEach(cb); - this.inferredProjects.forEach(cb); - } - /** @internal */ - forEachEnabledProject(cb) { - this.forEachProject((project) => { - if (!project.isOrphan() && project.languageServiceEnabled) { - cb(project); - } - }); - } - getDefaultProjectForFile(fileName, ensureProject) { - return ensureProject ? this.ensureDefaultProjectForFile(fileName) : this.tryGetDefaultProjectForFile(fileName); - } - /** @internal */ - tryGetDefaultProjectForFile(fileNameOrScriptInfo) { - const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo; - return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : void 0; - } - /** - * If there is default project calculation pending for this file, - * then it completes that calculation so that correct default project is used for the project - */ - tryGetDefaultProjectForEnsuringConfiguredProjectForFile(fileNameOrScriptInfo) { - var _a; - const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo; - if (!scriptInfo) return void 0; - if ((_a = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a.delete(scriptInfo.path)) { - this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( - scriptInfo, - 1 /* Create */ - ); - if (scriptInfo.isOrphan()) { - this.assignOrphanScriptInfoToInferredProject(scriptInfo, this.openFiles.get(scriptInfo.path)); - } - } - return this.tryGetDefaultProjectForFile(scriptInfo); - } - /** @internal */ - ensureDefaultProjectForFile(fileNameOrScriptInfo) { - return this.tryGetDefaultProjectForEnsuringConfiguredProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo); - } - doEnsureDefaultProjectForFile(fileNameOrScriptInfo) { - this.ensureProjectStructuresUptoDate(); - const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo; - return scriptInfo ? scriptInfo.getDefaultProject() : (this.logErrorForScriptInfoNotFound(isString(fileNameOrScriptInfo) ? fileNameOrScriptInfo : fileNameOrScriptInfo.fileName), Errors.ThrowNoProject()); - } - getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName) { - this.ensureProjectStructuresUptoDate(); - return this.getScriptInfo(uncheckedFileName); - } - /** - * Ensures the project structures are upto date - * This means, - * - we go through all the projects and update them if they are dirty - * - if updates reflect some change in structure or there was pending request to ensure projects for open files - * ensure that each open script info has project - */ - ensureProjectStructuresUptoDate() { - let hasChanges = this.pendingEnsureProjectForOpenFiles; - this.pendingProjectUpdates.clear(); - const updateGraph = (project) => { - hasChanges = updateProjectIfDirty(project) || hasChanges; - }; - this.externalProjects.forEach(updateGraph); - this.configuredProjects.forEach(updateGraph); - this.inferredProjects.forEach(updateGraph); - if (hasChanges) { - this.ensureProjectForOpenFiles(); - } - } - getFormatCodeOptions(file) { - const info = this.getScriptInfoForNormalizedPath(file); - return info && info.getFormatCodeSettings() || this.hostConfiguration.formatCodeOptions; - } - getPreferences(file) { - const info = this.getScriptInfoForNormalizedPath(file); - return { ...this.hostConfiguration.preferences, ...info && info.getPreferences() }; - } - getHostFormatCodeOptions() { - return this.hostConfiguration.formatCodeOptions; - } - getHostPreferences() { - return this.hostConfiguration.preferences; - } - onSourceFileChanged(info, eventKind) { - Debug.assert(!info.isScriptOpen()); - if (eventKind === 2 /* Deleted */) { - this.handleDeletedFile( - info, - /*deferredDelete*/ - true - ); - } else { - if (info.deferredDelete) info.deferredDelete = void 0; - info.delayReloadNonMixedContentFile(); - this.delayUpdateProjectGraphs( - info.containingProjects, - /*clearSourceMapperCache*/ - false - ); - this.handleSourceMapProjects(info); - } - } - handleSourceMapProjects(info) { - if (info.sourceMapFilePath) { - if (isString(info.sourceMapFilePath)) { - const sourceMapFileInfo = this.getScriptInfoForPath(info.sourceMapFilePath); - this.delayUpdateSourceInfoProjects(sourceMapFileInfo == null ? void 0 : sourceMapFileInfo.sourceInfos); - } else { - this.delayUpdateSourceInfoProjects(info.sourceMapFilePath.sourceInfos); - } - } - this.delayUpdateSourceInfoProjects(info.sourceInfos); - if (info.declarationInfoPath) { - this.delayUpdateProjectsOfScriptInfoPath(info.declarationInfoPath); - } - } - delayUpdateSourceInfoProjects(sourceInfos) { - if (sourceInfos) { - sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path)); - } - } - delayUpdateProjectsOfScriptInfoPath(path) { - const info = this.getScriptInfoForPath(path); - if (info) { - this.delayUpdateProjectGraphs( - info.containingProjects, - /*clearSourceMapperCache*/ - true - ); - } - } - handleDeletedFile(info, deferredDelete) { - Debug.assert(!info.isScriptOpen()); - this.delayUpdateProjectGraphs( - info.containingProjects, - /*clearSourceMapperCache*/ - false - ); - this.handleSourceMapProjects(info); - info.detachAllProjects(); - if (deferredDelete) { - info.delayReloadNonMixedContentFile(); - info.deferredDelete = true; - } else { - this.deleteScriptInfo(info); - } - } - /** - * This is to watch whenever files are added or removed to the wildcard directories - */ - watchWildcardDirectory(directory, flags, configFileName, config) { - let watcher = this.watchFactory.watchDirectory( - directory, - (fileOrDirectory) => this.onWildCardDirectoryWatcherInvoke( - directory, - configFileName, - config, - result, - fileOrDirectory - ), - flags, - this.getWatchOptionsFromProjectWatchOptions(config.parsedCommandLine.watchOptions, getDirectoryPath(configFileName)), - WatchType.WildcardDirectory, - configFileName - ); - const result = { - packageJsonWatches: void 0, - close() { - var _a; - if (watcher) { - watcher.close(); - watcher = void 0; - (_a = result.packageJsonWatches) == null ? void 0 : _a.forEach((watcher2) => { - watcher2.projects.delete(result); - watcher2.close(); - }); - result.packageJsonWatches = void 0; - } - } - }; - return result; - } - onWildCardDirectoryWatcherInvoke(directory, configFileName, config, wildCardWatcher, fileOrDirectory) { - const fileOrDirectoryPath = this.toPath(fileOrDirectory); - const fsResult = config.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); - if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) && (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectory))) { - const file = this.getNormalizedAbsolutePath(fileOrDirectory); - this.logger.info(`Config: ${configFileName} Detected new package.json: ${file}`); - this.packageJsonCache.addOrUpdate(file, fileOrDirectoryPath); - this.watchPackageJsonFile(file, fileOrDirectoryPath, wildCardWatcher); - } - if (!(fsResult == null ? void 0 : fsResult.fileExists)) { - this.sendSourceFileChange(fileOrDirectoryPath); - } - const configuredProjectForConfig = this.findConfiguredProjectByProjectName(configFileName); - if (isIgnoredFileFromWildCardWatching({ - watchedDirPath: this.toPath(directory), - fileOrDirectory, - fileOrDirectoryPath, - configFileName, - extraFileExtensions: this.hostConfiguration.extraFileExtensions, - currentDirectory: this.currentDirectory, - options: config.parsedCommandLine.options, - program: (configuredProjectForConfig == null ? void 0 : configuredProjectForConfig.getCurrentProgram()) || config.parsedCommandLine.fileNames, - useCaseSensitiveFileNames: this.host.useCaseSensitiveFileNames, - writeLog: (s) => this.logger.info(s), - toPath: (s) => this.toPath(s), - getScriptKind: configuredProjectForConfig ? (fileName) => configuredProjectForConfig.getScriptKind(fileName) : void 0 - })) return; - if (config.updateLevel !== 2 /* Full */) config.updateLevel = 1 /* RootNamesAndUpdate */; - config.projects.forEach((watchWildcardDirectories, projectCanonicalPath) => { - var _a; - if (!watchWildcardDirectories) return; - const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath); - if (!project) return; - if (configuredProjectForConfig !== project && this.getHostPreferences().includeCompletionsForModuleExports) { - const path = this.toPath(configFileName); - if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path)) { - project.markAutoImportProviderAsDirty(); - } - } - const updateLevel = configuredProjectForConfig === project ? 1 /* RootNamesAndUpdate */ : 0 /* Update */; - if (project.pendingUpdateLevel > updateLevel) return; - if (this.openFiles.has(fileOrDirectoryPath)) { - const info = Debug.checkDefined(this.getScriptInfoForPath(fileOrDirectoryPath)); - if (info.isAttached(project)) { - const loadLevelToSet = Math.max(updateLevel, project.openFileWatchTriggered.get(fileOrDirectoryPath) || 0 /* Update */); - project.openFileWatchTriggered.set(fileOrDirectoryPath, loadLevelToSet); - } else { - project.pendingUpdateLevel = updateLevel; - this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project); - } - } else { - project.pendingUpdateLevel = updateLevel; - this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project); - } - }); - } - delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, loadReason) { - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!(configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config)) return false; - let scheduledAnyProjectUpdate = false; - configFileExistenceInfo.config.updateLevel = 2 /* Full */; - configFileExistenceInfo.config.projects.forEach((_watchWildcardDirectories, projectCanonicalPath) => { - var _a; - const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath); - if (!project) return; - scheduledAnyProjectUpdate = true; - if (projectCanonicalPath === canonicalConfigFilePath) { - if (project.isInitialLoadPending()) return; - project.pendingUpdateLevel = 2 /* Full */; - project.pendingUpdateReason = loadReason; - this.delayUpdateProjectGraph(project); - project.markAutoImportProviderAsDirty(); - } else { - const path = this.toPath(canonicalConfigFilePath); - project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path); - this.delayUpdateProjectGraph(project); - if (this.getHostPreferences().includeCompletionsForModuleExports && find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path)) { - project.markAutoImportProviderAsDirty(); - } - } - }); - return scheduledAnyProjectUpdate; - } - onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind) { - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - const project = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath); - const wasDefferedClose = project == null ? void 0 : project.deferredClose; - if (eventKind === 2 /* Deleted */) { - configFileExistenceInfo.exists = false; - if (project) project.deferredClose = true; - } else { - configFileExistenceInfo.exists = true; - if (wasDefferedClose) { - project.deferredClose = void 0; - project.markAsDirty(); - } - } - this.delayUpdateProjectsFromParsedConfigOnConfigFileChange( - canonicalConfigFilePath, - "Change in config file detected" - ); - const updatedProjects = new Set(project ? [project] : void 0); - this.openFiles.forEach((_projectRootPath, path) => { - var _a, _b; - const configFileForOpenFile = this.configFileForOpenFiles.get(path); - if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path))) return; - this.configFileForOpenFiles.delete(path); - const info = this.getScriptInfoForPath(path); - const newConfigFileNameForInfo = this.getConfigFileNameForFile( - info, - /*findFromCacheOnly*/ - false - ); - if (!newConfigFileNameForInfo) return; - const projectForInfo = this.findConfiguredProjectByProjectName(newConfigFileNameForInfo) ?? this.createConfiguredProject( - newConfigFileNameForInfo, - `Change in config file ${configFileName} detected, ${fileOpenReason(info)}` - ); - if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path))) { - (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path, configFileForOpenFile); - } - if (tryAddToSet(updatedProjects, projectForInfo) && projectForInfo.isInitialLoadPending()) { - this.delayUpdateProjectGraph(projectForInfo); - } - }); - this.delayEnsureProjectForOpenFiles(); - } - removeProject(project) { - this.logger.info("`remove Project::"); - project.print( - /*writeProjectFileNames*/ - true, - /*writeFileExplaination*/ - true, - /*writeFileVersionAndText*/ - false - ); - project.close(); - if (Debug.shouldAssert(1 /* Normal */)) { - this.filenameToScriptInfo.forEach( - (info) => Debug.assert( - !info.isAttached(project), - "Found script Info still attached to project", - () => `${project.projectName}: ScriptInfos still attached: ${JSON.stringify( - arrayFrom( - mapDefinedIterator( - this.filenameToScriptInfo.values(), - (info2) => info2.isAttached(project) ? { - fileName: info2.fileName, - projects: info2.containingProjects.map((p) => p.projectName), - hasMixedContent: info2.hasMixedContent - } : void 0 - ) - ), - /*replacer*/ - void 0, - " " - )}` - ) - ); - } - this.pendingProjectUpdates.delete(project.getProjectName()); - switch (project.projectKind) { - case 2 /* External */: - unorderedRemoveItem(this.externalProjects, project); - this.projectToSizeMap.delete(project.getProjectName()); - break; - case 1 /* Configured */: - this.configuredProjects.delete(project.canonicalConfigFilePath); - this.projectToSizeMap.delete(project.canonicalConfigFilePath); - break; - case 0 /* Inferred */: - unorderedRemoveItem(this.inferredProjects, project); - break; - } - } - /** @internal */ - assignOrphanScriptInfoToInferredProject(info, projectRootPath) { - Debug.assert(info.isOrphan()); - const project = this.getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) || this.getOrCreateSingleInferredProjectIfEnabled() || this.getOrCreateSingleInferredWithoutProjectRoot( - info.isDynamic ? projectRootPath || this.currentDirectory : getDirectoryPath( - isRootedDiskPath(info.fileName) ? info.fileName : getNormalizedAbsolutePath( - info.fileName, - projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory - ) - ) - ); - project.addRoot(info); - if (info.containingProjects[0] !== project) { - orderedRemoveItem(info.containingProjects, project); - info.containingProjects.unshift(project); - } - project.updateGraph(); - if (!this.useSingleInferredProject && !project.projectRootPath) { - for (const inferredProject of this.inferredProjects) { - if (inferredProject === project || inferredProject.isOrphan()) { - continue; - } - const roots = inferredProject.getRootScriptInfos(); - Debug.assert(roots.length === 1 || !!inferredProject.projectRootPath); - if (roots.length === 1 && forEach(roots[0].containingProjects, (p) => p !== roots[0].containingProjects[0] && !p.isOrphan())) { - inferredProject.removeFile( - roots[0], - /*fileExists*/ - true, - /*detachFromProject*/ - true - ); - } - } - } - return project; - } - assignOrphanScriptInfosToInferredProject() { - this.openFiles.forEach((projectRootPath, path) => { - const info = this.getScriptInfoForPath(path); - if (info.isOrphan()) { - this.assignOrphanScriptInfoToInferredProject(info, projectRootPath); - } - }); - } - /** - * Remove this file from the set of open, non-configured files. - * @param info The file that has been closed or newly configured - */ - closeOpenFile(info, skipAssignOrphanScriptInfosToInferredProject) { - var _a; - const fileExists = info.isDynamic ? false : this.host.fileExists(info.fileName); - info.close(fileExists); - this.stopWatchingConfigFilesForScriptInfo(info); - const canonicalFileName = this.toCanonicalFileName(info.fileName); - if (this.openFilesWithNonRootedDiskPath.get(canonicalFileName) === info) { - this.openFilesWithNonRootedDiskPath.delete(canonicalFileName); - } - let ensureProjectsForOpenFiles = false; - for (const p of info.containingProjects) { - if (isConfiguredProject(p)) { - if (info.hasMixedContent) { - info.registerFileUpdate(); - } - const updateLevel = p.openFileWatchTriggered.get(info.path); - if (updateLevel !== void 0) { - p.openFileWatchTriggered.delete(info.path); - if (p.pendingUpdateLevel < updateLevel) { - p.pendingUpdateLevel = updateLevel; - p.markFileAsDirty(info.path); - } - } - } else if (isInferredProject(p) && p.isRoot(info)) { - if (p.isProjectWithSingleRoot()) { - ensureProjectsForOpenFiles = true; - } - p.removeFile( - info, - fileExists, - /*detachFromProject*/ - true - ); - } - if (!p.languageServiceEnabled) { - p.markAsDirty(); - } - } - this.openFiles.delete(info.path); - this.configFileForOpenFiles.delete(info.path); - (_a = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a.delete(info.path); - Debug.assert(!this.rootOfInferredProjects.has(info)); - if (!skipAssignOrphanScriptInfosToInferredProject && ensureProjectsForOpenFiles) { - this.assignOrphanScriptInfosToInferredProject(); - } - if (fileExists) { - this.watchClosedScriptInfo(info); - } else { - this.handleDeletedFile( - info, - /*deferredDelete*/ - false - ); - } - return ensureProjectsForOpenFiles; - } - deleteScriptInfo(info) { - Debug.assert(!info.isScriptOpen()); - this.filenameToScriptInfo.delete(info.path); - this.filenameToScriptInfoVersion.set(info.path, info.textStorage.version); - this.stopWatchingScriptInfo(info); - const realpath = info.getRealpathIfDifferent(); - if (realpath) { - this.realpathToScriptInfos.remove(realpath, info); - } - info.closeSourceMapFileWatcher(); - } - configFileExists(configFileName, canonicalConfigFilePath, info) { - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - let openFilesImpactedByConfigFile; - if (this.openFiles.has(info.path) && !isAncestorConfigFileInfo(info)) { - if (configFileExistenceInfo) (configFileExistenceInfo.openFilesImpactedByConfigFile ?? (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(info.path); - else (openFilesImpactedByConfigFile = /* @__PURE__ */ new Set()).add(info.path); - } - if (configFileExistenceInfo) return configFileExistenceInfo.exists; - const exists = this.host.fileExists(configFileName); - this.configFileExistenceInfoCache.set(canonicalConfigFilePath, { exists, openFilesImpactedByConfigFile }); - return exists; - } - createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, forProject) { - var _a, _b; - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo.watcher || configFileExistenceInfo.watcher === noopConfigFileWatcher) { - configFileExistenceInfo.watcher = this.watchFactory.watchFile( - configFileName, - (_fileName, eventKind) => this.onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind), - 2e3 /* High */, - this.getWatchOptionsFromProjectWatchOptions((_b = (_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config) == null ? void 0 : _a.parsedCommandLine) == null ? void 0 : _b.watchOptions, getDirectoryPath(configFileName)), - WatchType.ConfigFile, - forProject - ); - } - const projects = configFileExistenceInfo.config.projects; - projects.set(forProject.canonicalConfigFilePath, projects.get(forProject.canonicalConfigFilePath) || false); - } - /** @internal */ - releaseParsedConfig(canonicalConfigFilePath, forProject) { - var _a, _b, _c; - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!((_a = configFileExistenceInfo.config) == null ? void 0 : _a.projects.delete(forProject.canonicalConfigFilePath))) return; - if ((_b = configFileExistenceInfo.config) == null ? void 0 : _b.projects.size) return; - configFileExistenceInfo.config = void 0; - clearSharedExtendedConfigFileWatcher(canonicalConfigFilePath, this.sharedExtendedConfigFileWatchers); - Debug.checkDefined(configFileExistenceInfo.watcher); - if ((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) { - if (configFileExistenceInfo.inferredProjectRoots) { - if (!canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath)))) { - configFileExistenceInfo.watcher.close(); - configFileExistenceInfo.watcher = noopConfigFileWatcher; - } - } else { - configFileExistenceInfo.watcher.close(); - configFileExistenceInfo.watcher = void 0; - } - } else { - configFileExistenceInfo.watcher.close(); - this.configFileExistenceInfoCache.delete(canonicalConfigFilePath); - } - } - /** - * This is called on file close or when its removed from inferred project as root, - * so that we handle the watches and inferred project root data - * @internal - */ - stopWatchingConfigFilesForScriptInfo(info) { - if (this.serverMode !== 0 /* Semantic */) return; - const isRootOfInferredProject = this.rootOfInferredProjects.delete(info); - const isOpen = info.isScriptOpen(); - if (isOpen && !isRootOfInferredProject) return; - this.forEachConfigFileLocation(info, (canonicalConfigFilePath) => { - var _a, _b, _c; - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo) return; - if (isOpen) { - if (!((_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(info.path))) return; - } else { - if (!((_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.delete(info.path))) return; - } - if (isRootOfInferredProject) { - configFileExistenceInfo.inferredProjectRoots--; - if (configFileExistenceInfo.watcher && !configFileExistenceInfo.config && !configFileExistenceInfo.inferredProjectRoots) { - configFileExistenceInfo.watcher.close(); - configFileExistenceInfo.watcher = void 0; - } - } - if (!((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) && !configFileExistenceInfo.config) { - Debug.assert(!configFileExistenceInfo.watcher); - this.configFileExistenceInfoCache.delete(canonicalConfigFilePath); - } - }); - } - /** - * This is called by inferred project whenever script info is added as a root - * - * @internal - */ - startWatchingConfigFilesForInferredProjectRoot(info) { - if (this.serverMode !== 0 /* Semantic */) return; - Debug.assert(info.isScriptOpen()); - this.rootOfInferredProjects.add(info); - this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName) => { - let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo) { - configFileExistenceInfo = { exists: this.host.fileExists(configFileName), inferredProjectRoots: 1 }; - this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo); - } else { - configFileExistenceInfo.inferredProjectRoots = (configFileExistenceInfo.inferredProjectRoots ?? 0) + 1; - } - (configFileExistenceInfo.openFilesImpactedByConfigFile ?? (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Set())).add(info.path); - configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath))) ? this.watchFactory.watchFile( - configFileName, - (_filename, eventKind) => this.onConfigFileChanged(configFileName, canonicalConfigFilePath, eventKind), - 2e3 /* High */, - this.hostConfiguration.watchOptions, - WatchType.ConfigFileForInferredRoot - ) : noopConfigFileWatcher); - }); - } - /** - * This function tries to search for a tsconfig.json for the given file. - * This is different from the method the compiler uses because - * the compiler can assume it will always start searching in the - * current directory (the directory in which tsc was invoked). - * The server must start searching from the directory containing - * the newly opened file. - */ - forEachConfigFileLocation(info, action) { - if (this.serverMode !== 0 /* Semantic */) { - return void 0; - } - Debug.assert(!isOpenScriptInfo(info) || this.openFiles.has(info.path)); - const projectRootPath = this.openFiles.get(info.path); - const scriptInfo = Debug.checkDefined(this.getScriptInfo(info.path)); - if (scriptInfo.isDynamic) return void 0; - let searchPath = asNormalizedPath(getDirectoryPath(info.fileName)); - const isSearchPathInProjectRoot = () => containsPath(projectRootPath, searchPath, this.currentDirectory, !this.host.useCaseSensitiveFileNames); - const anySearchPathOk = !projectRootPath || !isSearchPathInProjectRoot(); - let searchInDirectory = !isAncestorConfigFileInfo(info); - do { - if (searchInDirectory) { - const canonicalSearchPath = normalizedPathToPath(searchPath, this.currentDirectory, this.toCanonicalFileName); - const tsconfigFileName = asNormalizedPath(combinePaths(searchPath, "tsconfig.json")); - let result = action(combinePaths(canonicalSearchPath, "tsconfig.json"), tsconfigFileName); - if (result) return tsconfigFileName; - const jsconfigFileName = asNormalizedPath(combinePaths(searchPath, "jsconfig.json")); - result = action(combinePaths(canonicalSearchPath, "jsconfig.json"), jsconfigFileName); - if (result) return jsconfigFileName; - if (isNodeModulesDirectory(canonicalSearchPath)) { - break; - } - } - const parentPath = asNormalizedPath(getDirectoryPath(searchPath)); - if (parentPath === searchPath) break; - searchPath = parentPath; - searchInDirectory = true; - } while (anySearchPathOk || isSearchPathInProjectRoot()); - return void 0; - } - /** @internal */ - findDefaultConfiguredProject(info) { - var _a; - return info.isScriptOpen() ? (_a = this.tryFindDefaultConfiguredProjectForOpenScriptInfo( - info, - 0 /* Find */ - )) == null ? void 0 : _a.defaultProject : void 0; - } - /** Get cached configFileName for scriptInfo or ancestor of open script info */ - getConfigFileNameForFileFromCache(info, lookInPendingFilesForValue) { - if (lookInPendingFilesForValue) { - const result = getConfigFileNameFromCache(info, this.pendingOpenFileProjectUpdates); - if (result !== void 0) return result; - } - return getConfigFileNameFromCache(info, this.configFileForOpenFiles); - } - /** Caches the configFilename for script info or ancestor of open script info */ - setConfigFileNameForFileInCache(info, configFileName) { - if (!this.openFiles.has(info.path)) return; - if (isAncestorConfigFileInfo(info)) return; - this.configFileForOpenFiles.set(info.path, configFileName || false); - } - /** - * This function tries to search for a tsconfig.json for the given file. - * This is different from the method the compiler uses because - * the compiler can assume it will always start searching in the - * current directory (the directory in which tsc was invoked). - * The server must start searching from the directory containing - * the newly opened file. - * If script info is passed in, it is asserted to be open script info - * otherwise just file name - * when findFromCacheOnly is true only looked up in cache instead of hitting disk to figure things out - * @internal - */ - getConfigFileNameForFile(info, findFromCacheOnly) { - const fromCache = this.getConfigFileNameForFileFromCache(info, findFromCacheOnly); - if (fromCache !== void 0) return fromCache || void 0; - if (findFromCacheOnly) return void 0; - const configFileName = this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName2) => this.configFileExists(configFileName2, canonicalConfigFilePath, info)); - this.logger.info(`getConfigFileNameForFile:: File: ${info.fileName} ProjectRootPath: ${this.openFiles.get(info.path)}:: Result: ${configFileName}`); - this.setConfigFileNameForFileInCache(info, configFileName); - return configFileName; - } - printProjects() { - if (!this.logger.hasLevel(1 /* normal */)) { - return; - } - this.logger.startGroup(); - this.externalProjects.forEach(printProjectWithoutFileNames); - this.configuredProjects.forEach(printProjectWithoutFileNames); - this.inferredProjects.forEach(printProjectWithoutFileNames); - this.logger.info("Open files: "); - this.openFiles.forEach((projectRootPath, path) => { - const info = this.getScriptInfoForPath(path); - this.logger.info(` FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`); - this.logger.info(` Projects: ${info.containingProjects.map((p) => p.getProjectName())}`); - }); - this.logger.endGroup(); - } - /** @internal */ - findConfiguredProjectByProjectName(configFileName, allowDeferredClosed) { - const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName)); - const result = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath); - return allowDeferredClosed ? result : !(result == null ? void 0 : result.deferredClose) ? result : void 0; - } - getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) { - return this.configuredProjects.get(canonicalConfigFilePath); - } - findExternalProjectByProjectName(projectFileName) { - return findProjectByName(projectFileName, this.externalProjects); - } - /** Get a filename if the language service exceeds the maximum allowed program size; otherwise returns undefined. */ - getFilenameForExceededTotalSizeLimitForNonTsFiles(name, options, fileNames, propertyReader) { - if (options && options.disableSizeLimit || !this.host.getFileSize) { - return; - } - let availableSpace = maxProgramSizeForNonTsFiles; - this.projectToSizeMap.set(name, 0); - this.projectToSizeMap.forEach((val) => availableSpace -= val || 0); - let totalNonTsFileSize = 0; - for (const f of fileNames) { - const fileName = propertyReader.getFileName(f); - if (hasTSFileExtension(fileName)) { - continue; - } - totalNonTsFileSize += this.host.getFileSize(fileName); - if (totalNonTsFileSize > maxProgramSizeForNonTsFiles || totalNonTsFileSize > availableSpace) { - const top5LargestFiles = fileNames.map((f2) => propertyReader.getFileName(f2)).filter((name2) => !hasTSFileExtension(name2)).map((name2) => ({ name: name2, size: this.host.getFileSize(name2) })).sort((a, b) => b.size - a.size).slice(0, 5); - this.logger.info(`Non TS file size exceeded limit (${totalNonTsFileSize}). Largest files: ${top5LargestFiles.map((file) => `${file.name}:${file.size}`).join(", ")}`); - return fileName; - } - } - this.projectToSizeMap.set(name, totalNonTsFileSize); - } - createExternalProject(projectFileName, files, options, typeAcquisition, excludedFiles) { - const compilerOptions = convertCompilerOptions(options); - const watchOptionsAndErrors = convertWatchOptions(options, getDirectoryPath(normalizeSlashes(projectFileName))); - const project = new ExternalProject( - projectFileName, - this, - this.documentRegistry, - compilerOptions, - /*lastFileExceededProgramSize*/ - this.getFilenameForExceededTotalSizeLimitForNonTsFiles(projectFileName, compilerOptions, files, externalFilePropertyReader), - options.compileOnSave === void 0 ? true : options.compileOnSave, - /*projectFilePath*/ - void 0, - watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions - ); - project.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors); - project.excludedFiles = excludedFiles; - this.addFilesToNonInferredProject(project, files, externalFilePropertyReader, typeAcquisition); - this.externalProjects.push(project); - return project; - } - /** @internal */ - sendProjectTelemetry(project) { - if (this.seenProjects.has(project.projectName)) { - setProjectOptionsUsed(project); - return; - } - this.seenProjects.set(project.projectName, true); - if (!this.eventHandler || !this.host.createSHA256Hash) { - setProjectOptionsUsed(project); - return; - } - const projectOptions = isConfiguredProject(project) ? project.projectOptions : void 0; - setProjectOptionsUsed(project); - const data = { - projectId: this.host.createSHA256Hash(project.projectName), - fileStats: countEachFileTypes( - project.getScriptInfos(), - /*includeSizes*/ - true - ), - compilerOptions: convertCompilerOptionsForTelemetry(project.getCompilationSettings()), - typeAcquisition: convertTypeAcquisition2(project.getTypeAcquisition()), - extends: projectOptions && projectOptions.configHasExtendsProperty, - files: projectOptions && projectOptions.configHasFilesProperty, - include: projectOptions && projectOptions.configHasIncludeProperty, - exclude: projectOptions && projectOptions.configHasExcludeProperty, - compileOnSave: project.compileOnSaveEnabled, - configFileName: configFileName(), - projectType: project instanceof ExternalProject ? "external" : "configured", - languageServiceEnabled: project.languageServiceEnabled, - version - }; - this.eventHandler({ eventName: ProjectInfoTelemetryEvent, data }); - function configFileName() { - if (!isConfiguredProject(project)) { - return "other"; - } - return getBaseConfigFileName(project.getConfigFilePath()) || "other"; - } - function convertTypeAcquisition2({ enable: enable2, include, exclude }) { - return { - enable: enable2, - include: include !== void 0 && include.length !== 0, - exclude: exclude !== void 0 && exclude.length !== 0 - }; - } - } - addFilesToNonInferredProject(project, files, propertyReader, typeAcquisition) { - this.updateNonInferredProjectFiles(project, files, propertyReader); - project.setTypeAcquisition(typeAcquisition); - project.markAsDirty(); - } - /** @internal */ - createConfiguredProject(configFileName, reason) { - var _a; - (_a = tracing) == null ? void 0 : _a.instant(tracing.Phase.Session, "createConfiguredProject", { configFilePath: configFileName }); - this.logger.info(`Creating configuration project ${configFileName}`); - const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName)); - let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo) { - this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo = { exists: true }); - } else { - configFileExistenceInfo.exists = true; - } - if (!configFileExistenceInfo.config) { - configFileExistenceInfo.config = { - cachedDirectoryStructureHost: createCachedDirectoryStructureHost(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames), - projects: /* @__PURE__ */ new Map(), - updateLevel: 2 /* Full */ - }; - } - const project = new ConfiguredProject2( - configFileName, - canonicalConfigFilePath, - this, - this.documentRegistry, - configFileExistenceInfo.config.cachedDirectoryStructureHost, - reason - ); - Debug.assert(!this.configuredProjects.has(canonicalConfigFilePath)); - this.configuredProjects.set(canonicalConfigFilePath, project); - this.createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, project); - return project; - } - /** - * Read the config file of the project, and update the project root file names. - */ - loadConfiguredProject(project, reason) { - var _a, _b; - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "loadConfiguredProject", { configFilePath: project.canonicalConfigFilePath }); - this.sendProjectLoadingStartEvent(project, reason); - const configFilename = asNormalizedPath(normalizePath(project.getConfigFilePath())); - const configFileExistenceInfo = this.ensureParsedConfigUptoDate( - configFilename, - project.canonicalConfigFilePath, - this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath), - project - ); - const parsedCommandLine = configFileExistenceInfo.config.parsedCommandLine; - Debug.assert(!!parsedCommandLine.fileNames); - const compilerOptions = parsedCommandLine.options; - if (!project.projectOptions) { - project.projectOptions = { - configHasExtendsProperty: parsedCommandLine.raw.extends !== void 0, - configHasFilesProperty: parsedCommandLine.raw.files !== void 0, - configHasIncludeProperty: parsedCommandLine.raw.include !== void 0, - configHasExcludeProperty: parsedCommandLine.raw.exclude !== void 0 - }; - } - project.canConfigFileJsonReportNoInputFiles = canJsonReportNoInputFiles(parsedCommandLine.raw); - project.setProjectErrors(parsedCommandLine.options.configFile.parseDiagnostics); - project.updateReferences(parsedCommandLine.projectReferences); - const lastFileExceededProgramSize = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(project.canonicalConfigFilePath, compilerOptions, parsedCommandLine.fileNames, fileNamePropertyReader); - if (lastFileExceededProgramSize) { - project.disableLanguageService(lastFileExceededProgramSize); - this.configFileExistenceInfoCache.forEach((_configFileExistenceInfo, canonicalConfigFilePath) => this.stopWatchingWildCards(canonicalConfigFilePath, project)); - } else { - project.setCompilerOptions(compilerOptions); - project.setWatchOptions(parsedCommandLine.watchOptions); - project.enableLanguageService(); - this.watchWildcards(configFilename, configFileExistenceInfo, project); - } - project.enablePluginsWithOptions(compilerOptions); - const filesToAdd = parsedCommandLine.fileNames.concat(project.getExternalFiles(2 /* Full */)); - this.updateRootAndOptionsOfNonInferredProject(project, filesToAdd, fileNamePropertyReader, compilerOptions, parsedCommandLine.typeAcquisition, parsedCommandLine.compileOnSave, parsedCommandLine.watchOptions); - (_b = tracing) == null ? void 0 : _b.pop(); - } - /** @internal */ - ensureParsedConfigUptoDate(configFilename, canonicalConfigFilePath, configFileExistenceInfo, forProject) { - var _a, _b, _c; - if (configFileExistenceInfo.config) { - if (!configFileExistenceInfo.config.updateLevel) return configFileExistenceInfo; - if (configFileExistenceInfo.config.updateLevel === 1 /* RootNamesAndUpdate */) { - this.reloadFileNamesOfParsedConfig(configFilename, configFileExistenceInfo.config); - return configFileExistenceInfo; - } - } - const cachedDirectoryStructureHost = ((_a = configFileExistenceInfo.config) == null ? void 0 : _a.cachedDirectoryStructureHost) || createCachedDirectoryStructureHost(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames); - const configFileContent = tryReadFile(configFilename, (fileName) => this.host.readFile(fileName)); - const configFile = parseJsonText(configFilename, isString(configFileContent) ? configFileContent : ""); - const configFileErrors = configFile.parseDiagnostics; - if (!isString(configFileContent)) configFileErrors.push(configFileContent); - const configDir = getDirectoryPath(configFilename); - const parsedCommandLine = parseJsonSourceFileConfigFileContent( - configFile, - cachedDirectoryStructureHost, - configDir, - /*existingOptions*/ - void 0, - configFilename, - /*resolutionStack*/ - void 0, - this.hostConfiguration.extraFileExtensions, - this.extendedConfigCache - ); - if (parsedCommandLine.errors.length) { - configFileErrors.push(...parsedCommandLine.errors); - } - this.logger.info(`Config: ${configFilename} : ${JSON.stringify( - { - rootNames: parsedCommandLine.fileNames, - options: parsedCommandLine.options, - watchOptions: parsedCommandLine.watchOptions, - projectReferences: parsedCommandLine.projectReferences - }, - /*replacer*/ - void 0, - " " - )}`); - const oldCommandLine = (_b = configFileExistenceInfo.config) == null ? void 0 : _b.parsedCommandLine; - if (!configFileExistenceInfo.config) { - configFileExistenceInfo.config = { parsedCommandLine, cachedDirectoryStructureHost, projects: /* @__PURE__ */ new Map() }; - } else { - configFileExistenceInfo.config.parsedCommandLine = parsedCommandLine; - configFileExistenceInfo.config.watchedDirectoriesStale = true; - configFileExistenceInfo.config.updateLevel = void 0; - } - if (!oldCommandLine && !isJsonEqual( - // Old options - this.getWatchOptionsFromProjectWatchOptions( - /*projectOptions*/ - void 0, - configDir - ), - // New options - this.getWatchOptionsFromProjectWatchOptions(parsedCommandLine.watchOptions, configDir) - )) { - (_c = configFileExistenceInfo.watcher) == null ? void 0 : _c.close(); - configFileExistenceInfo.watcher = void 0; - } - this.createConfigFileWatcherForParsedConfig(configFilename, canonicalConfigFilePath, forProject); - updateSharedExtendedConfigFileWatcher( - canonicalConfigFilePath, - parsedCommandLine.options, - this.sharedExtendedConfigFileWatchers, - (extendedConfigFileName, extendedConfigFilePath) => this.watchFactory.watchFile( - extendedConfigFileName, - () => { - var _a2; - cleanExtendedConfigCache(this.extendedConfigCache, extendedConfigFilePath, (fileName) => this.toPath(fileName)); - let ensureProjectsForOpenFiles = false; - (_a2 = this.sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a2.projects.forEach((canonicalPath) => { - ensureProjectsForOpenFiles = this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalPath, `Change in extended config file ${extendedConfigFileName} detected`) || ensureProjectsForOpenFiles; - }); - if (ensureProjectsForOpenFiles) this.delayEnsureProjectForOpenFiles(); - }, - 2e3 /* High */, - this.hostConfiguration.watchOptions, - WatchType.ExtendedConfigFile, - configFilename - ), - (fileName) => this.toPath(fileName) - ); - return configFileExistenceInfo; - } - /** @internal */ - watchWildcards(configFileName, { exists, config }, forProject) { - config.projects.set(forProject.canonicalConfigFilePath, true); - if (exists) { - if (config.watchedDirectories && !config.watchedDirectoriesStale) return; - config.watchedDirectoriesStale = false; - updateWatchingWildcardDirectories( - config.watchedDirectories || (config.watchedDirectories = /* @__PURE__ */ new Map()), - config.parsedCommandLine.wildcardDirectories, - // Create new directory watcher - (directory, flags) => this.watchWildcardDirectory(directory, flags, configFileName, config) - ); - } else { - config.watchedDirectoriesStale = false; - if (!config.watchedDirectories) return; - clearMap(config.watchedDirectories, closeFileWatcherOf); - config.watchedDirectories = void 0; - } - } - /** @internal */ - stopWatchingWildCards(canonicalConfigFilePath, forProject) { - const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath); - if (!configFileExistenceInfo.config || !configFileExistenceInfo.config.projects.get(forProject.canonicalConfigFilePath)) { - return; - } - configFileExistenceInfo.config.projects.set(forProject.canonicalConfigFilePath, false); - if (forEachEntry(configFileExistenceInfo.config.projects, identity)) return; - if (configFileExistenceInfo.config.watchedDirectories) { - clearMap(configFileExistenceInfo.config.watchedDirectories, closeFileWatcherOf); - configFileExistenceInfo.config.watchedDirectories = void 0; - } - configFileExistenceInfo.config.watchedDirectoriesStale = void 0; - } - updateNonInferredProjectFiles(project, files, propertyReader) { - var _a; - const projectRootFilesMap = project.getRootFilesMap(); - const newRootScriptInfoMap = /* @__PURE__ */ new Map(); - for (const f of files) { - const newRootFile = propertyReader.getFileName(f); - const fileName = toNormalizedPath(newRootFile); - const isDynamic = isDynamicFileName(fileName); - let path; - if (!isDynamic && !project.fileExists(newRootFile)) { - path = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName); - const existingValue = projectRootFilesMap.get(path); - if (existingValue) { - if (((_a = existingValue.info) == null ? void 0 : _a.path) === path) { - project.removeFile( - existingValue.info, - /*fileExists*/ - false, - /*detachFromProject*/ - true - ); - existingValue.info = void 0; - } - existingValue.fileName = fileName; - } else { - projectRootFilesMap.set(path, { fileName }); - } - } else { - const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions); - const hasMixedContent = propertyReader.hasMixedContent(f, this.hostConfiguration.extraFileExtensions); - const scriptInfo = Debug.checkDefined(this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath( - fileName, - project.currentDirectory, - scriptKind, - hasMixedContent, - project.directoryStructureHost, - /*deferredDeleteOk*/ - false - )); - path = scriptInfo.path; - const existingValue = projectRootFilesMap.get(path); - if (!existingValue || existingValue.info !== scriptInfo) { - project.addRoot(scriptInfo, fileName); - if (scriptInfo.isScriptOpen()) { - this.removeRootOfInferredProjectIfNowPartOfOtherProject(scriptInfo); - } - } else { - existingValue.fileName = fileName; - } - } - newRootScriptInfoMap.set(path, true); - } - if (projectRootFilesMap.size > newRootScriptInfoMap.size) { - projectRootFilesMap.forEach((value, path) => { - if (!newRootScriptInfoMap.has(path)) { - if (value.info) { - project.removeFile( - value.info, - project.fileExists(value.info.fileName), - /*detachFromProject*/ - true - ); - } else { - projectRootFilesMap.delete(path); - } - } - }); - } - } - updateRootAndOptionsOfNonInferredProject(project, newUncheckedFiles, propertyReader, newOptions, newTypeAcquisition, compileOnSave, watchOptions) { - project.setCompilerOptions(newOptions); - project.setWatchOptions(watchOptions); - if (compileOnSave !== void 0) { - project.compileOnSaveEnabled = compileOnSave; - } - this.addFilesToNonInferredProject(project, newUncheckedFiles, propertyReader, newTypeAcquisition); - } - /** - * Reload the file names from config file specs and update the project graph - * - * @internal - */ - reloadFileNamesOfConfiguredProject(project) { - const fileNames = this.reloadFileNamesOfParsedConfig(project.getConfigFilePath(), this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath).config); - project.updateErrorOnNoInputFiles(fileNames); - this.updateNonInferredProjectFiles(project, fileNames.concat(project.getExternalFiles(1 /* RootNamesAndUpdate */)), fileNamePropertyReader); - project.markAsDirty(); - return project.updateGraph(); - } - reloadFileNamesOfParsedConfig(configFileName, config) { - if (config.updateLevel === void 0) return config.parsedCommandLine.fileNames; - Debug.assert(config.updateLevel === 1 /* RootNamesAndUpdate */); - const configFileSpecs = config.parsedCommandLine.options.configFile.configFileSpecs; - const fileNames = getFileNamesFromConfigSpecs( - configFileSpecs, - getDirectoryPath(configFileName), - config.parsedCommandLine.options, - config.cachedDirectoryStructureHost, - this.hostConfiguration.extraFileExtensions - ); - config.parsedCommandLine = { ...config.parsedCommandLine, fileNames }; - return fileNames; - } - /** @internal */ - setFileNamesOfAutpImportProviderOrAuxillaryProject(project, fileNames) { - this.updateNonInferredProjectFiles(project, fileNames, fileNamePropertyReader); - } - /** @internal */ - reloadConfiguredProjectClearingSemanticCache(project, reason, reloadedProjects) { - if (!tryAddToSet(reloadedProjects, project)) return false; - this.clearSemanticCache(project); - this.reloadConfiguredProject(project, reloadReason(reason)); - return true; - } - /** - * Read the config file of the project again by clearing the cache and update the project graph - * - * @internal - */ - reloadConfiguredProject(project, reason) { - project.isInitialLoadPending = returnFalse; - project.pendingUpdateReason = void 0; - project.pendingUpdateLevel = 0 /* Update */; - const host = project.getCachedDirectoryStructureHost(); - host.clearCache(); - this.loadConfiguredProject(project, reason); - updateWithTriggerFile( - project, - project.triggerFileForConfigFileDiag ?? project.getConfigFilePath(), - /*isReload*/ - true - ); - } - clearSemanticCache(project) { - project.originalConfiguredProjects = void 0; - project.resolutionCache.clear(); - project.getLanguageService( - /*ensureSynchronized*/ - false - ).cleanupSemanticCache(); - project.cleanupProgram(); - project.markAsDirty(); - } - /** @internal */ - sendConfigFileDiagEvent(project, triggerFile, force) { - if (!this.eventHandler || this.suppressDiagnosticEvents) return false; - const diagnostics = project.getLanguageService().getCompilerOptionsDiagnostics(); - diagnostics.push(...project.getAllProjectErrors()); - if (!force && diagnostics.length === (project.configDiagDiagnosticsReported ?? 0)) return false; - project.configDiagDiagnosticsReported = diagnostics.length; - this.eventHandler( - { - eventName: ConfigFileDiagEvent, - data: { configFileName: project.getConfigFilePath(), diagnostics, triggerFile: triggerFile ?? project.getConfigFilePath() } - } - ); - return true; - } - getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) { - if (!this.useInferredProjectPerProjectRoot || // Its a dynamic info opened without project root - info.isDynamic && projectRootPath === void 0) { - return void 0; - } - if (projectRootPath) { - const canonicalProjectRootPath = this.toCanonicalFileName(projectRootPath); - for (const project of this.inferredProjects) { - if (project.projectRootPath === canonicalProjectRootPath) { - return project; - } - } - return this.createInferredProject( - projectRootPath, - /*isSingleInferredProject*/ - false, - projectRootPath - ); - } - let bestMatch; - for (const project of this.inferredProjects) { - if (!project.projectRootPath) continue; - if (!containsPath(project.projectRootPath, info.path, this.host.getCurrentDirectory(), !this.host.useCaseSensitiveFileNames)) continue; - if (bestMatch && bestMatch.projectRootPath.length > project.projectRootPath.length) continue; - bestMatch = project; - } - return bestMatch; - } - getOrCreateSingleInferredProjectIfEnabled() { - if (!this.useSingleInferredProject) { - return void 0; - } - if (this.inferredProjects.length > 0 && this.inferredProjects[0].projectRootPath === void 0) { - return this.inferredProjects[0]; - } - return this.createInferredProject( - "", - /*isSingleInferredProject*/ - true - ); - } - getOrCreateSingleInferredWithoutProjectRoot(currentDirectory) { - Debug.assert(!this.useSingleInferredProject); - const expectedCurrentDirectory = this.toCanonicalFileName(this.getNormalizedAbsolutePath(currentDirectory)); - for (const inferredProject of this.inferredProjects) { - if (!inferredProject.projectRootPath && inferredProject.isOrphan() && inferredProject.canonicalCurrentDirectory === expectedCurrentDirectory) { - return inferredProject; - } - } - return this.createInferredProject(currentDirectory); - } - createInferredProject(currentDirectory, isSingleInferredProject, projectRootPath) { - const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects; - let watchOptionsAndErrors; - let typeAcquisition; - if (projectRootPath) { - watchOptionsAndErrors = this.watchOptionsForInferredProjectsPerProjectRoot.get(projectRootPath); - typeAcquisition = this.typeAcquisitionForInferredProjectsPerProjectRoot.get(projectRootPath); - } - if (watchOptionsAndErrors === void 0) { - watchOptionsAndErrors = this.watchOptionsForInferredProjects; - } - if (typeAcquisition === void 0) { - typeAcquisition = this.typeAcquisitionForInferredProjects; - } - watchOptionsAndErrors = watchOptionsAndErrors || void 0; - const project = new InferredProject2(this, this.documentRegistry, compilerOptions, watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions, projectRootPath, currentDirectory, typeAcquisition); - project.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors); - if (isSingleInferredProject) { - this.inferredProjects.unshift(project); - } else { - this.inferredProjects.push(project); - } - return project; - } - /** @internal */ - getOrCreateScriptInfoNotOpenedByClient(uncheckedFileName, currentDirectory, hostToQueryFileExistsOn, deferredDeleteOk) { - return this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath( - toNormalizedPath(uncheckedFileName), - currentDirectory, - /*scriptKind*/ - void 0, - /*hasMixedContent*/ - void 0, - hostToQueryFileExistsOn, - deferredDeleteOk - ); - } - getScriptInfo(uncheckedFileName) { - return this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName)); - } - /** @internal */ - getScriptInfoOrConfig(uncheckedFileName) { - const path = toNormalizedPath(uncheckedFileName); - const info = this.getScriptInfoForNormalizedPath(path); - if (info) return info; - const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName)); - return configProject && configProject.getCompilerOptions().configFile; - } - /** @internal */ - logErrorForScriptInfoNotFound(fileName) { - const names = arrayFrom( - mapDefinedIterator( - this.filenameToScriptInfo.entries(), - (entry) => entry[1].deferredDelete ? void 0 : entry - ), - ([path, scriptInfo]) => ({ path, fileName: scriptInfo.fileName }) - ); - this.logger.msg(`Could not find file ${JSON.stringify(fileName)}. -All files are: ${JSON.stringify(names)}`, "Err" /* Err */); - } - /** - * Returns the projects that contain script info through SymLink - * Note that this does not return projects in info.containingProjects - * - * @internal - */ - getSymlinkedProjects(info) { - let projects; - if (this.realpathToScriptInfos) { - const realpath = info.getRealpathIfDifferent(); - if (realpath) { - forEach(this.realpathToScriptInfos.get(realpath), combineProjects); - } - forEach(this.realpathToScriptInfos.get(info.path), combineProjects); - } - return projects; - function combineProjects(toAddInfo) { - if (toAddInfo !== info) { - for (const project of toAddInfo.containingProjects) { - if (project.languageServiceEnabled && !project.isOrphan() && !project.getCompilerOptions().preserveSymlinks && !info.isAttached(project)) { - if (!projects) { - projects = createMultiMap(); - projects.add(toAddInfo.path, project); - } else if (!forEachEntry(projects, (projs, path) => path === toAddInfo.path ? false : contains(projs, project))) { - projects.add(toAddInfo.path, project); - } - } - } - } - } - } - watchClosedScriptInfo(info) { - Debug.assert(!info.fileWatcher); - if (!info.isDynamicOrHasMixedContent() && (!this.globalCacheLocationDirectoryPath || !startsWith(info.path, this.globalCacheLocationDirectoryPath))) { - const indexOfNodeModules = info.fileName.indexOf("/node_modules/"); - if (!this.host.getModifiedTime || indexOfNodeModules === -1) { - info.fileWatcher = this.watchFactory.watchFile( - info.fileName, - (_fileName, eventKind) => this.onSourceFileChanged(info, eventKind), - 500 /* Medium */, - this.hostConfiguration.watchOptions, - WatchType.ClosedScriptInfo - ); - } else { - info.mTime = this.getModifiedTime(info); - info.fileWatcher = this.watchClosedScriptInfoInNodeModules(info.fileName.substring(0, indexOfNodeModules)); - } - } - } - createNodeModulesWatcher(dir, dirPath) { - let watcher = this.watchFactory.watchDirectory( - dir, - (fileOrDirectory) => { - var _a; - const fileOrDirectoryPath = removeIgnoredPath(this.toPath(fileOrDirectory)); - if (!fileOrDirectoryPath) return; - const basename = getBaseFileName(fileOrDirectoryPath); - if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename === "package.json" || basename === "node_modules")) { - result.affectedModuleSpecifierCacheProjects.forEach((project) => { - var _a2; - (_a2 = project.getModuleSpecifierCache()) == null ? void 0 : _a2.clear(); - }); - } - if (result.refreshScriptInfoRefCount) { - if (dirPath === fileOrDirectoryPath) { - this.refreshScriptInfosInDirectory(dirPath); - } else { - const info = this.filenameToScriptInfo.get(fileOrDirectoryPath); - if (info) { - if (isScriptInfoWatchedFromNodeModules(info)) { - this.refreshScriptInfo(info); - } - } else if (!hasExtension(fileOrDirectoryPath)) { - this.refreshScriptInfosInDirectory(fileOrDirectoryPath); - } - } - } - }, - 1 /* Recursive */, - this.hostConfiguration.watchOptions, - WatchType.NodeModules - ); - const result = { - refreshScriptInfoRefCount: 0, - affectedModuleSpecifierCacheProjects: void 0, - close: () => { - var _a; - if (watcher && !result.refreshScriptInfoRefCount && !((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size)) { - watcher.close(); - watcher = void 0; - this.nodeModulesWatchers.delete(dirPath); - } - } - }; - this.nodeModulesWatchers.set(dirPath, result); - return result; - } - /** @internal */ - watchPackageJsonsInNodeModules(dir, project) { - var _a; - const dirPath = this.toPath(dir); - const watcher = this.nodeModulesWatchers.get(dirPath) || this.createNodeModulesWatcher(dir, dirPath); - Debug.assert(!((_a = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.has(project))); - (watcher.affectedModuleSpecifierCacheProjects || (watcher.affectedModuleSpecifierCacheProjects = /* @__PURE__ */ new Set())).add(project); - return { - close: () => { - var _a2; - (_a2 = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a2.delete(project); - watcher.close(); - } - }; - } - watchClosedScriptInfoInNodeModules(dir) { - const watchDir = dir + "/node_modules"; - const watchDirPath = this.toPath(watchDir); - const watcher = this.nodeModulesWatchers.get(watchDirPath) || this.createNodeModulesWatcher(watchDir, watchDirPath); - watcher.refreshScriptInfoRefCount++; - return { - close: () => { - watcher.refreshScriptInfoRefCount--; - watcher.close(); - } - }; - } - getModifiedTime(info) { - return (this.host.getModifiedTime(info.fileName) || missingFileModifiedTime).getTime(); - } - refreshScriptInfo(info) { - const mTime = this.getModifiedTime(info); - if (mTime !== info.mTime) { - const eventKind = getFileWatcherEventKind(info.mTime, mTime); - info.mTime = mTime; - this.onSourceFileChanged(info, eventKind); - } - } - refreshScriptInfosInDirectory(dir) { - dir = dir + directorySeparator; - this.filenameToScriptInfo.forEach((info) => { - if (isScriptInfoWatchedFromNodeModules(info) && startsWith(info.path, dir)) { - this.refreshScriptInfo(info); - } - }); - } - stopWatchingScriptInfo(info) { - if (info.fileWatcher) { - info.fileWatcher.close(); - info.fileWatcher = void 0; - } - } - getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(fileName, currentDirectory, scriptKind, hasMixedContent, hostToQueryFileExistsOn, deferredDeleteOk) { - if (isRootedDiskPath(fileName) || isDynamicFileName(fileName)) { - return this.getOrCreateScriptInfoWorker( - fileName, - currentDirectory, - /*openedByClient*/ - false, - /*fileContent*/ - void 0, - scriptKind, - !!hasMixedContent, - hostToQueryFileExistsOn, - deferredDeleteOk - ); - } - const info = this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName)); - if (info) { - return info; - } - return void 0; - } - getOrCreateScriptInfoForNormalizedPath(fileName, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) { - return this.getOrCreateScriptInfoWorker( - fileName, - this.currentDirectory, - openedByClient, - fileContent, - scriptKind, - !!hasMixedContent, - hostToQueryFileExistsOn, - /*deferredDeleteOk*/ - false - ); - } - getOrCreateScriptInfoWorker(fileName, currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn, deferredDeleteOk) { - Debug.assert(fileContent === void 0 || openedByClient, "ScriptInfo needs to be opened by client to be able to set its user defined content"); - const path = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName); - let info = this.filenameToScriptInfo.get(path); - if (!info) { - const isDynamic = isDynamicFileName(fileName); - Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })} -Script info with non-dynamic relative file name can only be open script info or in context of host currentDirectory`); - Debug.assert(!isRootedDiskPath(fileName) || this.currentDirectory === currentDirectory || !this.openFilesWithNonRootedDiskPath.has(this.toCanonicalFileName(fileName)), "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })} -Open script files with non rooted disk path opened with current directory context cannot have same canonical names`); - Debug.assert(!isDynamic || this.currentDirectory === currentDirectory || this.useInferredProjectPerProjectRoot, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })} -Dynamic files must always be opened with service's current directory or service should support inferred project per projectRootPath.`); - if (!openedByClient && !isDynamic && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) { - return; - } - info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path, this.filenameToScriptInfoVersion.get(path)); - this.filenameToScriptInfo.set(info.path, info); - this.filenameToScriptInfoVersion.delete(info.path); - if (!openedByClient) { - this.watchClosedScriptInfo(info); - } else if (!isRootedDiskPath(fileName) && (!isDynamic || this.currentDirectory !== currentDirectory)) { - this.openFilesWithNonRootedDiskPath.set(this.toCanonicalFileName(fileName), info); - } - } else if (info.deferredDelete) { - Debug.assert(!info.isDynamic); - if (!openedByClient && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) { - return deferredDeleteOk ? info : void 0; - } - info.deferredDelete = void 0; - } - if (openedByClient) { - this.stopWatchingScriptInfo(info); - info.open(fileContent); - if (hasMixedContent) { - info.registerFileUpdate(); - } - } - return info; - } - /** - * This gets the script info for the normalized path. If the path is not rooted disk path then the open script info with project root context is preferred - */ - getScriptInfoForNormalizedPath(fileName) { - return !isRootedDiskPath(fileName) && this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName)) || this.getScriptInfoForPath(normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName)); - } - getScriptInfoForPath(fileName) { - const info = this.filenameToScriptInfo.get(fileName); - return !info || !info.deferredDelete ? info : void 0; - } - /** @internal */ - getDocumentPositionMapper(project, generatedFileName, sourceFileName) { - const declarationInfo = this.getOrCreateScriptInfoNotOpenedByClient( - generatedFileName, - project.currentDirectory, - this.host, - /*deferredDeleteOk*/ - false - ); - if (!declarationInfo) { - if (sourceFileName) { - project.addGeneratedFileWatch(generatedFileName, sourceFileName); - } - return void 0; - } - declarationInfo.getSnapshot(); - if (isString(declarationInfo.sourceMapFilePath)) { - const sourceMapFileInfo2 = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath); - if (sourceMapFileInfo2) { - sourceMapFileInfo2.getSnapshot(); - if (sourceMapFileInfo2.documentPositionMapper !== void 0) { - sourceMapFileInfo2.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo2.sourceInfos); - return sourceMapFileInfo2.documentPositionMapper ? sourceMapFileInfo2.documentPositionMapper : void 0; - } - } - declarationInfo.sourceMapFilePath = void 0; - } else if (declarationInfo.sourceMapFilePath) { - declarationInfo.sourceMapFilePath.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, declarationInfo.sourceMapFilePath.sourceInfos); - return void 0; - } else if (declarationInfo.sourceMapFilePath !== void 0) { - return void 0; - } - let sourceMapFileInfo; - let readMapFile = (mapFileName, mapFileNameFromDts) => { - const mapInfo = this.getOrCreateScriptInfoNotOpenedByClient( - mapFileName, - project.currentDirectory, - this.host, - /*deferredDeleteOk*/ - true - ); - sourceMapFileInfo = mapInfo || mapFileNameFromDts; - if (!mapInfo || mapInfo.deferredDelete) return void 0; - const snap = mapInfo.getSnapshot(); - if (mapInfo.documentPositionMapper !== void 0) return mapInfo.documentPositionMapper; - return getSnapshotText(snap); - }; - const projectName = project.projectName; - const documentPositionMapper = getDocumentPositionMapper( - { getCanonicalFileName: this.toCanonicalFileName, log: (s) => this.logger.info(s), getSourceFileLike: (f) => this.getSourceFileLike(f, projectName, declarationInfo) }, - declarationInfo.fileName, - declarationInfo.textStorage.getLineInfo(), - readMapFile - ); - readMapFile = void 0; - if (sourceMapFileInfo) { - if (!isString(sourceMapFileInfo)) { - declarationInfo.sourceMapFilePath = sourceMapFileInfo.path; - sourceMapFileInfo.declarationInfoPath = declarationInfo.path; - if (!sourceMapFileInfo.deferredDelete) sourceMapFileInfo.documentPositionMapper = documentPositionMapper || false; - sourceMapFileInfo.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo.sourceInfos); - } else { - declarationInfo.sourceMapFilePath = { - watcher: this.addMissingSourceMapFile( - project.currentDirectory === this.currentDirectory ? sourceMapFileInfo : getNormalizedAbsolutePath(sourceMapFileInfo, project.currentDirectory), - declarationInfo.path - ), - sourceInfos: this.addSourceInfoToSourceMap(sourceFileName, project) - }; - } - } else { - declarationInfo.sourceMapFilePath = false; - } - return documentPositionMapper; - } - addSourceInfoToSourceMap(sourceFileName, project, sourceInfos) { - if (sourceFileName) { - const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient( - sourceFileName, - project.currentDirectory, - project.directoryStructureHost, - /*deferredDeleteOk*/ - false - ); - (sourceInfos || (sourceInfos = /* @__PURE__ */ new Set())).add(sourceInfo.path); - } - return sourceInfos; - } - addMissingSourceMapFile(mapFileName, declarationInfoPath) { - const fileWatcher = this.watchFactory.watchFile( - mapFileName, - () => { - const declarationInfo = this.getScriptInfoForPath(declarationInfoPath); - if (declarationInfo && declarationInfo.sourceMapFilePath && !isString(declarationInfo.sourceMapFilePath)) { - this.delayUpdateProjectGraphs( - declarationInfo.containingProjects, - /*clearSourceMapperCache*/ - true - ); - this.delayUpdateSourceInfoProjects(declarationInfo.sourceMapFilePath.sourceInfos); - declarationInfo.closeSourceMapFileWatcher(); - } - }, - 2e3 /* High */, - this.hostConfiguration.watchOptions, - WatchType.MissingSourceMapFile - ); - return fileWatcher; - } - /** @internal */ - getSourceFileLike(fileName, projectNameOrProject, declarationInfo) { - const project = projectNameOrProject.projectName ? projectNameOrProject : this.findProject(projectNameOrProject); - if (project) { - const path = project.toPath(fileName); - const sourceFile = project.getSourceFile(path); - if (sourceFile && sourceFile.resolvedPath === path) return sourceFile; - } - const info = this.getOrCreateScriptInfoNotOpenedByClient( - fileName, - (project || this).currentDirectory, - project ? project.directoryStructureHost : this.host, - /*deferredDeleteOk*/ - false - ); - if (!info) return void 0; - if (declarationInfo && isString(declarationInfo.sourceMapFilePath) && info !== declarationInfo) { - const sourceMapInfo = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath); - if (sourceMapInfo) { - (sourceMapInfo.sourceInfos ?? (sourceMapInfo.sourceInfos = /* @__PURE__ */ new Set())).add(info.path); - } - } - if (info.cacheSourceFile) return info.cacheSourceFile.sourceFile; - if (!info.sourceFileLike) { - info.sourceFileLike = { - get text() { - Debug.fail("shouldnt need text"); - return ""; - }, - getLineAndCharacterOfPosition: (pos) => { - const lineOffset = info.positionToLineOffset(pos); - return { line: lineOffset.line - 1, character: lineOffset.offset - 1 }; - }, - getPositionOfLineAndCharacter: (line, character, allowEdits) => info.lineOffsetToPosition(line + 1, character + 1, allowEdits) - }; - } - return info.sourceFileLike; - } - /** @internal */ - setPerformanceEventHandler(performanceEventHandler) { - this.performanceEventHandler = performanceEventHandler; - } - setHostConfiguration(args) { - var _a; - if (args.file) { - const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(args.file)); - if (info) { - info.setOptions(convertFormatOptions(args.formatOptions), args.preferences); - this.logger.info(`Host configuration update for file ${args.file}`); - } - } else { - if (args.hostInfo !== void 0) { - this.hostConfiguration.hostInfo = args.hostInfo; - this.logger.info(`Host information ${args.hostInfo}`); - } - if (args.formatOptions) { - this.hostConfiguration.formatCodeOptions = { ...this.hostConfiguration.formatCodeOptions, ...convertFormatOptions(args.formatOptions) }; - this.logger.info("Format host information updated"); - } - if (args.preferences) { - const { - lazyConfiguredProjectsFromExternalProject, - includePackageJsonAutoImports, - includeCompletionsForModuleExports - } = this.hostConfiguration.preferences; - this.hostConfiguration.preferences = { ...this.hostConfiguration.preferences, ...args.preferences }; - if (lazyConfiguredProjectsFromExternalProject && !this.hostConfiguration.preferences.lazyConfiguredProjectsFromExternalProject) { - this.externalProjectToConfiguredProjectMap.forEach( - (projects) => projects.forEach((project) => { - if (!project.deferredClose && !project.isClosed() && project.pendingUpdateLevel === 2 /* Full */ && !this.hasPendingProjectUpdate(project)) { - project.updateGraph(); - } - }) - ); - } - if (includePackageJsonAutoImports !== args.preferences.includePackageJsonAutoImports || !!includeCompletionsForModuleExports !== !!args.preferences.includeCompletionsForModuleExports) { - this.forEachProject((project) => { - project.onAutoImportProviderSettingsChanged(); - }); - } - } - if (args.extraFileExtensions) { - this.hostConfiguration.extraFileExtensions = args.extraFileExtensions; - this.reloadProjects(); - this.logger.info("Host file extension mappings updated"); - } - if (args.watchOptions) { - const watchOptions = (_a = convertWatchOptions(args.watchOptions)) == null ? void 0 : _a.watchOptions; - const substitution = handleWatchOptionsConfigDirTemplateSubstitution(watchOptions, this.currentDirectory); - this.hostConfiguration.watchOptions = substitution; - this.hostConfiguration.beforeSubstitution = substitution === watchOptions ? void 0 : watchOptions; - this.logger.info(`Host watch options changed to ${JSON.stringify(this.hostConfiguration.watchOptions)}, it will be take effect for next watches.`); - } - } - } - /** @internal */ - getWatchOptions(project) { - return this.getWatchOptionsFromProjectWatchOptions(project.getWatchOptions(), project.getCurrentDirectory()); - } - getWatchOptionsFromProjectWatchOptions(projectOptions, basePath) { - const hostWatchOptions = !this.hostConfiguration.beforeSubstitution ? this.hostConfiguration.watchOptions : handleWatchOptionsConfigDirTemplateSubstitution( - this.hostConfiguration.beforeSubstitution, - basePath - ); - return projectOptions && hostWatchOptions ? { ...hostWatchOptions, ...projectOptions } : projectOptions || hostWatchOptions; - } - closeLog() { - this.logger.close(); - } - sendSourceFileChange(inPath) { - this.filenameToScriptInfo.forEach((info) => { - if (this.openFiles.has(info.path)) return; - if (!info.fileWatcher) return; - const eventKind = memoize( - () => this.host.fileExists(info.fileName) ? info.deferredDelete ? 0 /* Created */ : 1 /* Changed */ : 2 /* Deleted */ - ); - if (inPath) { - if (isScriptInfoWatchedFromNodeModules(info) || !info.path.startsWith(inPath)) return; - if (eventKind() === 2 /* Deleted */ && info.deferredDelete) return; - this.logger.info(`Invoking sourceFileChange on ${info.fileName}:: ${eventKind()}`); - } - this.onSourceFileChanged( - info, - eventKind() - ); - }); - } - /** - * This function rebuilds the project for every file opened by the client - * This does not reload contents of open files from disk. But we could do that if needed - */ - reloadProjects() { - this.logger.info("reload projects."); - this.sendSourceFileChange( - /*inPath*/ - void 0 - ); - this.pendingProjectUpdates.forEach((_project, projectName) => { - this.throttledOperations.cancel(projectName); - this.pendingProjectUpdates.delete(projectName); - }); - this.throttledOperations.cancel(ensureProjectForOpenFileSchedule); - this.pendingOpenFileProjectUpdates = void 0; - this.pendingEnsureProjectForOpenFiles = false; - this.configFileExistenceInfoCache.forEach((info) => { - if (info.config) info.config.updateLevel = 2 /* Full */; - }); - this.configFileForOpenFiles.clear(); - this.externalProjects.forEach((project) => { - this.clearSemanticCache(project); - project.updateGraph(); - }); - const reloadedConfiguredProjects = /* @__PURE__ */ new Set(); - const delayReloadedConfiguredProjects = /* @__PURE__ */ new Set(); - this.externalProjectToConfiguredProjectMap.forEach((projects, externalProjectName) => { - const reason = `Reloading configured project in external project: ${externalProjectName}`; - projects.forEach((project) => { - if (this.getHostPreferences().lazyConfiguredProjectsFromExternalProject) { - if (!project.isInitialLoadPending()) { - this.clearSemanticCache(project); - project.pendingUpdateLevel = 2 /* Full */; - project.pendingUpdateReason = reloadReason(reason); - } - delayReloadedConfiguredProjects.add(project); - } else { - this.reloadConfiguredProjectClearingSemanticCache( - project, - reason, - reloadedConfiguredProjects - ); - } - }); - }); - this.openFiles.forEach((_projectRootPath, path) => { - const info = this.getScriptInfoForPath(path); - if (find(info.containingProjects, isExternalProject)) return; - this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( - info, - 2 /* Reload */, - reloadedConfiguredProjects, - delayReloadedConfiguredProjects - ); - }); - delayReloadedConfiguredProjects.forEach((p) => reloadedConfiguredProjects.add(p)); - this.inferredProjects.forEach((project) => this.clearSemanticCache(project)); - this.ensureProjectForOpenFiles(); - this.cleanupProjectsAndScriptInfos( - reloadedConfiguredProjects, - new Set(this.openFiles.keys()), - new Set(this.externalProjectToConfiguredProjectMap.keys()) - ); - this.logger.info("After reloading projects.."); - this.printProjects(); - } - /** - * Remove the root of inferred project if script info is part of another project - */ - removeRootOfInferredProjectIfNowPartOfOtherProject(info) { - Debug.assert(info.containingProjects.length > 0); - const firstProject = info.containingProjects[0]; - if (!firstProject.isOrphan() && isInferredProject(firstProject) && firstProject.isRoot(info) && forEach(info.containingProjects, (p) => p !== firstProject && !p.isOrphan())) { - firstProject.removeFile( - info, - /*fileExists*/ - true, - /*detachFromProject*/ - true - ); - } - } - /** - * This function is to update the project structure for every inferred project. - * It is called on the premise that all the configured projects are - * up to date. - * This will go through open files and assign them to inferred project if open file is not part of any other project - * After that all the inferred project graphs are updated - */ - ensureProjectForOpenFiles() { - this.logger.info("Before ensureProjectForOpenFiles:"); - this.printProjects(); - const pendingOpenFileProjectUpdates = this.pendingOpenFileProjectUpdates; - this.pendingOpenFileProjectUpdates = void 0; - pendingOpenFileProjectUpdates == null ? void 0 : pendingOpenFileProjectUpdates.forEach( - (_config, path) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( - this.getScriptInfoForPath(path), - 1 /* Create */ - ) - ); - this.openFiles.forEach((projectRootPath, path) => { - const info = this.getScriptInfoForPath(path); - if (info.isOrphan()) { - this.assignOrphanScriptInfoToInferredProject(info, projectRootPath); - } else { - this.removeRootOfInferredProjectIfNowPartOfOtherProject(info); - } - }); - this.pendingEnsureProjectForOpenFiles = false; - this.inferredProjects.forEach(updateProjectIfDirty); - this.logger.info("After ensureProjectForOpenFiles:"); - this.printProjects(); - } - /** - * Open file whose contents is managed by the client - * @param filename is absolute pathname - * @param fileContent is a known version of the file content that is more up to date than the one on disk - */ - openClientFile(fileName, fileContent, scriptKind, projectRootPath) { - return this.openClientFileWithNormalizedPath( - toNormalizedPath(fileName), - fileContent, - scriptKind, - /*hasMixedContent*/ - false, - projectRootPath ? toNormalizedPath(projectRootPath) : void 0 - ); - } - /** @internal */ - getOriginalLocationEnsuringConfiguredProject(project, location) { - const isSourceOfProjectReferenceRedirect = project.isSourceOfProjectReferenceRedirect(location.fileName); - const originalLocation = isSourceOfProjectReferenceRedirect ? location : project.getSourceMapper().tryGetSourcePosition(location); - if (!originalLocation) return void 0; - const { fileName } = originalLocation; - const scriptInfo = this.getScriptInfo(fileName); - if (!scriptInfo && !this.host.fileExists(fileName)) return void 0; - const originalFileInfo = { fileName: toNormalizedPath(fileName), path: this.toPath(fileName) }; - const configFileName = this.getConfigFileNameForFile( - originalFileInfo, - /*findFromCacheOnly*/ - false - ); - if (!configFileName) return void 0; - let configuredProject = this.findConfiguredProjectByProjectName(configFileName); - if (!configuredProject) { - if (project.getCompilerOptions().disableReferencedProjectLoad) { - if (isSourceOfProjectReferenceRedirect) { - return location; - } - return (scriptInfo == null ? void 0 : scriptInfo.containingProjects.length) ? originalLocation : location; - } - configuredProject = this.createConfiguredProject(configFileName, `Creating project for original file: ${originalFileInfo.fileName}${location !== originalLocation ? " for location: " + location.fileName : ""}`); - } - updateProjectIfDirty(configuredProject); - const projectContainsOriginalInfo = (project2) => { - const info = this.getScriptInfo(fileName); - return info && project2.containsScriptInfo(info) && !project2.isSourceOfProjectReferenceRedirect(info.path); - }; - if (configuredProject.isSolution() || !projectContainsOriginalInfo(configuredProject)) { - configuredProject = forEachResolvedProjectReferenceProject( - configuredProject, - fileName, - (child) => projectContainsOriginalInfo(child) ? child : void 0, - 1 /* Create */, - `Creating project referenced in solution ${configuredProject.projectName} to find possible configured project for original file: ${originalFileInfo.fileName}${location !== originalLocation ? " for location: " + location.fileName : ""}` - ); - if (!configuredProject) return void 0; - if (configuredProject === project) return originalLocation; - } - addOriginalConfiguredProject(configuredProject); - const originalScriptInfo = this.getScriptInfo(fileName); - if (!originalScriptInfo || !originalScriptInfo.containingProjects.length) return void 0; - originalScriptInfo.containingProjects.forEach((project2) => { - if (isConfiguredProject(project2)) { - addOriginalConfiguredProject(project2); - } - }); - return originalLocation; - function addOriginalConfiguredProject(originalProject) { - (project.originalConfiguredProjects ?? (project.originalConfiguredProjects = /* @__PURE__ */ new Set())).add(originalProject.canonicalConfigFilePath); - } - } - /** @internal */ - fileExists(fileName) { - return !!this.getScriptInfoForNormalizedPath(fileName) || this.host.fileExists(fileName); - } - findExternalProjectContainingOpenScriptInfo(info) { - return find(this.externalProjects, (proj) => { - updateProjectIfDirty(proj); - return proj.containsScriptInfo(info); - }); - } - getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) { - const info = this.getOrCreateScriptInfoWorker( - fileName, - projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory, - /*openedByClient*/ - true, - fileContent, - scriptKind, - !!hasMixedContent, - /*hostToQueryFileExistsOn*/ - void 0, - /*deferredDeleteOk*/ - true - ); - this.openFiles.set(info.path, projectRootPath); - return info; - } - assignProjectToOpenedScriptInfo(info) { - let configFileName; - let configFileErrors; - const project = this.findExternalProjectContainingOpenScriptInfo(info); - let retainProjects; - let sentConfigDiag; - if (!project && this.serverMode === 0 /* Semantic */) { - const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( - info, - 1 /* Create */ - ); - if (result) { - retainProjects = result.seenProjects; - sentConfigDiag = result.sentConfigDiag; - if (result.defaultProject) { - configFileName = result.defaultProject.getConfigFilePath(); - configFileErrors = result.defaultProject.getAllProjectErrors(); - } - } - } - info.containingProjects.forEach(updateProjectIfDirty); - if (info.isOrphan()) { - retainProjects == null ? void 0 : retainProjects.forEach((project2) => { - if (!sentConfigDiag.has(project2)) this.sendConfigFileDiagEvent( - project2, - info.fileName, - /*force*/ - true - ); - }); - Debug.assert(this.openFiles.has(info.path)); - this.assignOrphanScriptInfoToInferredProject(info, this.openFiles.get(info.path)); - } - Debug.assert(!info.isOrphan()); - return { configFileName, configFileErrors, retainProjects }; - } - /** - * Depending on kind - * - Find the configuedProject and return it - if allowDeferredClosed is set it will find the deferredClosed project as well - * - Create - if the project doesnt exist, it creates one as well. If not delayLoad, the project is updated (with triggerFile if passed) - * - Reload - if the project doesnt exist, it creates one. If not delayLoad, the project is reloaded clearing semantic cache - * @internal - */ - findCreateOrReloadConfiguredProject(configFileName, kind, reason, allowDeferredClosed, triggerFile, reloadedProjects, delayLoad, delayReloadedConfiguredProjects) { - let project = this.findConfiguredProjectByProjectName(configFileName, allowDeferredClosed); - let sentConfigFileDiag = false; - switch (kind) { - case 0 /* Find */: - if (!project) return; - break; - case 1 /* Create */: - project ?? (project = this.createConfiguredProject(configFileName, reason)); - sentConfigFileDiag = !delayLoad && updateConfiguredProject(project, triggerFile); - break; - case 2 /* Reload */: - project ?? (project = this.createConfiguredProject(configFileName, reloadReason(reason))); - sentConfigFileDiag = !delayReloadedConfiguredProjects && this.reloadConfiguredProjectClearingSemanticCache(project, reason, reloadedProjects); - if (delayReloadedConfiguredProjects && !delayReloadedConfiguredProjects.has(project) && !reloadedProjects.has(project)) { - project.pendingUpdateLevel = 2 /* Full */; - project.pendingUpdateReason = reloadReason(reason); - delayReloadedConfiguredProjects.add(project); - } - break; - default: - Debug.assertNever(kind); - } - return { project, sentConfigFileDiag }; - } - /** - * Finds the default configured project for given info - * For any tsconfig found, it looks into that project, if not then all its references, - * The search happens for all tsconfigs till projectRootPath - */ - tryFindDefaultConfiguredProjectForOpenScriptInfo(info, kind, allowDeferredClosed, reloadedProjects) { - const configFileName = this.getConfigFileNameForFile(info, kind === 0 /* Find */); - if (!configFileName) return; - const result = this.findCreateOrReloadConfiguredProject( - configFileName, - kind, - fileOpenReason(info), - allowDeferredClosed, - info.fileName, - reloadedProjects - ); - if (!result) return; - const seenProjects = /* @__PURE__ */ new Set(); - const sentConfigDiag = new Set(result.sentConfigFileDiag ? [result.project] : void 0); - let defaultProject; - let possiblyDefault; - tryFindDefaultConfiguredProject(result.project); - return { - defaultProject: defaultProject ?? possiblyDefault, - sentConfigDiag, - seenProjects - }; - function tryFindDefaultConfiguredProject(project) { - return isDefaultProject(project) ? defaultProject : tryFindDefaultConfiguredProjectFromReferences(project); - } - function isDefaultProject(project) { - if (!tryAddToSet(seenProjects, project)) return; - const projectWithInfo = project.containsScriptInfo(info); - if (projectWithInfo && !project.isSourceOfProjectReferenceRedirect(info.path)) return defaultProject = project; - possiblyDefault ?? (possiblyDefault = projectWithInfo ? project : void 0); - } - function tryFindDefaultConfiguredProjectFromReferences(project) { - return forEachResolvedProjectReferenceProject( - project, - info.path, - (child, sentConfigFileDiag) => { - if (sentConfigFileDiag) sentConfigDiag.add(child); - return isDefaultProject(child); - }, - kind, - `Creating project referenced in solution ${project.projectName} to find possible configured project for ${info.fileName} to open`, - allowDeferredClosed, - info.fileName, - reloadedProjects - ); - } - } - tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(info, kind, reloadedProjects, delayReloadedConfiguredProjects) { - const allowDeferredClosed = kind === 0 /* Find */; - const result = this.tryFindDefaultConfiguredProjectForOpenScriptInfo( - info, - kind, - allowDeferredClosed, - reloadedProjects - ); - if (!result) return; - const { defaultProject, seenProjects } = result; - if (defaultProject) { - forEachAncestorProject( - info, - defaultProject, - (ancestor) => { - seenProjects.add(ancestor); - }, - kind, - `Creating project possibly referencing default composite project ${defaultProject.getProjectName()} of open file ${info.fileName}`, - allowDeferredClosed, - reloadedProjects, - delayReloadedConfiguredProjects - ); - } - return result; - } - /** @internal */ - loadAncestorProjectTree(forProjects) { - forProjects ?? (forProjects = new Set( - mapDefinedIterator(this.configuredProjects.entries(), ([key, project]) => !project.isInitialLoadPending() ? key : void 0) - )); - const seenProjects = /* @__PURE__ */ new Set(); - const currentConfiguredProjects = arrayFrom(this.configuredProjects.values()); - for (const project of currentConfiguredProjects) { - if (forEachPotentialProjectReference(project, (potentialRefPath) => forProjects.has(potentialRefPath))) { - updateProjectIfDirty(project); - } - this.ensureProjectChildren(project, forProjects, seenProjects); - } - } - ensureProjectChildren(project, forProjects, seenProjects) { - var _a; - if (!tryAddToSet(seenProjects, project.canonicalConfigFilePath)) return; - if (project.getCompilerOptions().disableReferencedProjectLoad) return; - const children = (_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(); - if (!children) return; - for (const child of children) { - if (!child) continue; - const referencedProject = forEachResolvedProjectReference(child.references, (ref) => forProjects.has(ref.sourceFile.path) ? ref : void 0); - if (!referencedProject) continue; - const configFileName = toNormalizedPath(child.sourceFile.fileName); - const childProject = this.findConfiguredProjectByProjectName(configFileName) ?? this.createConfiguredProject( - configFileName, - `Creating project referenced by : ${project.projectName} as it references project ${referencedProject.sourceFile.fileName}` - ); - updateProjectIfDirty(childProject); - this.ensureProjectChildren(childProject, forProjects, seenProjects); - } - } - cleanupConfiguredProjects(toRetainConfiguredProjects, externalProjectsRetainingConfiguredProjects, openFilesWithRetainedConfiguredProject) { - this.getOrphanConfiguredProjects( - toRetainConfiguredProjects, - openFilesWithRetainedConfiguredProject, - externalProjectsRetainingConfiguredProjects - ).forEach((project) => this.removeProject(project)); - } - cleanupProjectsAndScriptInfos(toRetainConfiguredProjects, openFilesWithRetainedConfiguredProject, externalProjectsRetainingConfiguredProjects) { - this.cleanupConfiguredProjects( - toRetainConfiguredProjects, - externalProjectsRetainingConfiguredProjects, - openFilesWithRetainedConfiguredProject - ); - for (const inferredProject of this.inferredProjects.slice()) { - if (inferredProject.isOrphan()) { - this.removeProject(inferredProject); - } - } - this.removeOrphanScriptInfos(); - } - tryInvokeWildCardDirectories(info) { - this.configFileExistenceInfoCache.forEach((configFileExistenceInfo, config) => { - var _a, _b; - if (!((_a = configFileExistenceInfo.config) == null ? void 0 : _a.parsedCommandLine) || contains( - configFileExistenceInfo.config.parsedCommandLine.fileNames, - info.fileName, - !this.host.useCaseSensitiveFileNames ? equateStringsCaseInsensitive : equateStringsCaseSensitive - )) { - return; - } - (_b = configFileExistenceInfo.config.watchedDirectories) == null ? void 0 : _b.forEach((watcher, directory) => { - if (containsPath(directory, info.fileName, !this.host.useCaseSensitiveFileNames)) { - this.logger.info(`Invoking ${config}:: wildcard for open scriptInfo:: ${info.fileName}`); - this.onWildCardDirectoryWatcherInvoke( - directory, - config, - configFileExistenceInfo.config, - watcher.watcher, - info.fileName - ); - } - }); - }); - } - openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) { - const existing = this.getScriptInfoForPath(normalizedPathToPath( - fileName, - projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory, - this.toCanonicalFileName - )); - const info = this.getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath); - if (!existing && info && !info.isDynamic) this.tryInvokeWildCardDirectories(info); - const { retainProjects, ...result } = this.assignProjectToOpenedScriptInfo(info); - this.cleanupProjectsAndScriptInfos( - retainProjects, - /* @__PURE__ */ new Set([info.path]), - /*externalProjectsRetainingConfiguredProjects*/ - void 0 - ); - this.telemetryOnOpenFile(info); - this.printProjects(); - return result; - } - /** @internal */ - getOrphanConfiguredProjects(toRetainConfiguredProjects, openFilesWithRetainedConfiguredProject, externalProjectsRetainingConfiguredProjects) { - const toRemoveConfiguredProjects = new Set(this.configuredProjects.values()); - const markOriginalProjectsAsUsed = (project) => { - if (project.originalConfiguredProjects && (isConfiguredProject(project) || !project.isOrphan())) { - project.originalConfiguredProjects.forEach( - (_value, configuredProjectPath) => { - const project2 = this.getConfiguredProjectByCanonicalConfigFilePath(configuredProjectPath); - return project2 && retainConfiguredProject(project2); - } - ); - } - }; - toRetainConfiguredProjects == null ? void 0 : toRetainConfiguredProjects.forEach(retainConfiguredProject); - this.inferredProjects.forEach(markOriginalProjectsAsUsed); - this.externalProjects.forEach(markOriginalProjectsAsUsed); - this.externalProjectToConfiguredProjectMap.forEach((projects, externalProjectName) => { - if (!(externalProjectsRetainingConfiguredProjects == null ? void 0 : externalProjectsRetainingConfiguredProjects.has(externalProjectName))) { - projects.forEach(retainConfiguredProject); - } - }); - this.openFiles.forEach((_projectRootPath, path) => { - if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path)) return; - const info = this.getScriptInfoForPath(path); - if (find(info.containingProjects, isExternalProject)) return; - const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo( - info, - 0 /* Find */ - ); - if (result == null ? void 0 : result.defaultProject) { - result == null ? void 0 : result.seenProjects.forEach(retainConfiguredProject); - } - }); - this.configuredProjects.forEach((project) => { - if (toRemoveConfiguredProjects.has(project)) { - if (isPendingUpdate(project) || forEachReferencedProject(project, isRetained)) { - retainConfiguredProject(project); - } - } - }); - return toRemoveConfiguredProjects; - function isRetained(project) { - return !toRemoveConfiguredProjects.has(project) || isPendingUpdate(project); - } - function isPendingUpdate(project) { - var _a, _b; - return (project.deferredClose || project.projectService.hasPendingProjectUpdate(project)) && !!((_b = (_a = project.projectService.configFileExistenceInfoCache.get(project.canonicalConfigFilePath)) == null ? void 0 : _a.openFilesImpactedByConfigFile) == null ? void 0 : _b.size); - } - function retainConfiguredProject(project) { - if (!toRemoveConfiguredProjects.delete(project)) return; - markOriginalProjectsAsUsed(project); - forEachReferencedProject(project, retainConfiguredProject); - } - } - removeOrphanScriptInfos() { - const toRemoveScriptInfos = new Map(this.filenameToScriptInfo); - this.filenameToScriptInfo.forEach((info) => { - if (info.deferredDelete) return; - if (!info.isScriptOpen() && info.isOrphan() && !info.isContainedByBackgroundProject()) { - if (!info.sourceMapFilePath) return; - let sourceInfos; - if (isString(info.sourceMapFilePath)) { - const sourceMapInfo = this.filenameToScriptInfo.get(info.sourceMapFilePath); - sourceInfos = sourceMapInfo == null ? void 0 : sourceMapInfo.sourceInfos; - } else { - sourceInfos = info.sourceMapFilePath.sourceInfos; - } - if (!sourceInfos) return; - if (!forEachKey(sourceInfos, (path) => { - const info2 = this.getScriptInfoForPath(path); - return !!info2 && (info2.isScriptOpen() || !info2.isOrphan()); - })) { - return; - } - } - toRemoveScriptInfos.delete(info.path); - if (info.sourceMapFilePath) { - let sourceInfos; - if (isString(info.sourceMapFilePath)) { - const sourceMapInfo = this.filenameToScriptInfo.get(info.sourceMapFilePath); - if (sourceMapInfo == null ? void 0 : sourceMapInfo.deferredDelete) { - info.sourceMapFilePath = { - watcher: this.addMissingSourceMapFile(sourceMapInfo.fileName, info.path), - sourceInfos: sourceMapInfo.sourceInfos - }; - } else { - toRemoveScriptInfos.delete(info.sourceMapFilePath); - } - sourceInfos = sourceMapInfo == null ? void 0 : sourceMapInfo.sourceInfos; - } else { - sourceInfos = info.sourceMapFilePath.sourceInfos; - } - if (sourceInfos) { - sourceInfos.forEach((_value, path) => toRemoveScriptInfos.delete(path)); - } - } - }); - toRemoveScriptInfos.forEach((info) => this.deleteScriptInfo(info)); - } - telemetryOnOpenFile(scriptInfo) { - if (this.serverMode !== 0 /* Semantic */ || !this.eventHandler || !scriptInfo.isJavaScript() || !addToSeen(this.allJsFilesForOpenFileTelemetry, scriptInfo.path)) { - return; - } - const project = this.ensureDefaultProjectForFile(scriptInfo); - if (!project.languageServiceEnabled) { - return; - } - const sourceFile = project.getSourceFile(scriptInfo.path); - const checkJs = !!sourceFile && !!sourceFile.checkJsDirective; - this.eventHandler({ eventName: OpenFileInfoTelemetryEvent, data: { info: { checkJs } } }); - } - closeClientFile(uncheckedFileName, skipAssignOrphanScriptInfosToInferredProject) { - const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName)); - const result = info ? this.closeOpenFile(info, skipAssignOrphanScriptInfosToInferredProject) : false; - if (!skipAssignOrphanScriptInfosToInferredProject) { - this.printProjects(); - } - return result; - } - collectChanges(lastKnownProjectVersions, currentProjects, includeProjectReferenceRedirectInfo, result) { - for (const proj of currentProjects) { - const knownProject = find(lastKnownProjectVersions, (p) => p.projectName === proj.getProjectName()); - result.push(proj.getChangesSinceVersion(knownProject && knownProject.version, includeProjectReferenceRedirectInfo)); - } - } - /** @internal */ - synchronizeProjectList(knownProjects, includeProjectReferenceRedirectInfo) { - const files = []; - this.collectChanges(knownProjects, this.externalProjects, includeProjectReferenceRedirectInfo, files); - this.collectChanges(knownProjects, mapDefinedIterator(this.configuredProjects.values(), (p) => p.deferredClose ? void 0 : p), includeProjectReferenceRedirectInfo, files); - this.collectChanges(knownProjects, this.inferredProjects, includeProjectReferenceRedirectInfo, files); - return files; - } - /** @internal */ - applyChangesInOpenFiles(openFiles, changedFiles, closedFiles) { - let existingOpenScriptInfos; - let openScriptInfos; - let assignOrphanScriptInfosToInferredProject = false; - if (openFiles) { - for (const file of openFiles) { - (existingOpenScriptInfos ?? (existingOpenScriptInfos = [])).push(this.getScriptInfoForPath(normalizedPathToPath( - toNormalizedPath(file.fileName), - file.projectRootPath ? this.getNormalizedAbsolutePath(file.projectRootPath) : this.currentDirectory, - this.toCanonicalFileName - ))); - const info = this.getOrCreateOpenScriptInfo( - toNormalizedPath(file.fileName), - file.content, - tryConvertScriptKindName(file.scriptKind), - file.hasMixedContent, - file.projectRootPath ? toNormalizedPath(file.projectRootPath) : void 0 - ); - (openScriptInfos || (openScriptInfos = [])).push(info); - } - } - if (changedFiles) { - for (const file of changedFiles) { - const scriptInfo = this.getScriptInfo(file.fileName); - Debug.assert(!!scriptInfo); - this.applyChangesToFile(scriptInfo, file.changes); - } - } - if (closedFiles) { - for (const file of closedFiles) { - assignOrphanScriptInfosToInferredProject = this.closeClientFile( - file, - /*skipAssignOrphanScriptInfosToInferredProject*/ - true - ) || assignOrphanScriptInfosToInferredProject; - } - } - let retainProjects; - forEach( - existingOpenScriptInfos, - (existing, index) => !existing && openScriptInfos[index] && !openScriptInfos[index].isDynamic ? this.tryInvokeWildCardDirectories(openScriptInfos[index]) : void 0 - ); - openScriptInfos == null ? void 0 : openScriptInfos.forEach((info) => { - var _a; - return (_a = this.assignProjectToOpenedScriptInfo(info).retainProjects) == null ? void 0 : _a.forEach((p) => (retainProjects ?? (retainProjects = /* @__PURE__ */ new Set())).add(p)); - }); - if (assignOrphanScriptInfosToInferredProject) { - this.assignOrphanScriptInfosToInferredProject(); - } - if (openScriptInfos) { - this.cleanupProjectsAndScriptInfos( - retainProjects, - new Set(openScriptInfos.map((info) => info.path)), - /*externalProjectsRetainingConfiguredProjects*/ - void 0 - ); - openScriptInfos.forEach((info) => this.telemetryOnOpenFile(info)); - this.printProjects(); - } else if (length(closedFiles)) { - this.printProjects(); - } - } - /** @internal */ - applyChangesToFile(scriptInfo, changes) { - for (const change of changes) { - scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText); - } - } - // eslint-disable-line @typescript-eslint/unified-signatures - closeExternalProject(uncheckedFileName, cleanupAfter) { - const fileName = toNormalizedPath(uncheckedFileName); - const projects = this.externalProjectToConfiguredProjectMap.get(fileName); - if (projects) { - this.externalProjectToConfiguredProjectMap.delete(fileName); - } else { - const externalProject = this.findExternalProjectByProjectName(uncheckedFileName); - if (externalProject) { - this.removeProject(externalProject); - } - } - if (cleanupAfter) { - this.cleanupConfiguredProjects(); - this.printProjects(); - } - } - openExternalProjects(projects) { - const projectsToClose = new Set(this.externalProjects.map((p) => p.getProjectName())); - this.externalProjectToConfiguredProjectMap.forEach((_, externalProjectName) => projectsToClose.add(externalProjectName)); - for (const externalProject of projects) { - this.openExternalProject( - externalProject, - /*cleanupAfter*/ - false - ); - projectsToClose.delete(externalProject.projectFileName); - } - projectsToClose.forEach((externalProjectName) => this.closeExternalProject( - externalProjectName, - /*cleanupAfter*/ - false - )); - this.cleanupConfiguredProjects(); - this.printProjects(); - } - static escapeFilenameForRegex(filename) { - return filename.replace(this.filenameEscapeRegexp, "\\$&"); - } - resetSafeList() { - this.safelist = defaultTypeSafeList; - } - applySafeList(proj) { - const typeAcquisition = proj.typeAcquisition; - Debug.assert(!!typeAcquisition, "proj.typeAcquisition should be set by now"); - const result = this.applySafeListWorker(proj, proj.rootFiles, typeAcquisition); - return (result == null ? void 0 : result.excludedFiles) ?? []; - } - applySafeListWorker(proj, rootFiles, typeAcquisition) { - if (typeAcquisition.enable === false || typeAcquisition.disableFilenameBasedTypeAcquisition) { - return void 0; - } - const typeAcqInclude = typeAcquisition.include || (typeAcquisition.include = []); - const excludeRules = []; - const normalizedNames = rootFiles.map((f) => normalizeSlashes(f.fileName)); - for (const name of Object.keys(this.safelist)) { - const rule2 = this.safelist[name]; - for (const root of normalizedNames) { - if (rule2.match.test(root)) { - this.logger.info(`Excluding files based on rule ${name} matching file '${root}'`); - if (rule2.types) { - for (const type of rule2.types) { - if (!typeAcqInclude.includes(type)) { - typeAcqInclude.push(type); - } - } - } - if (rule2.exclude) { - for (const exclude of rule2.exclude) { - const processedRule = root.replace(rule2.match, (...groups) => { - return exclude.map((groupNumberOrString) => { - if (typeof groupNumberOrString === "number") { - if (!isString(groups[groupNumberOrString])) { - this.logger.info(`Incorrect RegExp specification in safelist rule ${name} - not enough groups`); - return "\\*"; - } - return _ProjectService.escapeFilenameForRegex(groups[groupNumberOrString]); - } - return groupNumberOrString; - }).join(""); - }); - if (!excludeRules.includes(processedRule)) { - excludeRules.push(processedRule); - } - } - } else { - const escaped = _ProjectService.escapeFilenameForRegex(root); - if (!excludeRules.includes(escaped)) { - excludeRules.push(escaped); - } - } - } - } - } - const excludeRegexes = excludeRules.map((e) => new RegExp(e, "i")); - let filesToKeep; - let excludedFiles; - for (let i = 0; i < rootFiles.length; i++) { - if (excludeRegexes.some((re) => re.test(normalizedNames[i]))) { - addExcludedFile(i); - } else { - if (typeAcquisition.enable) { - const baseName = getBaseFileName(toFileNameLowerCase(normalizedNames[i])); - if (fileExtensionIs(baseName, "js")) { - const inferredTypingName = removeFileExtension(baseName); - const cleanedTypingName = removeMinAndVersionNumbers(inferredTypingName); - const typeName = this.legacySafelist.get(cleanedTypingName); - if (typeName !== void 0) { - this.logger.info(`Excluded '${normalizedNames[i]}' because it matched ${cleanedTypingName} from the legacy safelist`); - addExcludedFile(i); - if (!typeAcqInclude.includes(typeName)) { - typeAcqInclude.push(typeName); - } - continue; - } - } - } - if (/^.+[.-]min\.js$/.test(normalizedNames[i])) { - addExcludedFile(i); - } else { - filesToKeep == null ? void 0 : filesToKeep.push(rootFiles[i]); - } - } - } - return excludedFiles ? { - rootFiles: filesToKeep, - excludedFiles - } : void 0; - function addExcludedFile(index) { - if (!excludedFiles) { - Debug.assert(!filesToKeep); - filesToKeep = rootFiles.slice(0, index); - excludedFiles = []; - } - excludedFiles.push(normalizedNames[index]); - } - } - // eslint-disable-line @typescript-eslint/unified-signatures - openExternalProject(proj, cleanupAfter) { - const existingExternalProject = this.findExternalProjectByProjectName(proj.projectFileName); - let configuredProjects; - let rootFiles = []; - for (const file of proj.rootFiles) { - const normalized = toNormalizedPath(file.fileName); - if (getBaseConfigFileName(normalized)) { - if (this.serverMode === 0 /* Semantic */ && this.host.fileExists(normalized)) { - let project = this.findConfiguredProjectByProjectName(normalized); - if (!project) { - project = this.createConfiguredProject(normalized, `Creating configured project in external project: ${proj.projectFileName}`); - if (!this.getHostPreferences().lazyConfiguredProjectsFromExternalProject) project.updateGraph(); - } - (configuredProjects ?? (configuredProjects = /* @__PURE__ */ new Set())).add(project); - Debug.assert(!project.isClosed()); - } - } else { - rootFiles.push(file); - } - } - if (configuredProjects) { - this.externalProjectToConfiguredProjectMap.set(proj.projectFileName, configuredProjects); - if (existingExternalProject) this.removeProject(existingExternalProject); - } else { - this.externalProjectToConfiguredProjectMap.delete(proj.projectFileName); - const typeAcquisition = proj.typeAcquisition || {}; - typeAcquisition.include = typeAcquisition.include || []; - typeAcquisition.exclude = typeAcquisition.exclude || []; - if (typeAcquisition.enable === void 0) { - typeAcquisition.enable = hasNoTypeScriptSource(rootFiles.map((f) => f.fileName)); - } - const excludeResult = this.applySafeListWorker(proj, rootFiles, typeAcquisition); - const excludedFiles = (excludeResult == null ? void 0 : excludeResult.excludedFiles) ?? []; - rootFiles = (excludeResult == null ? void 0 : excludeResult.rootFiles) ?? rootFiles; - if (existingExternalProject) { - existingExternalProject.excludedFiles = excludedFiles; - const compilerOptions = convertCompilerOptions(proj.options); - const watchOptionsAndErrors = convertWatchOptions(proj.options, existingExternalProject.getCurrentDirectory()); - const lastFileExceededProgramSize = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(proj.projectFileName, compilerOptions, rootFiles, externalFilePropertyReader); - if (lastFileExceededProgramSize) { - existingExternalProject.disableLanguageService(lastFileExceededProgramSize); - } else { - existingExternalProject.enableLanguageService(); - } - existingExternalProject.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors); - this.updateRootAndOptionsOfNonInferredProject(existingExternalProject, rootFiles, externalFilePropertyReader, compilerOptions, typeAcquisition, proj.options.compileOnSave, watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions); - existingExternalProject.updateGraph(); - } else { - const project = this.createExternalProject(proj.projectFileName, rootFiles, proj.options, typeAcquisition, excludedFiles); - project.updateGraph(); - } - } - if (cleanupAfter) { - this.cleanupConfiguredProjects( - configuredProjects, - new Set(proj.projectFileName) - ); - this.printProjects(); - } - } - hasDeferredExtension() { - for (const extension of this.hostConfiguration.extraFileExtensions) { - if (extension.scriptKind === 7 /* Deferred */) { - return true; - } - } - return false; - } - /** - * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin either asynchronously or synchronously - * @internal - */ - requestEnablePlugin(project, pluginConfigEntry, searchPaths) { - if (!this.host.importPlugin && !this.host.require) { - this.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded"); - return; - } - this.logger.info(`Enabling plugin ${pluginConfigEntry.name} from candidate paths: ${searchPaths.join(",")}`); - if (!pluginConfigEntry.name || isExternalModuleNameRelative(pluginConfigEntry.name) || /[\\/]\.\.?(?:$|[\\/])/.test(pluginConfigEntry.name)) { - this.logger.info(`Skipped loading plugin ${pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)} because only package name is allowed plugin name`); - return; - } - if (this.host.importPlugin) { - const importPromise = Project2.importServicePluginAsync( - pluginConfigEntry, - searchPaths, - this.host, - (s) => this.logger.info(s) - ); - this.pendingPluginEnablements ?? (this.pendingPluginEnablements = /* @__PURE__ */ new Map()); - let promises = this.pendingPluginEnablements.get(project); - if (!promises) this.pendingPluginEnablements.set(project, promises = []); - promises.push(importPromise); - return; - } - this.endEnablePlugin( - project, - Project2.importServicePluginSync( - pluginConfigEntry, - searchPaths, - this.host, - (s) => this.logger.info(s) - ) - ); - } - /** - * Performs the remaining steps of enabling a plugin after its module has been instantiated. - */ - endEnablePlugin(project, { pluginConfigEntry, resolvedModule, errorLogs }) { - var _a; - if (resolvedModule) { - const configurationOverride = (_a = this.currentPluginConfigOverrides) == null ? void 0 : _a.get(pluginConfigEntry.name); - if (configurationOverride) { - const pluginName = pluginConfigEntry.name; - pluginConfigEntry = configurationOverride; - pluginConfigEntry.name = pluginName; - } - project.enableProxy(resolvedModule, pluginConfigEntry); - } else { - forEach(errorLogs, (message) => this.logger.info(message)); - this.logger.info(`Couldn't find ${pluginConfigEntry.name}`); - } - } - /** @internal */ - hasNewPluginEnablementRequests() { - return !!this.pendingPluginEnablements; - } - /** @internal */ - hasPendingPluginEnablements() { - return !!this.currentPluginEnablementPromise; - } - /** - * Waits for any ongoing plugin enablement requests to complete. - * - * @internal - */ - async waitForPendingPlugins() { - while (this.currentPluginEnablementPromise) { - await this.currentPluginEnablementPromise; - } - } - /** - * Starts enabling any requested plugins without waiting for the result. - * - * @internal - */ - enableRequestedPlugins() { - if (this.pendingPluginEnablements) { - void this.enableRequestedPluginsAsync(); - } - } - async enableRequestedPluginsAsync() { - if (this.currentPluginEnablementPromise) { - await this.waitForPendingPlugins(); - } - if (!this.pendingPluginEnablements) { - return; - } - const entries = arrayFrom(this.pendingPluginEnablements.entries()); - this.pendingPluginEnablements = void 0; - this.currentPluginEnablementPromise = this.enableRequestedPluginsWorker(entries); - await this.currentPluginEnablementPromise; - } - async enableRequestedPluginsWorker(pendingPlugins) { - Debug.assert(this.currentPluginEnablementPromise === void 0); - let sendProjectsUpdatedInBackgroundEvent = false; - await Promise.all(map(pendingPlugins, async ([project, promises]) => { - const results = await Promise.all(promises); - if (project.isClosed() || isProjectDeferredClose(project)) { - this.logger.info(`Cancelling plugin enabling for ${project.getProjectName()} as it is ${project.isClosed() ? "closed" : "deferred close"}`); - return; - } - sendProjectsUpdatedInBackgroundEvent = true; - for (const result of results) { - this.endEnablePlugin(project, result); - } - this.delayUpdateProjectGraph(project); - })); - this.currentPluginEnablementPromise = void 0; - if (sendProjectsUpdatedInBackgroundEvent) this.sendProjectsUpdatedInBackgroundEvent(); - } - configurePlugin(args) { - this.forEachEnabledProject((project) => project.onPluginConfigurationChanged(args.pluginName, args.configuration)); - this.currentPluginConfigOverrides = this.currentPluginConfigOverrides || /* @__PURE__ */ new Map(); - this.currentPluginConfigOverrides.set(args.pluginName, args.configuration); - } - /** @internal */ - getPackageJsonsVisibleToFile(fileName, project, rootDir) { - const packageJsonCache = this.packageJsonCache; - const rootPath = rootDir && this.toPath(rootDir); - const result = []; - const processDirectory = (directory) => { - switch (packageJsonCache.directoryHasPackageJson(directory)) { - case 3 /* Maybe */: - packageJsonCache.searchDirectoryAndAncestors(directory); - return processDirectory(directory); - case -1 /* True */: - const packageJsonFileName = combinePaths(directory, "package.json"); - this.watchPackageJsonFile(packageJsonFileName, this.toPath(packageJsonFileName), project); - const info = packageJsonCache.getInDirectory(directory); - if (info) result.push(info); - } - if (rootPath && rootPath === directory) { - return true; - } - }; - forEachAncestorDirectory(getDirectoryPath(fileName), processDirectory); - return result; - } - /** @internal */ - getNearestAncestorDirectoryWithPackageJson(fileName) { - return forEachAncestorDirectory(fileName, (directory) => { - switch (this.packageJsonCache.directoryHasPackageJson(directory)) { - case -1 /* True */: - return directory; - case 0 /* False */: - return void 0; - case 3 /* Maybe */: - return this.host.fileExists(combinePaths(directory, "package.json")) ? directory : void 0; - } - }); - } - watchPackageJsonFile(file, path, project) { - Debug.assert(project !== void 0); - let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path); - if (!result) { - let watcher = this.watchFactory.watchFile( - file, - (fileName, eventKind) => { - switch (eventKind) { - case 0 /* Created */: - case 1 /* Changed */: - this.packageJsonCache.addOrUpdate(fileName, path); - this.onPackageJsonChange(result); - break; - case 2 /* Deleted */: - this.packageJsonCache.delete(path); - this.onPackageJsonChange(result); - result.projects.clear(); - result.close(); - } - }, - 250 /* Low */, - this.hostConfiguration.watchOptions, - WatchType.PackageJson - ); - result = { - projects: /* @__PURE__ */ new Set(), - close: () => { - var _a; - if (result.projects.size || !watcher) return; - watcher.close(); - watcher = void 0; - (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path); - this.packageJsonCache.invalidate(path); - } - }; - this.packageJsonFilesMap.set(path, result); - } - result.projects.add(project); - (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result); - } - onPackageJsonChange(result) { - result.projects.forEach((project) => { - var _a; - return (_a = project.onPackageJsonChange) == null ? void 0 : _a.call(project); - }); - } - /** @internal */ - includePackageJsonAutoImports() { - switch (this.hostConfiguration.preferences.includePackageJsonAutoImports) { - case "on": - return 1 /* On */; - case "off": - return 0 /* Off */; - default: - return 2 /* Auto */; - } - } - /** @internal */ - getIncompleteCompletionsCache() { - return this.incompleteCompletionsCache || (this.incompleteCompletionsCache = createIncompleteCompletionsCache()); - } -}; -/** Makes a filename safe to insert in a RegExp */ -_ProjectService.filenameEscapeRegexp = /[-/\\^$*+?.()|[\]{}]/g; -var ProjectService2 = _ProjectService; -function createIncompleteCompletionsCache() { - let info; - return { - get() { - return info; - }, - set(newInfo) { - info = newInfo; - }, - clear() { - info = void 0; - } - }; -} -function isConfigFile(config) { - return config.kind !== void 0; -} -function printProjectWithoutFileNames(project) { - project.print( - /*writeProjectFileNames*/ - false, - /*writeFileExplaination*/ - false, - /*writeFileVersionAndText*/ - false - ); -} - -// src/server/moduleSpecifierCache.ts -function createModuleSpecifierCache(host) { - let containedNodeModulesWatchers; - let cache; - let currentKey; - const result = { - get(fromFileName, toFileName2, preferences, options) { - if (!cache || currentKey !== key(fromFileName, preferences, options)) return void 0; - return cache.get(toFileName2); - }, - set(fromFileName, toFileName2, preferences, options, kind, modulePaths, moduleSpecifiers) { - ensureCache(fromFileName, preferences, options).set(toFileName2, createInfo( - kind, - modulePaths, - moduleSpecifiers, - /*packageName*/ - void 0, - /*isBlockedByPackageJsonDependencies*/ - false - )); - if (moduleSpecifiers) { - for (const p of modulePaths) { - if (p.isInNodeModules) { - const nodeModulesPath = p.path.substring(0, p.path.indexOf(nodeModulesPathPart) + nodeModulesPathPart.length - 1); - const key2 = host.toPath(nodeModulesPath); - if (!(containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.has(key2))) { - (containedNodeModulesWatchers || (containedNodeModulesWatchers = /* @__PURE__ */ new Map())).set( - key2, - host.watchNodeModulesForPackageJsonChanges(nodeModulesPath) - ); - } - } - } - } - }, - setModulePaths(fromFileName, toFileName2, preferences, options, modulePaths) { - const cache2 = ensureCache(fromFileName, preferences, options); - const info = cache2.get(toFileName2); - if (info) { - info.modulePaths = modulePaths; - } else { - cache2.set(toFileName2, createInfo( - /*kind*/ - void 0, - modulePaths, - /*moduleSpecifiers*/ - void 0, - /*packageName*/ - void 0, - /*isBlockedByPackageJsonDependencies*/ - void 0 - )); - } - }, - setBlockedByPackageJsonDependencies(fromFileName, toFileName2, preferences, options, packageName, isBlockedByPackageJsonDependencies) { - const cache2 = ensureCache(fromFileName, preferences, options); - const info = cache2.get(toFileName2); - if (info) { - info.isBlockedByPackageJsonDependencies = isBlockedByPackageJsonDependencies; - info.packageName = packageName; - } else { - cache2.set(toFileName2, createInfo( - /*kind*/ - void 0, - /*modulePaths*/ - void 0, - /*moduleSpecifiers*/ - void 0, - packageName, - isBlockedByPackageJsonDependencies - )); - } - }, - clear() { - containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.forEach(closeFileWatcher); - cache == null ? void 0 : cache.clear(); - containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.clear(); - currentKey = void 0; - }, - count() { - return cache ? cache.size : 0; - } - }; - if (Debug.isDebugging) { - Object.defineProperty(result, "__cache", { get: () => cache }); - } - return result; - function ensureCache(fromFileName, preferences, options) { - const newKey = key(fromFileName, preferences, options); - if (cache && currentKey !== newKey) { - result.clear(); - } - currentKey = newKey; - return cache || (cache = /* @__PURE__ */ new Map()); - } - function key(fromFileName, preferences, options) { - return `${fromFileName},${preferences.importModuleSpecifierEnding},${preferences.importModuleSpecifierPreference},${options.overrideImportMode}`; - } - function createInfo(kind, modulePaths, moduleSpecifiers, packageName, isBlockedByPackageJsonDependencies) { - return { kind, modulePaths, moduleSpecifiers, packageName, isBlockedByPackageJsonDependencies }; - } -} - -// src/server/packageJsonCache.ts -function createPackageJsonCache(host) { - const packageJsons = /* @__PURE__ */ new Map(); - const directoriesWithoutPackageJson = /* @__PURE__ */ new Map(); - return { - addOrUpdate, - invalidate, - delete: (fileName) => { - packageJsons.delete(fileName); - directoriesWithoutPackageJson.set(getDirectoryPath(fileName), true); - }, - getInDirectory: (directory) => { - return packageJsons.get(host.toPath(combinePaths(directory, "package.json"))) || void 0; - }, - directoryHasPackageJson: (directory) => directoryHasPackageJson(host.toPath(directory)), - searchDirectoryAndAncestors: (directory) => { - forEachAncestorDirectory(directory, (ancestor) => { - const ancestorPath = host.toPath(ancestor); - if (directoryHasPackageJson(ancestorPath) !== 3 /* Maybe */) { - return true; - } - const packageJsonFileName = combinePaths(ancestor, "package.json"); - if (tryFileExists(host, packageJsonFileName)) { - addOrUpdate(packageJsonFileName, combinePaths(ancestorPath, "package.json")); - } else { - directoriesWithoutPackageJson.set(ancestorPath, true); - } - }); - } - }; - function addOrUpdate(fileName, path) { - const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host)); - packageJsons.set(path, packageJsonInfo); - directoriesWithoutPackageJson.delete(getDirectoryPath(path)); - } - function invalidate(path) { - packageJsons.delete(path); - directoriesWithoutPackageJson.delete(getDirectoryPath(path)); - } - function directoryHasPackageJson(directory) { - return packageJsons.has(combinePaths(directory, "package.json")) ? -1 /* True */ : directoriesWithoutPackageJson.has(directory) ? 0 /* False */ : 3 /* Maybe */; - } -} - -// src/server/session.ts -var nullCancellationToken = { - isCancellationRequested: () => false, - setRequest: () => void 0, - resetRequest: () => void 0 -}; -function hrTimeToMilliseconds(time) { - const seconds = time[0]; - const nanoseconds = time[1]; - return (1e9 * seconds + nanoseconds) / 1e6; -} -function isDeclarationFileInJSOnlyNonConfiguredProject(project, file) { - if ((isInferredProject(project) || isExternalProject(project)) && project.isJsOnlyProject()) { - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - return scriptInfo && !scriptInfo.isJavaScript(); - } - return false; -} -function dtsChangeCanAffectEmit(compilationSettings) { - return getEmitDeclarations(compilationSettings) || !!compilationSettings.emitDecoratorMetadata; -} -function formatDiag(fileName, project, diag2) { - const scriptInfo = project.getScriptInfoForNormalizedPath(fileName); - return { - start: scriptInfo.positionToLineOffset(diag2.start), - end: scriptInfo.positionToLineOffset(diag2.start + diag2.length), - // TODO: GH#18217 - text: flattenDiagnosticMessageText(diag2.messageText, "\n"), - code: diag2.code, - category: diagnosticCategoryName(diag2), - reportsUnnecessary: diag2.reportsUnnecessary, - reportsDeprecated: diag2.reportsDeprecated, - source: diag2.source, - relatedInformation: map(diag2.relatedInformation, formatRelatedInformation) - }; -} -function formatRelatedInformation(info) { - if (!info.file) { - return { - message: flattenDiagnosticMessageText(info.messageText, "\n"), - category: diagnosticCategoryName(info), - code: info.code - }; - } - return { - span: { - start: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start)), - end: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start + info.length)), - // TODO: GH#18217 - file: info.file.fileName - }, - message: flattenDiagnosticMessageText(info.messageText, "\n"), - category: diagnosticCategoryName(info), - code: info.code - }; -} -function convertToLocation(lineAndCharacter) { - return { line: lineAndCharacter.line + 1, offset: lineAndCharacter.character + 1 }; -} -function formatDiagnosticToProtocol(diag2, includeFileName) { - const start = diag2.file && convertToLocation(getLineAndCharacterOfPosition(diag2.file, diag2.start)); - const end = diag2.file && convertToLocation(getLineAndCharacterOfPosition(diag2.file, diag2.start + diag2.length)); - const text = flattenDiagnosticMessageText(diag2.messageText, "\n"); - const { code, source } = diag2; - const category = diagnosticCategoryName(diag2); - const common = { - start, - end, - text, - code, - category, - reportsUnnecessary: diag2.reportsUnnecessary, - reportsDeprecated: diag2.reportsDeprecated, - source, - relatedInformation: map(diag2.relatedInformation, formatRelatedInformation) - }; - return includeFileName ? { ...common, fileName: diag2.file && diag2.file.fileName } : common; -} -function allEditsBeforePos(edits, pos) { - return edits.every((edit) => textSpanEnd(edit.span) < pos); -} -var CommandNames = CommandTypes; -function formatMessage2(msg, logger, byteLength, newLine) { - const verboseLogging = logger.hasLevel(3 /* verbose */); - const json = JSON.stringify(msg); - if (verboseLogging) { - logger.info(`${msg.type}:${stringifyIndented(msg)}`); - } - const len = byteLength(json, "utf8"); - return `Content-Length: ${1 + len}\r -\r -${json}${newLine}`; -} -var MultistepOperation = class { - constructor(operationHost) { - this.operationHost = operationHost; - } - startNew(action) { - this.complete(); - this.requestId = this.operationHost.getCurrentRequestId(); - this.executeAction(action); - } - complete() { - if (this.requestId !== void 0) { - this.operationHost.sendRequestCompletedEvent(this.requestId, this.performanceData); - this.requestId = void 0; - } - this.setTimerHandle(void 0); - this.setImmediateId(void 0); - this.performanceData = void 0; - } - immediate(actionType, action) { - const requestId = this.requestId; - Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "immediate: incorrect request id"); - this.setImmediateId( - this.operationHost.getServerHost().setImmediate(() => { - this.immediateId = void 0; - this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action), this.performanceData); - }, actionType) - ); - } - delay(actionType, ms, action) { - const requestId = this.requestId; - Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "delay: incorrect request id"); - this.setTimerHandle( - this.operationHost.getServerHost().setTimeout( - () => { - this.timerHandle = void 0; - this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action), this.performanceData); - }, - ms, - actionType - ) - ); - } - executeAction(action) { - var _a, _b, _c, _d, _e, _f; - let stop = false; - try { - if (this.operationHost.isCancellationRequested()) { - stop = true; - (_a = tracing) == null ? void 0 : _a.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId, early: true }); - } else { - (_b = tracing) == null ? void 0 : _b.push(tracing.Phase.Session, "stepAction", { seq: this.requestId }); - action(this); - (_c = tracing) == null ? void 0 : _c.pop(); - } - } catch (e) { - (_d = tracing) == null ? void 0 : _d.popAll(); - stop = true; - if (e instanceof OperationCanceledException) { - (_e = tracing) == null ? void 0 : _e.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId }); - } else { - (_f = tracing) == null ? void 0 : _f.instant(tracing.Phase.Session, "stepError", { seq: this.requestId, message: e.message }); - this.operationHost.logError(e, `delayed processing of request ${this.requestId}`); - } - } - this.performanceData = this.operationHost.getPerformanceData(); - if (stop || !this.hasPendingWork()) { - this.complete(); - } - } - setTimerHandle(timerHandle) { - if (this.timerHandle !== void 0) { - this.operationHost.getServerHost().clearTimeout(this.timerHandle); - } - this.timerHandle = timerHandle; - } - setImmediateId(immediateId) { - if (this.immediateId !== void 0) { - this.operationHost.getServerHost().clearImmediate(this.immediateId); - } - this.immediateId = immediateId; - } - hasPendingWork() { - return !!this.timerHandle || !!this.immediateId; - } -}; -function toEvent(eventName, body) { - return { - seq: 0, - type: "event", - event: eventName, - body - }; -} -function combineProjectOutput(defaultValue, getValue, projects, action) { - const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, (project) => action(project, defaultValue)); - if (!isArray(projects) && projects.symLinkedProjects) { - projects.symLinkedProjects.forEach((projects2, path) => { - const value = getValue(path); - outputs.push(...flatMap(projects2, (project) => action(project, value))); - }); - } - return deduplicate(outputs, equateValues); -} -function createDocumentSpanSet(useCaseSensitiveFileNames2) { - return createSet(({ textSpan }) => textSpan.start + 100003 * textSpan.length, getDocumentSpansEqualityComparer(useCaseSensitiveFileNames2)); -} -function getRenameLocationsWorker(projects, defaultProject, initialLocation, findInStrings, findInComments, preferences, useCaseSensitiveFileNames2) { - const perProjectResults = getPerProjectReferences( - projects, - defaultProject, - initialLocation, - /*isForRename*/ - true, - (project, position) => project.getLanguageService().findRenameLocations(position.fileName, position.pos, findInStrings, findInComments, preferences), - (renameLocation, cb) => cb(documentSpanLocation(renameLocation)) - ); - if (isArray(perProjectResults)) { - return perProjectResults; - } - const results = []; - const seen = createDocumentSpanSet(useCaseSensitiveFileNames2); - perProjectResults.forEach((projectResults, project) => { - for (const result of projectResults) { - if (!seen.has(result) && !getMappedLocationForProject(documentSpanLocation(result), project)) { - results.push(result); - seen.add(result); - } - } - }); - return results; -} -function getDefinitionLocation(defaultProject, initialLocation, isForRename) { - const infos = defaultProject.getLanguageService().getDefinitionAtPosition( - initialLocation.fileName, - initialLocation.pos, - /*searchOtherFilesOnly*/ - false, - /*stopAtAlias*/ - isForRename - ); - const info = infos && firstOrUndefined(infos); - return info && !info.isLocal ? { fileName: info.fileName, pos: info.textSpan.start } : void 0; -} -function getReferencesWorker(projects, defaultProject, initialLocation, useCaseSensitiveFileNames2, logger) { - var _a, _b; - const perProjectResults = getPerProjectReferences( - projects, - defaultProject, - initialLocation, - /*isForRename*/ - false, - (project, position) => { - logger.info(`Finding references to ${position.fileName} position ${position.pos} in project ${project.getProjectName()}`); - return project.getLanguageService().findReferences(position.fileName, position.pos); - }, - (referencedSymbol, cb) => { - cb(documentSpanLocation(referencedSymbol.definition)); - for (const ref of referencedSymbol.references) { - cb(documentSpanLocation(ref)); - } - } - ); - if (isArray(perProjectResults)) { - return perProjectResults; - } - const defaultProjectResults = perProjectResults.get(defaultProject); - if (((_b = (_a = defaultProjectResults == null ? void 0 : defaultProjectResults[0]) == null ? void 0 : _a.references[0]) == null ? void 0 : _b.isDefinition) === void 0) { - perProjectResults.forEach((projectResults) => { - for (const referencedSymbol of projectResults) { - for (const ref of referencedSymbol.references) { - delete ref.isDefinition; - } - } - }); - } else { - const knownSymbolSpans = createDocumentSpanSet(useCaseSensitiveFileNames2); - for (const referencedSymbol of defaultProjectResults) { - for (const ref of referencedSymbol.references) { - if (ref.isDefinition) { - knownSymbolSpans.add(ref); - break; - } - } - } - const updatedProjects = /* @__PURE__ */ new Set(); - while (true) { - let progress = false; - perProjectResults.forEach((referencedSymbols, project) => { - if (updatedProjects.has(project)) return; - const updated = project.getLanguageService().updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans); - if (updated) { - updatedProjects.add(project); - progress = true; - } - }); - if (!progress) break; - } - perProjectResults.forEach((referencedSymbols, project) => { - if (updatedProjects.has(project)) return; - for (const referencedSymbol of referencedSymbols) { - for (const ref of referencedSymbol.references) { - ref.isDefinition = false; - } - } - }); - } - const results = []; - const seenRefs = createDocumentSpanSet(useCaseSensitiveFileNames2); - perProjectResults.forEach((projectResults, project) => { - for (const referencedSymbol of projectResults) { - const mappedDefinitionFile = getMappedLocationForProject(documentSpanLocation(referencedSymbol.definition), project); - const definition = mappedDefinitionFile === void 0 ? referencedSymbol.definition : { - ...referencedSymbol.definition, - textSpan: createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length), - // Why would the length be the same in the original? - fileName: mappedDefinitionFile.fileName, - contextSpan: getMappedContextSpanForProject(referencedSymbol.definition, project) - }; - let symbolToAddTo = find(results, (o) => documentSpansEqual(o.definition, definition, useCaseSensitiveFileNames2)); - if (!symbolToAddTo) { - symbolToAddTo = { definition, references: [] }; - results.push(symbolToAddTo); - } - for (const ref of referencedSymbol.references) { - if (!seenRefs.has(ref) && !getMappedLocationForProject(documentSpanLocation(ref), project)) { - seenRefs.add(ref); - symbolToAddTo.references.push(ref); - } - } - } - }); - return results.filter((o) => o.references.length !== 0); -} -function forEachProjectInProjects(projects, path, cb) { - for (const project of isArray(projects) ? projects : projects.projects) { - cb(project, path); - } - if (!isArray(projects) && projects.symLinkedProjects) { - projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => { - for (const project of symlinkedProjects) { - cb(project, symlinkedPath); - } - }); - } -} -function getPerProjectReferences(projects, defaultProject, initialLocation, isForRename, getResultsForPosition, forPositionInResult) { - const resultsMap = /* @__PURE__ */ new Map(); - const queue = createQueue(); - queue.enqueue({ project: defaultProject, location: initialLocation }); - forEachProjectInProjects(projects, initialLocation.fileName, (project, path) => { - const location = { fileName: path, pos: initialLocation.pos }; - queue.enqueue({ project, location }); - }); - const projectService = defaultProject.projectService; - const cancellationToken = defaultProject.getCancellationToken(); - const defaultDefinition = getDefinitionLocation(defaultProject, initialLocation, isForRename); - const getGeneratedDefinition = memoize( - () => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ? defaultDefinition : defaultProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(defaultDefinition) - ); - const getSourceDefinition = memoize( - () => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ? defaultDefinition : defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition) - ); - const searchedProjectKeys = /* @__PURE__ */ new Set(); - onCancellation: - while (!queue.isEmpty()) { - while (!queue.isEmpty()) { - if (cancellationToken.isCancellationRequested()) break onCancellation; - const { project, location } = queue.dequeue(); - if (resultsMap.has(project)) continue; - if (isLocationProjectReferenceRedirect(project, location)) continue; - updateProjectIfDirty(project); - if (!project.containsFile(toNormalizedPath(location.fileName))) { - continue; - } - const projectResults = searchPosition(project, location); - resultsMap.set(project, projectResults ?? emptyArray2); - searchedProjectKeys.add(getProjectKey(project)); - } - if (defaultDefinition) { - projectService.loadAncestorProjectTree(searchedProjectKeys); - projectService.forEachEnabledProject((project) => { - if (cancellationToken.isCancellationRequested()) return; - if (resultsMap.has(project)) return; - const location = mapDefinitionInProject(defaultDefinition, project, getGeneratedDefinition, getSourceDefinition); - if (location) { - queue.enqueue({ project, location }); - } - }); - } - } - if (resultsMap.size === 1) { - return firstIterator(resultsMap.values()); - } - return resultsMap; - function searchPosition(project, location) { - const projectResults = getResultsForPosition(project, location); - if (!projectResults) return void 0; - for (const result of projectResults) { - forPositionInResult(result, (position) => { - const originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(project, position); - if (!originalLocation) return; - const originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName); - for (const project2 of originalScriptInfo.containingProjects) { - if (!project2.isOrphan() && !resultsMap.has(project2)) { - queue.enqueue({ project: project2, location: originalLocation }); - } - } - const symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo); - if (symlinkedProjectsMap) { - symlinkedProjectsMap.forEach((symlinkedProjects, symlinkedPath) => { - for (const symlinkedProject of symlinkedProjects) { - if (!symlinkedProject.isOrphan() && !resultsMap.has(symlinkedProject)) { - queue.enqueue({ project: symlinkedProject, location: { fileName: symlinkedPath, pos: originalLocation.pos } }); - } - } - }); - } - }); - } - return projectResults; - } -} -function mapDefinitionInProject(definition, project, getGeneratedDefinition, getSourceDefinition) { - if (project.containsFile(toNormalizedPath(definition.fileName)) && !isLocationProjectReferenceRedirect(project, definition)) { - return definition; - } - const generatedDefinition = getGeneratedDefinition(); - if (generatedDefinition && project.containsFile(toNormalizedPath(generatedDefinition.fileName))) return generatedDefinition; - const sourceDefinition = getSourceDefinition(); - return sourceDefinition && project.containsFile(toNormalizedPath(sourceDefinition.fileName)) ? sourceDefinition : void 0; -} -function isLocationProjectReferenceRedirect(project, location) { - if (!location) return false; - const program = project.getLanguageService().getProgram(); - if (!program) return false; - const sourceFile = program.getSourceFile(location.fileName); - return !!sourceFile && sourceFile.resolvedPath !== sourceFile.path && sourceFile.resolvedPath !== project.toPath(location.fileName); -} -function getProjectKey(project) { - return isConfiguredProject(project) ? project.canonicalConfigFilePath : project.getProjectName(); -} -function documentSpanLocation({ fileName, textSpan }) { - return { fileName, pos: textSpan.start }; -} -function getMappedLocationForProject(location, project) { - return getMappedLocation(location, project.getSourceMapper(), (p) => project.projectService.fileExists(p)); -} -function getMappedDocumentSpanForProject(documentSpan, project) { - return getMappedDocumentSpan(documentSpan, project.getSourceMapper(), (p) => project.projectService.fileExists(p)); -} -function getMappedContextSpanForProject(documentSpan, project) { - return getMappedContextSpan(documentSpan, project.getSourceMapper(), (p) => project.projectService.fileExists(p)); -} -var invalidPartialSemanticModeCommands = [ - "openExternalProject" /* OpenExternalProject */, - "openExternalProjects" /* OpenExternalProjects */, - "closeExternalProject" /* CloseExternalProject */, - "synchronizeProjectList" /* SynchronizeProjectList */, - "emit-output" /* EmitOutput */, - "compileOnSaveAffectedFileList" /* CompileOnSaveAffectedFileList */, - "compileOnSaveEmitFile" /* CompileOnSaveEmitFile */, - "compilerOptionsDiagnostics-full" /* CompilerOptionsDiagnosticsFull */, - "encodedSemanticClassifications-full" /* EncodedSemanticClassificationsFull */, - "semanticDiagnosticsSync" /* SemanticDiagnosticsSync */, - "suggestionDiagnosticsSync" /* SuggestionDiagnosticsSync */, - "geterrForProject" /* GeterrForProject */, - "reload" /* Reload */, - "reloadProjects" /* ReloadProjects */, - "getCodeFixes" /* GetCodeFixes */, - "getCodeFixes-full" /* GetCodeFixesFull */, - "getCombinedCodeFix" /* GetCombinedCodeFix */, - "getCombinedCodeFix-full" /* GetCombinedCodeFixFull */, - "applyCodeActionCommand" /* ApplyCodeActionCommand */, - "getSupportedCodeFixes" /* GetSupportedCodeFixes */, - "getApplicableRefactors" /* GetApplicableRefactors */, - "getMoveToRefactoringFileSuggestions" /* GetMoveToRefactoringFileSuggestions */, - "getEditsForRefactor" /* GetEditsForRefactor */, - "getEditsForRefactor-full" /* GetEditsForRefactorFull */, - "organizeImports" /* OrganizeImports */, - "organizeImports-full" /* OrganizeImportsFull */, - "getEditsForFileRename" /* GetEditsForFileRename */, - "getEditsForFileRename-full" /* GetEditsForFileRenameFull */, - "prepareCallHierarchy" /* PrepareCallHierarchy */, - "provideCallHierarchyIncomingCalls" /* ProvideCallHierarchyIncomingCalls */, - "provideCallHierarchyOutgoingCalls" /* ProvideCallHierarchyOutgoingCalls */, - "getPasteEdits" /* GetPasteEdits */ -]; -var invalidSyntacticModeCommands = [ - ...invalidPartialSemanticModeCommands, - "definition" /* Definition */, - "definition-full" /* DefinitionFull */, - "definitionAndBoundSpan" /* DefinitionAndBoundSpan */, - "definitionAndBoundSpan-full" /* DefinitionAndBoundSpanFull */, - "typeDefinition" /* TypeDefinition */, - "implementation" /* Implementation */, - "implementation-full" /* ImplementationFull */, - "references" /* References */, - "references-full" /* ReferencesFull */, - "rename" /* Rename */, - "renameLocations-full" /* RenameLocationsFull */, - "rename-full" /* RenameInfoFull */, - "quickinfo" /* Quickinfo */, - "quickinfo-full" /* QuickinfoFull */, - "completionInfo" /* CompletionInfo */, - "completions" /* Completions */, - "completions-full" /* CompletionsFull */, - "completionEntryDetails" /* CompletionDetails */, - "completionEntryDetails-full" /* CompletionDetailsFull */, - "signatureHelp" /* SignatureHelp */, - "signatureHelp-full" /* SignatureHelpFull */, - "navto" /* Navto */, - "navto-full" /* NavtoFull */, - "documentHighlights" /* DocumentHighlights */, - "documentHighlights-full" /* DocumentHighlightsFull */ -]; -var Session3 = class _Session { - constructor(opts) { - this.changeSeq = 0; - // Minimum number of lines for attempting to use region diagnostics for a file. - /** @internal */ - this.regionDiagLineCountThreshold = 500; - this.handlers = new Map(Object.entries({ - // TODO(jakebailey): correctly type the handlers - ["status" /* Status */]: () => { - const response = { version }; - return this.requiredResponse(response); - }, - ["openExternalProject" /* OpenExternalProject */]: (request) => { - this.projectService.openExternalProject( - request.arguments, - /*cleanupAfter*/ - true - ); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["openExternalProjects" /* OpenExternalProjects */]: (request) => { - this.projectService.openExternalProjects(request.arguments.projects); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["closeExternalProject" /* CloseExternalProject */]: (request) => { - this.projectService.closeExternalProject( - request.arguments.projectFileName, - /*cleanupAfter*/ - true - ); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["synchronizeProjectList" /* SynchronizeProjectList */]: (request) => { - const result = this.projectService.synchronizeProjectList(request.arguments.knownProjects, request.arguments.includeProjectReferenceRedirectInfo); - if (!result.some((p) => p.projectErrors && p.projectErrors.length !== 0)) { - return this.requiredResponse(result); - } - const converted = map(result, (p) => { - if (!p.projectErrors || p.projectErrors.length === 0) { - return p; - } - return { - info: p.info, - changes: p.changes, - files: p.files, - projectErrors: this.convertToDiagnosticsWithLinePosition( - p.projectErrors, - /*scriptInfo*/ - void 0 - ) - }; - }); - return this.requiredResponse(converted); - }, - ["updateOpen" /* UpdateOpen */]: (request) => { - this.changeSeq++; - this.projectService.applyChangesInOpenFiles( - request.arguments.openFiles && mapIterator(request.arguments.openFiles, (file) => ({ - fileName: file.file, - content: file.fileContent, - scriptKind: file.scriptKindName, - projectRootPath: file.projectRootPath - })), - request.arguments.changedFiles && mapIterator(request.arguments.changedFiles, (file) => ({ - fileName: file.fileName, - changes: mapDefinedIterator(arrayReverseIterator(file.textChanges), (change) => { - const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(file.fileName)); - const start = scriptInfo.lineOffsetToPosition(change.start.line, change.start.offset); - const end = scriptInfo.lineOffsetToPosition(change.end.line, change.end.offset); - return start >= 0 ? { span: { start, length: end - start }, newText: change.newText } : void 0; - }) - })), - request.arguments.closedFiles - ); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["applyChangedToOpenFiles" /* ApplyChangedToOpenFiles */]: (request) => { - this.changeSeq++; - this.projectService.applyChangesInOpenFiles( - request.arguments.openFiles, - request.arguments.changedFiles && mapIterator(request.arguments.changedFiles, (file) => ({ - fileName: file.fileName, - // apply changes in reverse order - changes: arrayReverseIterator(file.changes) - })), - request.arguments.closedFiles - ); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["exit" /* Exit */]: () => { - this.exit(); - return this.notRequired( - /*request*/ - void 0 - ); - }, - ["definition" /* Definition */]: (request) => { - return this.requiredResponse(this.getDefinition( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["definition-full" /* DefinitionFull */]: (request) => { - return this.requiredResponse(this.getDefinition( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["definitionAndBoundSpan" /* DefinitionAndBoundSpan */]: (request) => { - return this.requiredResponse(this.getDefinitionAndBoundSpan( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["definitionAndBoundSpan-full" /* DefinitionAndBoundSpanFull */]: (request) => { - return this.requiredResponse(this.getDefinitionAndBoundSpan( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["findSourceDefinition" /* FindSourceDefinition */]: (request) => { - return this.requiredResponse(this.findSourceDefinition(request.arguments)); - }, - ["emit-output" /* EmitOutput */]: (request) => { - return this.requiredResponse(this.getEmitOutput(request.arguments)); - }, - ["typeDefinition" /* TypeDefinition */]: (request) => { - return this.requiredResponse(this.getTypeDefinition(request.arguments)); - }, - ["implementation" /* Implementation */]: (request) => { - return this.requiredResponse(this.getImplementation( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["implementation-full" /* ImplementationFull */]: (request) => { - return this.requiredResponse(this.getImplementation( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["references" /* References */]: (request) => { - return this.requiredResponse(this.getReferences( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["references-full" /* ReferencesFull */]: (request) => { - return this.requiredResponse(this.getReferences( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["rename" /* Rename */]: (request) => { - return this.requiredResponse(this.getRenameLocations( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["renameLocations-full" /* RenameLocationsFull */]: (request) => { - return this.requiredResponse(this.getRenameLocations( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["rename-full" /* RenameInfoFull */]: (request) => { - return this.requiredResponse(this.getRenameInfo(request.arguments)); - }, - ["open" /* Open */]: (request) => { - this.openClientFile( - toNormalizedPath(request.arguments.file), - request.arguments.fileContent, - convertScriptKindName(request.arguments.scriptKindName), - // TODO: GH#18217 - request.arguments.projectRootPath ? toNormalizedPath(request.arguments.projectRootPath) : void 0 - ); - return this.notRequired(request); - }, - ["quickinfo" /* Quickinfo */]: (request) => { - return this.requiredResponse(this.getQuickInfoWorker( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["quickinfo-full" /* QuickinfoFull */]: (request) => { - return this.requiredResponse(this.getQuickInfoWorker( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["getOutliningSpans" /* GetOutliningSpans */]: (request) => { - return this.requiredResponse(this.getOutliningSpans( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["outliningSpans" /* GetOutliningSpansFull */]: (request) => { - return this.requiredResponse(this.getOutliningSpans( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["todoComments" /* TodoComments */]: (request) => { - return this.requiredResponse(this.getTodoComments(request.arguments)); - }, - ["indentation" /* Indentation */]: (request) => { - return this.requiredResponse(this.getIndentation(request.arguments)); - }, - ["nameOrDottedNameSpan" /* NameOrDottedNameSpan */]: (request) => { - return this.requiredResponse(this.getNameOrDottedNameSpan(request.arguments)); - }, - ["breakpointStatement" /* BreakpointStatement */]: (request) => { - return this.requiredResponse(this.getBreakpointStatement(request.arguments)); - }, - ["braceCompletion" /* BraceCompletion */]: (request) => { - return this.requiredResponse(this.isValidBraceCompletion(request.arguments)); - }, - ["docCommentTemplate" /* DocCommentTemplate */]: (request) => { - return this.requiredResponse(this.getDocCommentTemplate(request.arguments)); - }, - ["getSpanOfEnclosingComment" /* GetSpanOfEnclosingComment */]: (request) => { - return this.requiredResponse(this.getSpanOfEnclosingComment(request.arguments)); - }, - ["fileReferences" /* FileReferences */]: (request) => { - return this.requiredResponse(this.getFileReferences( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["fileReferences-full" /* FileReferencesFull */]: (request) => { - return this.requiredResponse(this.getFileReferences( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["format" /* Format */]: (request) => { - return this.requiredResponse(this.getFormattingEditsForRange(request.arguments)); - }, - ["formatonkey" /* Formatonkey */]: (request) => { - return this.requiredResponse(this.getFormattingEditsAfterKeystroke(request.arguments)); - }, - ["format-full" /* FormatFull */]: (request) => { - return this.requiredResponse(this.getFormattingEditsForDocumentFull(request.arguments)); - }, - ["formatonkey-full" /* FormatonkeyFull */]: (request) => { - return this.requiredResponse(this.getFormattingEditsAfterKeystrokeFull(request.arguments)); - }, - ["formatRange-full" /* FormatRangeFull */]: (request) => { - return this.requiredResponse(this.getFormattingEditsForRangeFull(request.arguments)); - }, - ["completionInfo" /* CompletionInfo */]: (request) => { - return this.requiredResponse(this.getCompletions(request.arguments, "completionInfo" /* CompletionInfo */)); - }, - ["completions" /* Completions */]: (request) => { - return this.requiredResponse(this.getCompletions(request.arguments, "completions" /* Completions */)); - }, - ["completions-full" /* CompletionsFull */]: (request) => { - return this.requiredResponse(this.getCompletions(request.arguments, "completions-full" /* CompletionsFull */)); - }, - ["completionEntryDetails" /* CompletionDetails */]: (request) => { - return this.requiredResponse(this.getCompletionEntryDetails( - request.arguments, - /*fullResult*/ - false - )); - }, - ["completionEntryDetails-full" /* CompletionDetailsFull */]: (request) => { - return this.requiredResponse(this.getCompletionEntryDetails( - request.arguments, - /*fullResult*/ - true - )); - }, - ["compileOnSaveAffectedFileList" /* CompileOnSaveAffectedFileList */]: (request) => { - return this.requiredResponse(this.getCompileOnSaveAffectedFileList(request.arguments)); - }, - ["compileOnSaveEmitFile" /* CompileOnSaveEmitFile */]: (request) => { - return this.requiredResponse(this.emitFile(request.arguments)); - }, - ["signatureHelp" /* SignatureHelp */]: (request) => { - return this.requiredResponse(this.getSignatureHelpItems( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["signatureHelp-full" /* SignatureHelpFull */]: (request) => { - return this.requiredResponse(this.getSignatureHelpItems( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["compilerOptionsDiagnostics-full" /* CompilerOptionsDiagnosticsFull */]: (request) => { - return this.requiredResponse(this.getCompilerOptionsDiagnostics(request.arguments)); - }, - ["encodedSyntacticClassifications-full" /* EncodedSyntacticClassificationsFull */]: (request) => { - return this.requiredResponse(this.getEncodedSyntacticClassifications(request.arguments)); - }, - ["encodedSemanticClassifications-full" /* EncodedSemanticClassificationsFull */]: (request) => { - return this.requiredResponse(this.getEncodedSemanticClassifications(request.arguments)); - }, - ["cleanup" /* Cleanup */]: () => { - this.cleanup(); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["semanticDiagnosticsSync" /* SemanticDiagnosticsSync */]: (request) => { - return this.requiredResponse(this.getSemanticDiagnosticsSync(request.arguments)); - }, - ["syntacticDiagnosticsSync" /* SyntacticDiagnosticsSync */]: (request) => { - return this.requiredResponse(this.getSyntacticDiagnosticsSync(request.arguments)); - }, - ["suggestionDiagnosticsSync" /* SuggestionDiagnosticsSync */]: (request) => { - return this.requiredResponse(this.getSuggestionDiagnosticsSync(request.arguments)); - }, - ["geterr" /* Geterr */]: (request) => { - this.errorCheck.startNew((next) => this.getDiagnostics(next, request.arguments.delay, request.arguments.files)); - return this.notRequired( - /*request*/ - void 0 - ); - }, - ["geterrForProject" /* GeterrForProject */]: (request) => { - this.errorCheck.startNew((next) => this.getDiagnosticsForProject(next, request.arguments.delay, request.arguments.file)); - return this.notRequired( - /*request*/ - void 0 - ); - }, - ["change" /* Change */]: (request) => { - this.change(request.arguments); - return this.notRequired(request); - }, - ["configure" /* Configure */]: (request) => { - this.projectService.setHostConfiguration(request.arguments); - return this.notRequired(request); - }, - ["reload" /* Reload */]: (request) => { - this.reload(request.arguments); - return this.requiredResponse({ reloadFinished: true }); - }, - ["saveto" /* Saveto */]: (request) => { - const savetoArgs = request.arguments; - this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile); - return this.notRequired(request); - }, - ["close" /* Close */]: (request) => { - const closeArgs = request.arguments; - this.closeClientFile(closeArgs.file); - return this.notRequired(request); - }, - ["navto" /* Navto */]: (request) => { - return this.requiredResponse(this.getNavigateToItems( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["navto-full" /* NavtoFull */]: (request) => { - return this.requiredResponse(this.getNavigateToItems( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["brace" /* Brace */]: (request) => { - return this.requiredResponse(this.getBraceMatching( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["brace-full" /* BraceFull */]: (request) => { - return this.requiredResponse(this.getBraceMatching( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["navbar" /* NavBar */]: (request) => { - return this.requiredResponse(this.getNavigationBarItems( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["navbar-full" /* NavBarFull */]: (request) => { - return this.requiredResponse(this.getNavigationBarItems( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["navtree" /* NavTree */]: (request) => { - return this.requiredResponse(this.getNavigationTree( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["navtree-full" /* NavTreeFull */]: (request) => { - return this.requiredResponse(this.getNavigationTree( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["documentHighlights" /* DocumentHighlights */]: (request) => { - return this.requiredResponse(this.getDocumentHighlights( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["documentHighlights-full" /* DocumentHighlightsFull */]: (request) => { - return this.requiredResponse(this.getDocumentHighlights( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["compilerOptionsForInferredProjects" /* CompilerOptionsForInferredProjects */]: (request) => { - this.setCompilerOptionsForInferredProjects(request.arguments); - return this.requiredResponse( - /*response*/ - true - ); - }, - ["projectInfo" /* ProjectInfo */]: (request) => { - return this.requiredResponse(this.getProjectInfo(request.arguments)); - }, - ["reloadProjects" /* ReloadProjects */]: (request) => { - this.projectService.reloadProjects(); - return this.notRequired(request); - }, - ["jsxClosingTag" /* JsxClosingTag */]: (request) => { - return this.requiredResponse(this.getJsxClosingTag(request.arguments)); - }, - ["linkedEditingRange" /* LinkedEditingRange */]: (request) => { - return this.requiredResponse(this.getLinkedEditingRange(request.arguments)); - }, - ["getCodeFixes" /* GetCodeFixes */]: (request) => { - return this.requiredResponse(this.getCodeFixes( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["getCodeFixes-full" /* GetCodeFixesFull */]: (request) => { - return this.requiredResponse(this.getCodeFixes( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["getCombinedCodeFix" /* GetCombinedCodeFix */]: (request) => { - return this.requiredResponse(this.getCombinedCodeFix( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["getCombinedCodeFix-full" /* GetCombinedCodeFixFull */]: (request) => { - return this.requiredResponse(this.getCombinedCodeFix( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["applyCodeActionCommand" /* ApplyCodeActionCommand */]: (request) => { - return this.requiredResponse(this.applyCodeActionCommand(request.arguments)); - }, - ["getSupportedCodeFixes" /* GetSupportedCodeFixes */]: (request) => { - return this.requiredResponse(this.getSupportedCodeFixes(request.arguments)); - }, - ["getApplicableRefactors" /* GetApplicableRefactors */]: (request) => { - return this.requiredResponse(this.getApplicableRefactors(request.arguments)); - }, - ["getEditsForRefactor" /* GetEditsForRefactor */]: (request) => { - return this.requiredResponse(this.getEditsForRefactor( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["getMoveToRefactoringFileSuggestions" /* GetMoveToRefactoringFileSuggestions */]: (request) => { - return this.requiredResponse(this.getMoveToRefactoringFileSuggestions(request.arguments)); - }, - ["getPasteEdits" /* GetPasteEdits */]: (request) => { - return this.requiredResponse(this.getPasteEdits(request.arguments)); - }, - ["getEditsForRefactor-full" /* GetEditsForRefactorFull */]: (request) => { - return this.requiredResponse(this.getEditsForRefactor( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["organizeImports" /* OrganizeImports */]: (request) => { - return this.requiredResponse(this.organizeImports( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["organizeImports-full" /* OrganizeImportsFull */]: (request) => { - return this.requiredResponse(this.organizeImports( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["getEditsForFileRename" /* GetEditsForFileRename */]: (request) => { - return this.requiredResponse(this.getEditsForFileRename( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["getEditsForFileRename-full" /* GetEditsForFileRenameFull */]: (request) => { - return this.requiredResponse(this.getEditsForFileRename( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["configurePlugin" /* ConfigurePlugin */]: (request) => { - this.configurePlugin(request.arguments); - return this.notRequired(request); - }, - ["selectionRange" /* SelectionRange */]: (request) => { - return this.requiredResponse(this.getSmartSelectionRange( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["selectionRange-full" /* SelectionRangeFull */]: (request) => { - return this.requiredResponse(this.getSmartSelectionRange( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["prepareCallHierarchy" /* PrepareCallHierarchy */]: (request) => { - return this.requiredResponse(this.prepareCallHierarchy(request.arguments)); - }, - ["provideCallHierarchyIncomingCalls" /* ProvideCallHierarchyIncomingCalls */]: (request) => { - return this.requiredResponse(this.provideCallHierarchyIncomingCalls(request.arguments)); - }, - ["provideCallHierarchyOutgoingCalls" /* ProvideCallHierarchyOutgoingCalls */]: (request) => { - return this.requiredResponse(this.provideCallHierarchyOutgoingCalls(request.arguments)); - }, - ["toggleLineComment" /* ToggleLineComment */]: (request) => { - return this.requiredResponse(this.toggleLineComment( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["toggleLineComment-full" /* ToggleLineCommentFull */]: (request) => { - return this.requiredResponse(this.toggleLineComment( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["toggleMultilineComment" /* ToggleMultilineComment */]: (request) => { - return this.requiredResponse(this.toggleMultilineComment( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["toggleMultilineComment-full" /* ToggleMultilineCommentFull */]: (request) => { - return this.requiredResponse(this.toggleMultilineComment( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["commentSelection" /* CommentSelection */]: (request) => { - return this.requiredResponse(this.commentSelection( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["commentSelection-full" /* CommentSelectionFull */]: (request) => { - return this.requiredResponse(this.commentSelection( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["uncommentSelection" /* UncommentSelection */]: (request) => { - return this.requiredResponse(this.uncommentSelection( - request.arguments, - /*simplifiedResult*/ - true - )); - }, - ["uncommentSelection-full" /* UncommentSelectionFull */]: (request) => { - return this.requiredResponse(this.uncommentSelection( - request.arguments, - /*simplifiedResult*/ - false - )); - }, - ["provideInlayHints" /* ProvideInlayHints */]: (request) => { - return this.requiredResponse(this.provideInlayHints(request.arguments)); - }, - ["mapCode" /* MapCode */]: (request) => { - return this.requiredResponse(this.mapCode(request.arguments)); - } - })); - this.host = opts.host; - this.cancellationToken = opts.cancellationToken; - this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller; - this.byteLength = opts.byteLength; - this.hrtime = opts.hrtime; - this.logger = opts.logger; - this.canUseEvents = opts.canUseEvents; - this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents; - this.noGetErrOnBackgroundUpdate = opts.noGetErrOnBackgroundUpdate; - const { throttleWaitMilliseconds } = opts; - this.eventHandler = this.canUseEvents ? opts.eventHandler || ((event) => this.defaultEventHandler(event)) : void 0; - const multistepOperationHost = { - executeWithRequestId: (requestId, action, performanceData) => this.executeWithRequestId(requestId, action, performanceData), - getCurrentRequestId: () => this.currentRequestId, - getPerformanceData: () => this.performanceData, - getServerHost: () => this.host, - logError: (err, cmd) => this.logError(err, cmd), - sendRequestCompletedEvent: (requestId, performanceData) => this.sendRequestCompletedEvent(requestId, performanceData), - isCancellationRequested: () => this.cancellationToken.isCancellationRequested() - }; - this.errorCheck = new MultistepOperation(multistepOperationHost); - const settings = { - host: this.host, - logger: this.logger, - cancellationToken: this.cancellationToken, - useSingleInferredProject: opts.useSingleInferredProject, - useInferredProjectPerProjectRoot: opts.useInferredProjectPerProjectRoot, - typingsInstaller: this.typingsInstaller, - throttleWaitMilliseconds, - eventHandler: this.eventHandler, - suppressDiagnosticEvents: this.suppressDiagnosticEvents, - globalPlugins: opts.globalPlugins, - pluginProbeLocations: opts.pluginProbeLocations, - allowLocalPluginLoads: opts.allowLocalPluginLoads, - typesMapLocation: opts.typesMapLocation, - serverMode: opts.serverMode, - session: this, - canUseWatchEvents: opts.canUseWatchEvents, - incrementalVerifier: opts.incrementalVerifier - }; - this.projectService = new ProjectService2(settings); - this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this)); - this.gcTimer = new GcTimer( - this.host, - /*delay*/ - 7e3, - this.logger - ); - switch (this.projectService.serverMode) { - case 0 /* Semantic */: - break; - case 1 /* PartialSemantic */: - invalidPartialSemanticModeCommands.forEach( - (commandName) => this.handlers.set(commandName, (request) => { - throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.PartialSemantic`); - }) - ); - break; - case 2 /* Syntactic */: - invalidSyntacticModeCommands.forEach( - (commandName) => this.handlers.set(commandName, (request) => { - throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`); - }) - ); - break; - default: - Debug.assertNever(this.projectService.serverMode); - } - } - sendRequestCompletedEvent(requestId, performanceData) { - this.event( - { - request_seq: requestId, - performanceData: performanceData && toProtocolPerformanceData(performanceData) - }, - "requestCompleted" - ); - } - addPerformanceData(key, value) { - if (!this.performanceData) { - this.performanceData = {}; - } - this.performanceData[key] = (this.performanceData[key] ?? 0) + value; - } - addDiagnosticsPerformanceData(file, kind, duration) { - var _a, _b; - if (!this.performanceData) { - this.performanceData = {}; - } - let fileDiagnosticDuration = (_a = this.performanceData.diagnosticsDuration) == null ? void 0 : _a.get(file); - if (!fileDiagnosticDuration) ((_b = this.performanceData).diagnosticsDuration ?? (_b.diagnosticsDuration = /* @__PURE__ */ new Map())).set(file, fileDiagnosticDuration = {}); - fileDiagnosticDuration[kind] = duration; - } - performanceEventHandler(event) { - switch (event.kind) { - case "UpdateGraph": - this.addPerformanceData("updateGraphDurationMs", event.durationMs); - break; - case "CreatePackageJsonAutoImportProvider": - this.addPerformanceData("createAutoImportProviderProgramDurationMs", event.durationMs); - break; - } - } - defaultEventHandler(event) { - switch (event.eventName) { - case ProjectsUpdatedInBackgroundEvent: - this.projectsUpdatedInBackgroundEvent(event.data.openFiles); - break; - case ProjectLoadingStartEvent: - this.event({ - projectName: event.data.project.getProjectName(), - reason: event.data.reason - }, event.eventName); - break; - case ProjectLoadingFinishEvent: - this.event({ - projectName: event.data.project.getProjectName() - }, event.eventName); - break; - case LargeFileReferencedEvent: - case CreateFileWatcherEvent: - case CreateDirectoryWatcherEvent: - case CloseFileWatcherEvent: - this.event(event.data, event.eventName); - break; - case ConfigFileDiagEvent: - this.event({ - triggerFile: event.data.triggerFile, - configFile: event.data.configFileName, - diagnostics: map(event.data.diagnostics, (diagnostic) => formatDiagnosticToProtocol( - diagnostic, - /*includeFileName*/ - true - )) - }, event.eventName); - break; - case ProjectLanguageServiceStateEvent: { - this.event({ - projectName: event.data.project.getProjectName(), - languageServiceEnabled: event.data.languageServiceEnabled - }, event.eventName); - break; - } - case ProjectInfoTelemetryEvent: { - const eventName = "telemetry"; - this.event({ - telemetryEventName: event.eventName, - payload: event.data - }, eventName); - break; - } - } - } - projectsUpdatedInBackgroundEvent(openFiles) { - this.projectService.logger.info(`got projects updated in background ${openFiles}`); - if (openFiles.length) { - if (!this.suppressDiagnosticEvents && !this.noGetErrOnBackgroundUpdate) { - this.projectService.logger.info(`Queueing diagnostics update for ${openFiles}`); - this.errorCheck.startNew((next) => this.updateErrorCheck( - next, - openFiles, - 100, - /*requireOpen*/ - true - )); - } - this.event({ - openFiles - }, ProjectsUpdatedInBackgroundEvent); - } - } - logError(err, cmd) { - this.logErrorWorker(err, cmd); - } - logErrorWorker(err, cmd, fileRequest) { - let msg = "Exception on executing command " + cmd; - if (err.message) { - msg += ":\n" + indent2(err.message); - if (err.stack) { - msg += "\n" + indent2(err.stack); - } - } - if (this.logger.hasLevel(3 /* verbose */)) { - if (fileRequest) { - try { - const { file, project } = this.getFileAndProject(fileRequest); - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - if (scriptInfo) { - const text = getSnapshotText(scriptInfo.getSnapshot()); - msg += ` - -File text of ${fileRequest.file}:${indent2(text)} -`; - } - } catch { - } - } - if (err.ProgramFiles) { - msg += ` - -Program files: ${JSON.stringify(err.ProgramFiles)} -`; - msg += ` - -Projects:: -`; - let counter = 0; - const addProjectInfo = (project) => { - msg += ` -Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter} -`; - msg += project.filesToString( - /*writeProjectFileNames*/ - true - ); - msg += "\n-----------------------------------------------\n"; - counter++; - }; - this.projectService.externalProjects.forEach(addProjectInfo); - this.projectService.configuredProjects.forEach(addProjectInfo); - this.projectService.inferredProjects.forEach(addProjectInfo); - } - } - this.logger.msg(msg, "Err" /* Err */); - } - send(msg) { - if (msg.type === "event" && !this.canUseEvents) { - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`Session does not support events: ignored event: ${stringifyIndented(msg)}`); - } - return; - } - this.writeMessage(msg); - } - writeMessage(msg) { - const msgText = formatMessage2(msg, this.logger, this.byteLength, this.host.newLine); - this.host.write(msgText); - } - event(body, eventName) { - this.send(toEvent(eventName, body)); - } - /** @internal */ - doOutput(info, cmdName, reqSeq, success, performanceData, message) { - const res = { - seq: 0, - type: "response", - command: cmdName, - request_seq: reqSeq, - success, - performanceData: performanceData && toProtocolPerformanceData(performanceData) - }; - if (success) { - let metadata; - if (isArray(info)) { - res.body = info; - metadata = info.metadata; - delete info.metadata; - } else if (typeof info === "object") { - if (info.metadata) { - const { metadata: infoMetadata, ...body } = info; - res.body = body; - metadata = infoMetadata; - } else { - res.body = info; - } - } else { - res.body = info; - } - if (metadata) res.metadata = metadata; - } else { - Debug.assert(info === void 0); - } - if (message) { - res.message = message; - } - this.send(res); - } - semanticCheck(file, project) { - var _a, _b; - const diagnosticsStartTime = timestamp(); - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "semanticCheck", { file, configFilePath: project.canonicalConfigFilePath }); - const diags = isDeclarationFileInJSOnlyNonConfiguredProject(project, file) ? emptyArray2 : project.getLanguageService().getSemanticDiagnostics(file).filter((d) => !!d.file); - this.sendDiagnosticsEvent(file, project, diags, "semanticDiag", diagnosticsStartTime); - (_b = tracing) == null ? void 0 : _b.pop(); - } - syntacticCheck(file, project) { - var _a, _b; - const diagnosticsStartTime = timestamp(); - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "syntacticCheck", { file, configFilePath: project.canonicalConfigFilePath }); - this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSyntacticDiagnostics(file), "syntaxDiag", diagnosticsStartTime); - (_b = tracing) == null ? void 0 : _b.pop(); - } - suggestionCheck(file, project) { - var _a, _b; - const diagnosticsStartTime = timestamp(); - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "suggestionCheck", { file, configFilePath: project.canonicalConfigFilePath }); - this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSuggestionDiagnostics(file), "suggestionDiag", diagnosticsStartTime); - (_b = tracing) == null ? void 0 : _b.pop(); - } - regionSemanticCheck(file, project, ranges) { - var _a, _b, _c; - const diagnosticsStartTime = timestamp(); - (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.Session, "regionSemanticCheck", { file, configFilePath: project.canonicalConfigFilePath }); - let diagnosticsResult; - if (!this.shouldDoRegionCheck(file) || !(diagnosticsResult = project.getLanguageService().getRegionSemanticDiagnostics(file, ranges))) { - (_b = tracing) == null ? void 0 : _b.pop(); - return; - } - this.sendDiagnosticsEvent(file, project, diagnosticsResult.diagnostics, "regionSemanticDiag", diagnosticsStartTime, diagnosticsResult.spans); - (_c = tracing) == null ? void 0 : _c.pop(); - return; - } - // We should only do the region-based semantic check if we think it would be - // considerably faster than a whole-file semantic check. - /** @internal */ - shouldDoRegionCheck(file) { - var _a; - const lineCount = (_a = this.projectService.getScriptInfoForNormalizedPath(file)) == null ? void 0 : _a.textStorage.getLineInfo().getLineCount(); - return !!(lineCount && lineCount >= this.regionDiagLineCountThreshold); - } - sendDiagnosticsEvent(file, project, diagnostics, kind, diagnosticsStartTime, spans) { - try { - const scriptInfo = Debug.checkDefined(project.getScriptInfo(file)); - const duration = timestamp() - diagnosticsStartTime; - const body = { - file, - diagnostics: diagnostics.map((diag2) => formatDiag(file, project, diag2)), - spans: spans == null ? void 0 : spans.map((span) => toProtocolTextSpan(span, scriptInfo)) - }; - this.event( - body, - kind - ); - this.addDiagnosticsPerformanceData(file, kind, duration); - } catch (err) { - this.logError(err, kind); - } - } - /** It is the caller's responsibility to verify that `!this.suppressDiagnosticEvents`. */ - updateErrorCheck(next, checkList, ms, requireOpen = true) { - if (checkList.length === 0) { - return; - } - Debug.assert(!this.suppressDiagnosticEvents); - const seq = this.changeSeq; - const followMs = Math.min(ms, 200); - let index = 0; - const goNext = () => { - index++; - if (checkList.length > index) { - return next.delay("checkOne", followMs, checkOne); - } - }; - const doSemanticCheck = (fileName, project) => { - this.semanticCheck(fileName, project); - if (this.changeSeq !== seq) { - return; - } - if (this.getPreferences(fileName).disableSuggestions) { - return goNext(); - } - next.immediate("suggestionCheck", () => { - this.suggestionCheck(fileName, project); - goNext(); - }); - }; - const checkOne = () => { - if (this.changeSeq !== seq) { - return; - } - let ranges; - let item = checkList[index]; - if (isString(item)) { - item = this.toPendingErrorCheck(item); - } else if ("ranges" in item) { - ranges = item.ranges; - item = this.toPendingErrorCheck(item.file); - } - if (!item) { - return goNext(); - } - const { fileName, project } = item; - updateProjectIfDirty(project); - if (!project.containsFile(fileName, requireOpen)) { - return; - } - this.syntacticCheck(fileName, project); - if (this.changeSeq !== seq) { - return; - } - if (project.projectService.serverMode !== 0 /* Semantic */) { - return goNext(); - } - if (ranges) { - return next.immediate("regionSemanticCheck", () => { - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(fileName); - if (scriptInfo) { - this.regionSemanticCheck(fileName, project, ranges.map((range) => this.getRange({ file: fileName, ...range }, scriptInfo))); - } - if (this.changeSeq !== seq) { - return; - } - next.immediate("semanticCheck", () => doSemanticCheck(fileName, project)); - }); - } - next.immediate("semanticCheck", () => doSemanticCheck(fileName, project)); - }; - if (checkList.length > index && this.changeSeq === seq) { - next.delay("checkOne", ms, checkOne); - } - } - cleanProjects(caption, projects) { - if (!projects) { - return; - } - this.logger.info(`cleaning ${caption}`); - for (const p of projects) { - p.getLanguageService( - /*ensureSynchronized*/ - false - ).cleanupSemanticCache(); - p.cleanupProgram(); - } - } - cleanup() { - this.cleanProjects("inferred projects", this.projectService.inferredProjects); - this.cleanProjects("configured projects", arrayFrom(this.projectService.configuredProjects.values())); - this.cleanProjects("external projects", this.projectService.externalProjects); - if (this.host.gc) { - this.logger.info(`host.gc()`); - this.host.gc(); - } - } - getEncodedSyntacticClassifications(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - return languageService.getEncodedSyntacticClassifications(file, args); - } - getEncodedSemanticClassifications(args) { - const { file, project } = this.getFileAndProject(args); - const format = args.format === "2020" ? "2020" /* TwentyTwenty */ : "original" /* Original */; - return project.getLanguageService().getEncodedSemanticClassifications(file, args, format); - } - getProject(projectFileName) { - return projectFileName === void 0 ? void 0 : this.projectService.findProject(projectFileName); - } - getConfigFileAndProject(args) { - const project = this.getProject(args.projectFileName); - const file = toNormalizedPath(args.file); - return { - configFile: project && project.hasConfigFile(file) ? file : void 0, - project - }; - } - getConfigFileDiagnostics(configFile, project, includeLinePosition) { - const projectErrors = project.getAllProjectErrors(); - const optionsErrors = project.getLanguageService().getCompilerOptionsDiagnostics(); - const diagnosticsForConfigFile = filter( - concatenate(projectErrors, optionsErrors), - (diagnostic) => !!diagnostic.file && diagnostic.file.fileName === configFile - ); - return includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnosticsForConfigFile) : map( - diagnosticsForConfigFile, - (diagnostic) => formatDiagnosticToProtocol( - diagnostic, - /*includeFileName*/ - false - ) - ); - } - convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) { - return diagnostics.map((d) => ({ - message: flattenDiagnosticMessageText(d.messageText, this.host.newLine), - start: d.start, - // TODO: GH#18217 - length: d.length, - // TODO: GH#18217 - category: diagnosticCategoryName(d), - code: d.code, - source: d.source, - startLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start)), - // TODO: GH#18217 - endLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start + d.length)), - // TODO: GH#18217 - reportsUnnecessary: d.reportsUnnecessary, - reportsDeprecated: d.reportsDeprecated, - relatedInformation: map(d.relatedInformation, formatRelatedInformation) - })); - } - getCompilerOptionsDiagnostics(args) { - const project = this.getProject(args.projectFileName); - return this.convertToDiagnosticsWithLinePosition( - filter( - project.getLanguageService().getCompilerOptionsDiagnostics(), - (diagnostic) => !diagnostic.file - ), - /*scriptInfo*/ - void 0 - ); - } - convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo) { - return diagnostics.map( - (d) => ({ - message: flattenDiagnosticMessageText(d.messageText, this.host.newLine), - start: d.start, - length: d.length, - category: diagnosticCategoryName(d), - code: d.code, - source: d.source, - startLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start), - // TODO: GH#18217 - endLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start + d.length), - reportsUnnecessary: d.reportsUnnecessary, - reportsDeprecated: d.reportsDeprecated, - relatedInformation: map(d.relatedInformation, formatRelatedInformation) - }) - ); - } - getDiagnosticsWorker(args, isSemantic, selector, includeLinePosition) { - const { project, file } = this.getFileAndProject(args); - if (isSemantic && isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) { - return emptyArray2; - } - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - const diagnostics = selector(project, file); - return includeLinePosition ? this.convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo) : diagnostics.map((d) => formatDiag(file, project, d)); - } - getDefinition(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const definitions = this.mapDefinitionInfoLocations(project.getLanguageService().getDefinitionAtPosition(file, position) || emptyArray2, project); - return simplifiedResult ? this.mapDefinitionInfo(definitions, project) : definitions.map(_Session.mapToOriginalLocation); - } - mapDefinitionInfoLocations(definitions, project) { - return definitions.map((info) => { - const newDocumentSpan = getMappedDocumentSpanForProject(info, project); - return !newDocumentSpan ? info : { - ...newDocumentSpan, - containerKind: info.containerKind, - containerName: info.containerName, - kind: info.kind, - name: info.name, - failedAliasResolution: info.failedAliasResolution, - ...info.unverified && { unverified: info.unverified } - }; - }); - } - getDefinitionAndBoundSpan(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const scriptInfo = Debug.checkDefined(project.getScriptInfo(file)); - const unmappedDefinitionAndBoundSpan = project.getLanguageService().getDefinitionAndBoundSpan(file, position); - if (!unmappedDefinitionAndBoundSpan || !unmappedDefinitionAndBoundSpan.definitions) { - return { - definitions: emptyArray2, - textSpan: void 0 - // TODO: GH#18217 - }; - } - const definitions = this.mapDefinitionInfoLocations(unmappedDefinitionAndBoundSpan.definitions, project); - const { textSpan } = unmappedDefinitionAndBoundSpan; - if (simplifiedResult) { - return { - definitions: this.mapDefinitionInfo(definitions, project), - textSpan: toProtocolTextSpan(textSpan, scriptInfo) - }; - } - return { - definitions: definitions.map(_Session.mapToOriginalLocation), - textSpan - }; - } - findSourceDefinition(args) { - var _a; - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const unmappedDefinitions = project.getLanguageService().getDefinitionAtPosition(file, position); - let definitions = this.mapDefinitionInfoLocations(unmappedDefinitions || emptyArray2, project).slice(); - const needsJsResolution = this.projectService.serverMode === 0 /* Semantic */ && (!some(definitions, (d) => toNormalizedPath(d.fileName) !== file && !d.isAmbient) || some(definitions, (d) => !!d.failedAliasResolution)); - if (needsJsResolution) { - const definitionSet = createSet( - (d) => d.textSpan.start, - getDocumentSpansEqualityComparer(this.host.useCaseSensitiveFileNames) - ); - definitions == null ? void 0 : definitions.forEach((d) => definitionSet.add(d)); - const noDtsProject = project.getNoDtsResolutionProject(file); - const ls = noDtsProject.getLanguageService(); - const jsDefinitions = (_a = ls.getDefinitionAtPosition( - file, - position, - /*searchOtherFilesOnly*/ - true, - /*stopAtAlias*/ - false - )) == null ? void 0 : _a.filter((d) => toNormalizedPath(d.fileName) !== file); - if (some(jsDefinitions)) { - for (const jsDefinition of jsDefinitions) { - if (jsDefinition.unverified) { - const refined = tryRefineDefinition(jsDefinition, project.getLanguageService().getProgram(), ls.getProgram()); - if (some(refined)) { - for (const def of refined) { - definitionSet.add(def); - } - continue; - } - } - definitionSet.add(jsDefinition); - } - } else { - const ambientCandidates = definitions.filter((d) => toNormalizedPath(d.fileName) !== file && d.isAmbient); - for (const candidate of some(ambientCandidates) ? ambientCandidates : getAmbientCandidatesByClimbingAccessChain()) { - const fileNameToSearch = findImplementationFileFromDtsFileName(candidate.fileName, file, noDtsProject); - if (!fileNameToSearch) continue; - const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient( - fileNameToSearch, - noDtsProject.currentDirectory, - noDtsProject.directoryStructureHost, - /*deferredDeleteOk*/ - false - ); - if (!info) continue; - if (!noDtsProject.containsScriptInfo(info)) { - noDtsProject.addRoot(info); - noDtsProject.updateGraph(); - } - const noDtsProgram = ls.getProgram(); - const fileToSearch = Debug.checkDefined(noDtsProgram.getSourceFile(fileNameToSearch)); - for (const match of searchForDeclaration(candidate.name, fileToSearch, noDtsProgram)) { - definitionSet.add(match); - } - } - } - definitions = arrayFrom(definitionSet.values()); - } - definitions = definitions.filter((d) => !d.isAmbient && !d.failedAliasResolution); - return this.mapDefinitionInfo(definitions, project); - function findImplementationFileFromDtsFileName(fileName, resolveFromFile, auxiliaryProject) { - var _a2, _b, _c; - const nodeModulesPathParts = getNodeModulePathParts(fileName); - if (nodeModulesPathParts && fileName.lastIndexOf(nodeModulesPathPart) === nodeModulesPathParts.topLevelNodeModulesIndex) { - const packageDirectory = fileName.substring(0, nodeModulesPathParts.packageRootIndex); - const packageJsonCache = (_a2 = project.getModuleResolutionCache()) == null ? void 0 : _a2.getPackageJsonInfoCache(); - const compilerOptions = project.getCompilationSettings(); - const packageJson = getPackageScopeForPath(getNormalizedAbsolutePath(packageDirectory, project.getCurrentDirectory()), getTemporaryModuleResolutionState(packageJsonCache, project, compilerOptions)); - if (!packageJson) return void 0; - const entrypoints = getEntrypointsFromPackageJsonInfo( - packageJson, - { moduleResolution: 2 /* Node10 */ }, - project, - project.getModuleResolutionCache() - ); - const packageNamePathPart = fileName.substring( - nodeModulesPathParts.topLevelPackageNameIndex + 1, - nodeModulesPathParts.packageRootIndex - ); - const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart)); - const path = project.toPath(fileName); - if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path)) { - return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName; - } else { - const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1); - const specifier = `${packageName}/${removeFileExtension(pathToFileInPackage)}`; - return (_c = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(specifier, resolveFromFile).resolvedModule) == null ? void 0 : _c.resolvedFileName; - } - } - return void 0; - } - function getAmbientCandidatesByClimbingAccessChain() { - const ls = project.getLanguageService(); - const program = ls.getProgram(); - const initialNode = getTouchingPropertyName(program.getSourceFile(file), position); - if ((isStringLiteralLike(initialNode) || isIdentifier(initialNode)) && isAccessExpression(initialNode.parent)) { - return forEachNameInAccessChainWalkingLeft(initialNode, (nameInChain) => { - var _a2; - if (nameInChain === initialNode) return void 0; - const candidates = (_a2 = ls.getDefinitionAtPosition( - file, - nameInChain.getStart(), - /*searchOtherFilesOnly*/ - true, - /*stopAtAlias*/ - false - )) == null ? void 0 : _a2.filter((d) => toNormalizedPath(d.fileName) !== file && d.isAmbient).map((d) => ({ - fileName: d.fileName, - name: getTextOfIdentifierOrLiteral(initialNode) - })); - if (some(candidates)) { - return candidates; - } - }) || emptyArray2; - } - return emptyArray2; - } - function tryRefineDefinition(definition, program, noDtsProgram) { - var _a2; - const fileToSearch = noDtsProgram.getSourceFile(definition.fileName); - if (!fileToSearch) { - return void 0; - } - const initialNode = getTouchingPropertyName(program.getSourceFile(file), position); - const symbol = program.getTypeChecker().getSymbolAtLocation(initialNode); - const importSpecifier = symbol && getDeclarationOfKind(symbol, 276 /* ImportSpecifier */); - if (!importSpecifier) return void 0; - const nameToSearch = ((_a2 = importSpecifier.propertyName) == null ? void 0 : _a2.text) || importSpecifier.name.text; - return searchForDeclaration(nameToSearch, fileToSearch, noDtsProgram); - } - function searchForDeclaration(declarationName, fileToSearch, noDtsProgram) { - const matches = ts_FindAllReferences_exports.Core.getTopMostDeclarationNamesInFile(declarationName, fileToSearch); - return mapDefined(matches, (match) => { - const symbol = noDtsProgram.getTypeChecker().getSymbolAtLocation(match); - const decl = getDeclarationFromName(match); - if (symbol && decl) { - return ts_GoToDefinition_exports.createDefinitionInfo( - decl, - noDtsProgram.getTypeChecker(), - symbol, - decl, - /*unverified*/ - true - ); - } - }); - } - } - getEmitOutput(args) { - const { file, project } = this.getFileAndProject(args); - if (!project.shouldEmitFile(project.getScriptInfo(file))) { - return { emitSkipped: true, outputFiles: [], diagnostics: [] }; - } - const result = project.getLanguageService().getEmitOutput(file); - return args.richResponse ? { - ...result, - diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(result.diagnostics) : result.diagnostics.map((d) => formatDiagnosticToProtocol( - d, - /*includeFileName*/ - true - )) - } : result; - } - mapJSDocTagInfo(tags, project, richResponse) { - return tags ? tags.map((tag) => { - var _a; - return { - ...tag, - text: richResponse ? this.mapDisplayParts(tag.text, project) : (_a = tag.text) == null ? void 0 : _a.map((part) => part.text).join("") - }; - }) : []; - } - mapDisplayParts(parts, project) { - if (!parts) { - return []; - } - return parts.map( - (part) => part.kind !== "linkName" ? part : { - ...part, - target: this.toFileSpan(part.target.fileName, part.target.textSpan, project) - } - ); - } - mapSignatureHelpItems(items, project, richResponse) { - return items.map((item) => ({ - ...item, - documentation: this.mapDisplayParts(item.documentation, project), - parameters: item.parameters.map((p) => ({ ...p, documentation: this.mapDisplayParts(p.documentation, project) })), - tags: this.mapJSDocTagInfo(item.tags, project, richResponse) - })); - } - mapDefinitionInfo(definitions, project) { - return definitions.map((def) => ({ ...this.toFileSpanWithContext(def.fileName, def.textSpan, def.contextSpan, project), ...def.unverified && { unverified: def.unverified } })); - } - /* - * When we map a .d.ts location to .ts, Visual Studio gets confused because there's no associated Roslyn Document in - * the same project which corresponds to the file. VS Code has no problem with this, and luckily we have two protocols. - * This retains the existing behavior for the "simplified" (VS Code) protocol but stores the .d.ts location in a - * set of additional fields, and does the reverse for VS (store the .d.ts location where - * it used to be and stores the .ts location in the additional fields). - */ - static mapToOriginalLocation(def) { - if (def.originalFileName) { - Debug.assert(def.originalTextSpan !== void 0, "originalTextSpan should be present if originalFileName is"); - return { - ...def, - fileName: def.originalFileName, - textSpan: def.originalTextSpan, - targetFileName: def.fileName, - targetTextSpan: def.textSpan, - contextSpan: def.originalContextSpan, - targetContextSpan: def.contextSpan - }; - } - return def; - } - toFileSpan(fileName, textSpan, project) { - const ls = project.getLanguageService(); - const start = ls.toLineColumnOffset(fileName, textSpan.start); - const end = ls.toLineColumnOffset(fileName, textSpanEnd(textSpan)); - return { - file: fileName, - start: { line: start.line + 1, offset: start.character + 1 }, - end: { line: end.line + 1, offset: end.character + 1 } - }; - } - toFileSpanWithContext(fileName, textSpan, contextSpan, project) { - const fileSpan = this.toFileSpan(fileName, textSpan, project); - const context = contextSpan && this.toFileSpan(fileName, contextSpan, project); - return context ? { ...fileSpan, contextStart: context.start, contextEnd: context.end } : fileSpan; - } - getTypeDefinition(args) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const definitions = this.mapDefinitionInfoLocations(project.getLanguageService().getTypeDefinitionAtPosition(file, position) || emptyArray2, project); - return this.mapDefinitionInfo(definitions, project); - } - mapImplementationLocations(implementations, project) { - return implementations.map((info) => { - const newDocumentSpan = getMappedDocumentSpanForProject(info, project); - return !newDocumentSpan ? info : { - ...newDocumentSpan, - kind: info.kind, - displayParts: info.displayParts - }; - }); - } - getImplementation(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const implementations = this.mapImplementationLocations(project.getLanguageService().getImplementationAtPosition(file, position) || emptyArray2, project); - return simplifiedResult ? implementations.map(({ fileName, textSpan, contextSpan }) => this.toFileSpanWithContext(fileName, textSpan, contextSpan, project)) : implementations.map(_Session.mapToOriginalLocation); - } - getSyntacticDiagnosticsSync(args) { - const { configFile } = this.getConfigFileAndProject(args); - if (configFile) { - return emptyArray2; - } - return this.getDiagnosticsWorker( - args, - /*isSemantic*/ - false, - (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), - !!args.includeLinePosition - ); - } - getSemanticDiagnosticsSync(args) { - const { configFile, project } = this.getConfigFileAndProject(args); - if (configFile) { - return this.getConfigFileDiagnostics(configFile, project, !!args.includeLinePosition); - } - return this.getDiagnosticsWorker( - args, - /*isSemantic*/ - true, - (project2, file) => project2.getLanguageService().getSemanticDiagnostics(file).filter((d) => !!d.file), - !!args.includeLinePosition - ); - } - getSuggestionDiagnosticsSync(args) { - const { configFile } = this.getConfigFileAndProject(args); - if (configFile) { - return emptyArray2; - } - return this.getDiagnosticsWorker( - args, - /*isSemantic*/ - true, - (project, file) => project.getLanguageService().getSuggestionDiagnostics(file), - !!args.includeLinePosition - ); - } - getJsxClosingTag(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - const tag = languageService.getJsxClosingTagAtPosition(file, position); - return tag === void 0 ? void 0 : { newText: tag.newText, caretOffset: 0 }; - } - getLinkedEditingRange(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - const linkedEditInfo = languageService.getLinkedEditingRangeAtPosition(file, position); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - if (scriptInfo === void 0 || linkedEditInfo === void 0) return void 0; - return convertLinkedEditInfoToRanges(linkedEditInfo, scriptInfo); - } - getDocumentHighlights(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const documentHighlights = project.getLanguageService().getDocumentHighlights(file, position, args.filesToSearch); - if (!documentHighlights) return emptyArray2; - if (!simplifiedResult) return documentHighlights; - return documentHighlights.map(({ fileName, highlightSpans }) => { - const scriptInfo = project.getScriptInfo(fileName); - return { - file: fileName, - highlightSpans: highlightSpans.map(({ textSpan, kind, contextSpan }) => ({ - ...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo), - kind - })) - }; - }); - } - provideInlayHints(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const hints = project.getLanguageService().provideInlayHints(file, args, this.getPreferences(file)); - return hints.map((hint) => { - const { position, displayParts } = hint; - return { - ...hint, - position: scriptInfo.positionToLineOffset(position), - displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => { - if (span) { - Debug.assertIsDefined(file2, "Target file should be defined together with its span."); - const scriptInfo2 = this.projectService.getScriptInfo(file2); - return { - text, - span: { - start: scriptInfo2.positionToLineOffset(span.start), - end: scriptInfo2.positionToLineOffset(span.start + span.length), - file: file2 - } - }; - } else { - return { text }; - } - }) - }; - }); - } - mapCode(args) { - var _a; - const formatOptions = this.getHostFormatOptions(); - const preferences = this.getHostPreferences(); - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const focusLocations = (_a = args.mapping.focusLocations) == null ? void 0 : _a.map((spans) => { - return spans.map((loc) => { - const start = scriptInfo.lineOffsetToPosition(loc.start.line, loc.start.offset); - const end = scriptInfo.lineOffsetToPosition(loc.end.line, loc.end.offset); - return { - start, - length: end - start - }; - }); - }); - const changes = languageService.mapCode(file, args.mapping.contents, focusLocations, formatOptions, preferences); - return this.mapTextChangesToCodeEdits(changes); - } - setCompilerOptionsForInferredProjects(args) { - this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath); - } - getProjectInfo(args) { - return this.getProjectInfoWorker( - args.file, - args.projectFileName, - args.needFileNameList, - /*excludeConfigFiles*/ - false - ); - } - getProjectInfoWorker(uncheckedFileName, projectFileName, needFileNameList, excludeConfigFiles) { - const { project } = this.getFileAndProjectWorker(uncheckedFileName, projectFileName); - updateProjectIfDirty(project); - const projectInfo = { - configFileName: project.getProjectName(), - languageServiceDisabled: !project.languageServiceEnabled, - fileNames: needFileNameList ? project.getFileNames( - /*excludeFilesFromExternalLibraries*/ - false, - excludeConfigFiles - ) : void 0 - }; - return projectInfo; - } - getRenameInfo(args) { - const { file, project } = this.getFileAndProject(args); - const position = this.getPositionInFile(args, file); - const preferences = this.getPreferences(file); - return project.getLanguageService().getRenameInfo(file, position, preferences); - } - getProjects(args, getScriptInfoEnsuringProjectsUptoDate, ignoreNoProjectError) { - let projects; - let symLinkedProjects; - if (args.projectFileName) { - const project = this.getProject(args.projectFileName); - if (project) { - projects = [project]; - } - } else { - const scriptInfo = getScriptInfoEnsuringProjectsUptoDate ? this.projectService.getScriptInfoEnsuringProjectsUptoDate(args.file) : this.projectService.getScriptInfo(args.file); - if (!scriptInfo) { - if (ignoreNoProjectError) return emptyArray2; - this.projectService.logErrorForScriptInfoNotFound(args.file); - return Errors.ThrowNoProject(); - } else if (!getScriptInfoEnsuringProjectsUptoDate) { - this.projectService.ensureDefaultProjectForFile(scriptInfo); - } - projects = scriptInfo.containingProjects; - symLinkedProjects = this.projectService.getSymlinkedProjects(scriptInfo); - } - projects = filter(projects, (p) => p.languageServiceEnabled && !p.isOrphan()); - if (!ignoreNoProjectError && (!projects || !projects.length) && !symLinkedProjects) { - this.projectService.logErrorForScriptInfoNotFound(args.file ?? args.projectFileName); - return Errors.ThrowNoProject(); - } - return symLinkedProjects ? { projects, symLinkedProjects } : projects; - } - getDefaultProject(args) { - if (args.projectFileName) { - const project = this.getProject(args.projectFileName); - if (project) { - return project; - } - if (!args.file) { - return Errors.ThrowNoProject(); - } - } - const info = this.projectService.getScriptInfo(args.file); - return info.getDefaultProject(); - } - getRenameLocations(args, simplifiedResult) { - const file = toNormalizedPath(args.file); - const position = this.getPositionInFile(args, file); - const projects = this.getProjects(args); - const defaultProject = this.getDefaultProject(args); - const preferences = this.getPreferences(file); - const renameInfo = this.mapRenameInfo( - defaultProject.getLanguageService().getRenameInfo(file, position, preferences), - Debug.checkDefined(this.projectService.getScriptInfo(file)) - ); - if (!renameInfo.canRename) return simplifiedResult ? { info: renameInfo, locs: [] } : []; - const locations = getRenameLocationsWorker( - projects, - defaultProject, - { fileName: args.file, pos: position }, - !!args.findInStrings, - !!args.findInComments, - preferences, - this.host.useCaseSensitiveFileNames - ); - if (!simplifiedResult) return locations; - return { info: renameInfo, locs: this.toSpanGroups(locations) }; - } - mapRenameInfo(info, scriptInfo) { - if (info.canRename) { - const { canRename, fileToRename, displayName, fullDisplayName, kind, kindModifiers, triggerSpan } = info; - return identity( - { canRename, fileToRename, displayName, fullDisplayName, kind, kindModifiers, triggerSpan: toProtocolTextSpan(triggerSpan, scriptInfo) } - ); - } else { - return info; - } - } - toSpanGroups(locations) { - const map2 = /* @__PURE__ */ new Map(); - for (const { fileName, textSpan, contextSpan, originalContextSpan: _2, originalTextSpan: _, originalFileName: _1, ...prefixSuffixText } of locations) { - let group2 = map2.get(fileName); - if (!group2) map2.set(fileName, group2 = { file: fileName, locs: [] }); - const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(fileName)); - group2.locs.push({ ...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo), ...prefixSuffixText }); - } - return arrayFrom(map2.values()); - } - getReferences(args, simplifiedResult) { - const file = toNormalizedPath(args.file); - const projects = this.getProjects(args); - const position = this.getPositionInFile(args, file); - const references = getReferencesWorker( - projects, - this.getDefaultProject(args), - { fileName: args.file, pos: position }, - this.host.useCaseSensitiveFileNames, - this.logger - ); - if (!simplifiedResult) return references; - const preferences = this.getPreferences(file); - const defaultProject = this.getDefaultProject(args); - const scriptInfo = defaultProject.getScriptInfoForNormalizedPath(file); - const nameInfo = defaultProject.getLanguageService().getQuickInfoAtPosition(file, position); - const symbolDisplayString = nameInfo ? displayPartsToString(nameInfo.displayParts) : ""; - const nameSpan = nameInfo && nameInfo.textSpan; - const symbolStartOffset = nameSpan ? scriptInfo.positionToLineOffset(nameSpan.start).offset : 0; - const symbolName2 = nameSpan ? scriptInfo.getSnapshot().getText(nameSpan.start, textSpanEnd(nameSpan)) : ""; - const refs = flatMap(references, (referencedSymbol) => { - return referencedSymbol.references.map((entry) => referenceEntryToReferencesResponseItem(this.projectService, entry, preferences)); - }); - return { refs, symbolName: symbolName2, symbolStartOffset, symbolDisplayString }; - } - getFileReferences(args, simplifiedResult) { - const projects = this.getProjects(args); - const fileName = args.file; - const preferences = this.getPreferences(toNormalizedPath(fileName)); - const references = []; - const seen = createDocumentSpanSet(this.host.useCaseSensitiveFileNames); - forEachProjectInProjects( - projects, - /*path*/ - void 0, - (project) => { - if (project.getCancellationToken().isCancellationRequested()) return; - const projectOutputs = project.getLanguageService().getFileReferences(fileName); - if (projectOutputs) { - for (const referenceEntry of projectOutputs) { - if (!seen.has(referenceEntry)) { - references.push(referenceEntry); - seen.add(referenceEntry); - } - } - } - } - ); - if (!simplifiedResult) return references; - const refs = references.map((entry) => referenceEntryToReferencesResponseItem(this.projectService, entry, preferences)); - return { - refs, - symbolName: `"${args.file}"` - }; - } - /** - * @param fileName is the name of the file to be opened - * @param fileContent is a version of the file content that is known to be more up to date than the one on disk - */ - openClientFile(fileName, fileContent, scriptKind, projectRootPath) { - this.projectService.openClientFileWithNormalizedPath( - fileName, - fileContent, - scriptKind, - /*hasMixedContent*/ - false, - projectRootPath - ); - } - getPosition(args, scriptInfo) { - return args.position !== void 0 ? args.position : scriptInfo.lineOffsetToPosition(args.line, args.offset); - } - getPositionInFile(args, file) { - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - return this.getPosition(args, scriptInfo); - } - getFileAndProject(args) { - return this.getFileAndProjectWorker(args.file, args.projectFileName); - } - getFileAndLanguageServiceForSyntacticOperation(args) { - const { file, project } = this.getFileAndProject(args); - return { - file, - languageService: project.getLanguageService( - /*ensureSynchronized*/ - false - ) - }; - } - getFileAndProjectWorker(uncheckedFileName, projectFileName) { - const file = toNormalizedPath(uncheckedFileName); - const project = this.getProject(projectFileName) || this.projectService.ensureDefaultProjectForFile(file); - return { file, project }; - } - getOutliningSpans(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const spans = languageService.getOutliningSpans(file); - if (simplifiedResult) { - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - return spans.map((s) => ({ - textSpan: toProtocolTextSpan(s.textSpan, scriptInfo), - hintSpan: toProtocolTextSpan(s.hintSpan, scriptInfo), - bannerText: s.bannerText, - autoCollapse: s.autoCollapse, - kind: s.kind - })); - } else { - return spans; - } - } - getTodoComments(args) { - const { file, project } = this.getFileAndProject(args); - return project.getLanguageService().getTodoComments(file, args.descriptors); - } - getDocCommentTemplate(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - return languageService.getDocCommentTemplateAtPosition(file, position, this.getPreferences(file), this.getFormatOptions(file)); - } - getSpanOfEnclosingComment(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const onlyMultiLine = args.onlyMultiLine; - const position = this.getPositionInFile(args, file); - return languageService.getSpanOfEnclosingComment(file, position, onlyMultiLine); - } - getIndentation(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file); - const indentation = languageService.getIndentationAtPosition(file, position, options); - return { position, indentation }; - } - getBreakpointStatement(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - return languageService.getBreakpointStatementAtPosition(file, position); - } - getNameOrDottedNameSpan(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - return languageService.getNameOrDottedNameSpan(file, position, position); - } - isValidBraceCompletion(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const position = this.getPositionInFile(args, file); - return languageService.isValidBraceCompletionAtPosition(file, position, args.openingBrace.charCodeAt(0)); - } - getQuickInfoWorker(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo)); - if (!quickInfo) { - return void 0; - } - const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc; - if (simplifiedResult) { - const displayString = displayPartsToString(quickInfo.displayParts); - return { - kind: quickInfo.kind, - kindModifiers: quickInfo.kindModifiers, - start: scriptInfo.positionToLineOffset(quickInfo.textSpan.start), - end: scriptInfo.positionToLineOffset(textSpanEnd(quickInfo.textSpan)), - displayString, - documentation: useDisplayParts ? this.mapDisplayParts(quickInfo.documentation, project) : displayPartsToString(quickInfo.documentation), - tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts) - }; - } else { - return useDisplayParts ? quickInfo : { - ...quickInfo, - tags: this.mapJSDocTagInfo( - quickInfo.tags, - project, - /*richResponse*/ - false - ) - }; - } - } - getFormattingEditsForRange(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const startPosition = scriptInfo.lineOffsetToPosition(args.line, args.offset); - const endPosition = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset); - const edits = languageService.getFormattingEditsForRange(file, startPosition, endPosition, this.getFormatOptions(file)); - if (!edits) { - return void 0; - } - return edits.map((edit) => this.convertTextChangeToCodeEdit(edit, scriptInfo)); - } - getFormattingEditsForRangeFull(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file); - return languageService.getFormattingEditsForRange(file, args.position, args.endPosition, options); - } - getFormattingEditsForDocumentFull(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file); - return languageService.getFormattingEditsForDocument(file, options); - } - getFormattingEditsAfterKeystrokeFull(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file); - return languageService.getFormattingEditsAfterKeystroke(file, args.position, args.key, options); - } - getFormattingEditsAfterKeystroke(args) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const position = scriptInfo.lineOffsetToPosition(args.line, args.offset); - const formatOptions = this.getFormatOptions(file); - const edits = languageService.getFormattingEditsAfterKeystroke(file, position, args.key, formatOptions); - if (args.key === "\n" && (!edits || edits.length === 0 || allEditsBeforePos(edits, position))) { - const { lineText, absolutePosition } = scriptInfo.textStorage.getAbsolutePositionAndLineText(args.line); - if (lineText && lineText.search("\\S") < 0) { - const preferredIndent = languageService.getIndentationAtPosition(file, position, formatOptions); - let hasIndent = 0; - let i, len; - for (i = 0, len = lineText.length; i < len; i++) { - if (lineText.charAt(i) === " ") { - hasIndent++; - } else if (lineText.charAt(i) === " ") { - hasIndent += formatOptions.tabSize; - } else { - break; - } - } - if (preferredIndent !== hasIndent) { - const firstNoWhiteSpacePosition = absolutePosition + i; - edits.push({ - span: createTextSpanFromBounds(absolutePosition, firstNoWhiteSpacePosition), - newText: ts_formatting_exports.getIndentationString(preferredIndent, formatOptions) - }); - } - } - } - if (!edits) { - return void 0; - } - return edits.map((edit) => { - return { - start: scriptInfo.positionToLineOffset(edit.span.start), - end: scriptInfo.positionToLineOffset(textSpanEnd(edit.span)), - newText: edit.newText ? edit.newText : "" - }; - }); - } - getCompletions(args, kind) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const position = this.getPosition(args, scriptInfo); - const completions = project.getLanguageService().getCompletionsAtPosition( - file, - position, - { - ...convertUserPreferences(this.getPreferences(file)), - triggerCharacter: args.triggerCharacter, - triggerKind: args.triggerKind, - includeExternalModuleExports: args.includeExternalModuleExports, - includeInsertTextCompletions: args.includeInsertTextCompletions - }, - project.projectService.getFormatCodeOptions(file) - ); - if (completions === void 0) return void 0; - if (kind === "completions-full" /* CompletionsFull */) return completions; - const prefix = args.prefix || ""; - const entries = mapDefined(completions.entries, (entry) => { - if (completions.isMemberCompletion || startsWith(entry.name.toLowerCase(), prefix.toLowerCase())) { - const convertedSpan = entry.replacementSpan ? toProtocolTextSpan(entry.replacementSpan, scriptInfo) : void 0; - return { - ...entry, - replacementSpan: convertedSpan, - hasAction: entry.hasAction || void 0, - symbol: void 0 - }; - } - }); - if (kind === "completions" /* Completions */) { - if (completions.metadata) entries.metadata = completions.metadata; - return entries; - } - const res = { - ...completions, - optionalReplacementSpan: completions.optionalReplacementSpan && toProtocolTextSpan(completions.optionalReplacementSpan, scriptInfo), - entries - }; - return res; - } - getCompletionEntryDetails(args, fullResult) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const position = this.getPosition(args, scriptInfo); - const formattingOptions = project.projectService.getFormatCodeOptions(file); - const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc; - const result = mapDefined(args.entryNames, (entryName) => { - const { name, source, data } = typeof entryName === "string" ? { name: entryName, source: void 0, data: void 0 } : entryName; - return project.getLanguageService().getCompletionEntryDetails(file, position, name, formattingOptions, source, this.getPreferences(file), data ? cast(data, isCompletionEntryData) : void 0); - }); - return fullResult ? useDisplayParts ? result : result.map((details) => ({ ...details, tags: this.mapJSDocTagInfo( - details.tags, - project, - /*richResponse*/ - false - ) })) : result.map((details) => ({ - ...details, - codeActions: map(details.codeActions, (action) => this.mapCodeAction(action)), - documentation: this.mapDisplayParts(details.documentation, project), - tags: this.mapJSDocTagInfo(details.tags, project, useDisplayParts) - })); - } - getCompileOnSaveAffectedFileList(args) { - const projects = this.getProjects( - args, - /*getScriptInfoEnsuringProjectsUptoDate*/ - true, - /*ignoreNoProjectError*/ - true - ); - const info = this.projectService.getScriptInfo(args.file); - if (!info) { - return emptyArray2; - } - return combineProjectOutput( - info, - (path) => this.projectService.getScriptInfoForPath(path), - projects, - (project, info2) => { - if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) { - return void 0; - } - const compilationSettings = project.getCompilationSettings(); - if (!!compilationSettings.noEmit || isDeclarationFileName(info2.fileName) && !dtsChangeCanAffectEmit(compilationSettings)) { - return void 0; - } - return { - projectFileName: project.getProjectName(), - fileNames: project.getCompileOnSaveAffectedFileList(info2), - projectUsesOutFile: !!compilationSettings.outFile - }; - } - ); - } - emitFile(args) { - const { file, project } = this.getFileAndProject(args); - if (!project) { - Errors.ThrowNoProject(); - } - if (!project.languageServiceEnabled) { - return args.richResponse ? { emitSkipped: true, diagnostics: [] } : false; - } - const scriptInfo = project.getScriptInfo(file); - const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path, data, writeByteOrderMark) => this.host.writeFile(path, data, writeByteOrderMark)); - return args.richResponse ? { - emitSkipped, - diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol( - d, - /*includeFileName*/ - true - )) - } : !emitSkipped; - } - getSignatureHelpItems(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const position = this.getPosition(args, scriptInfo); - const helpItems = project.getLanguageService().getSignatureHelpItems(file, position, args); - const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc; - if (helpItems && simplifiedResult) { - const span = helpItems.applicableSpan; - return { - ...helpItems, - applicableSpan: { - start: scriptInfo.positionToLineOffset(span.start), - end: scriptInfo.positionToLineOffset(span.start + span.length) - }, - items: this.mapSignatureHelpItems(helpItems.items, project, useDisplayParts) - }; - } else if (useDisplayParts || !helpItems) { - return helpItems; - } else { - return { - ...helpItems, - items: helpItems.items.map((item) => ({ ...item, tags: this.mapJSDocTagInfo( - item.tags, - project, - /*richResponse*/ - false - ) })) - }; - } - } - toPendingErrorCheck(uncheckedFileName) { - const fileName = toNormalizedPath(uncheckedFileName); - const project = this.projectService.tryGetDefaultProjectForFile(fileName); - return project && { fileName, project }; - } - getDiagnostics(next, delay, fileArgs) { - if (this.suppressDiagnosticEvents) { - return; - } - if (fileArgs.length > 0) { - this.updateErrorCheck(next, fileArgs, delay); - } - } - change(args) { - const scriptInfo = this.projectService.getScriptInfo(args.file); - Debug.assert(!!scriptInfo); - scriptInfo.textStorage.switchToScriptVersionCache(); - const start = scriptInfo.lineOffsetToPosition(args.line, args.offset); - const end = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset); - if (start >= 0) { - this.changeSeq++; - this.projectService.applyChangesToFile( - scriptInfo, - singleIterator({ - span: { start, length: end - start }, - newText: args.insertString - // TODO: GH#18217 - }) - ); - } - } - reload(args) { - const file = toNormalizedPath(args.file); - const tempFileName = args.tmpfile === void 0 ? void 0 : toNormalizedPath(args.tmpfile); - const info = this.projectService.getScriptInfoForNormalizedPath(file); - if (info) { - this.changeSeq++; - info.reloadFromFile(tempFileName); - } - } - saveToTmp(fileName, tempFileName) { - const scriptInfo = this.projectService.getScriptInfo(fileName); - if (scriptInfo) { - scriptInfo.saveTo(tempFileName); - } - } - closeClientFile(fileName) { - if (!fileName) { - return; - } - const file = normalizePath(fileName); - this.projectService.closeClientFile(file); - } - mapLocationNavigationBarItems(items, scriptInfo) { - return map(items, (item) => ({ - text: item.text, - kind: item.kind, - kindModifiers: item.kindModifiers, - spans: item.spans.map((span) => toProtocolTextSpan(span, scriptInfo)), - childItems: this.mapLocationNavigationBarItems(item.childItems, scriptInfo), - indent: item.indent - })); - } - getNavigationBarItems(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const items = languageService.getNavigationBarItems(file); - return !items ? void 0 : simplifiedResult ? this.mapLocationNavigationBarItems(items, this.projectService.getScriptInfoForNormalizedPath(file)) : items; - } - toLocationNavigationTree(tree, scriptInfo) { - return { - text: tree.text, - kind: tree.kind, - kindModifiers: tree.kindModifiers, - spans: tree.spans.map((span) => toProtocolTextSpan(span, scriptInfo)), - nameSpan: tree.nameSpan && toProtocolTextSpan(tree.nameSpan, scriptInfo), - childItems: map(tree.childItems, (item) => this.toLocationNavigationTree(item, scriptInfo)) - }; - } - getNavigationTree(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const tree = languageService.getNavigationTree(file); - return !tree ? void 0 : simplifiedResult ? this.toLocationNavigationTree(tree, this.projectService.getScriptInfoForNormalizedPath(file)) : tree; - } - getNavigateToItems(args, simplifiedResult) { - const full = this.getFullNavigateToItems(args); - return !simplifiedResult ? flatMap(full, ({ navigateToItems }) => navigateToItems) : flatMap( - full, - ({ project, navigateToItems }) => navigateToItems.map((navItem) => { - const scriptInfo = project.getScriptInfo(navItem.fileName); - const bakedItem = { - name: navItem.name, - kind: navItem.kind, - kindModifiers: navItem.kindModifiers, - isCaseSensitive: navItem.isCaseSensitive, - matchKind: navItem.matchKind, - file: navItem.fileName, - start: scriptInfo.positionToLineOffset(navItem.textSpan.start), - end: scriptInfo.positionToLineOffset(textSpanEnd(navItem.textSpan)) - }; - if (navItem.kindModifiers && navItem.kindModifiers !== "") { - bakedItem.kindModifiers = navItem.kindModifiers; - } - if (navItem.containerName && navItem.containerName.length > 0) { - bakedItem.containerName = navItem.containerName; - } - if (navItem.containerKind && navItem.containerKind.length > 0) { - bakedItem.containerKind = navItem.containerKind; - } - return bakedItem; - }) - ); - } - getFullNavigateToItems(args) { - const { currentFileOnly, searchValue, maxResultCount, projectFileName } = args; - if (currentFileOnly) { - Debug.assertIsDefined(args.file); - const { file, project } = this.getFileAndProject(args); - return [{ project, navigateToItems: project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, file) }]; - } - const preferences = this.getHostPreferences(); - const outputs = []; - const seenItems = /* @__PURE__ */ new Map(); - if (!args.file && !projectFileName) { - this.projectService.loadAncestorProjectTree(); - this.projectService.forEachEnabledProject((project) => addItemsForProject(project)); - } else { - const projects = this.getProjects(args); - forEachProjectInProjects( - projects, - /*path*/ - void 0, - (project) => addItemsForProject(project) - ); - } - return outputs; - function addItemsForProject(project) { - const projectItems = project.getLanguageService().getNavigateToItems( - searchValue, - maxResultCount, - /*fileName*/ - void 0, - /*excludeDts*/ - project.isNonTsProject(), - /*excludeLibFiles*/ - preferences.excludeLibrarySymbolsInNavTo - ); - const unseenItems = filter(projectItems, (item) => tryAddSeenItem(item) && !getMappedLocationForProject(documentSpanLocation(item), project)); - if (unseenItems.length) { - outputs.push({ project, navigateToItems: unseenItems }); - } - } - function tryAddSeenItem(item) { - const name = item.name; - if (!seenItems.has(name)) { - seenItems.set(name, [item]); - return true; - } - const seen = seenItems.get(name); - for (const seenItem of seen) { - if (navigateToItemIsEqualTo(seenItem, item)) { - return false; - } - } - seen.push(item); - return true; - } - function navigateToItemIsEqualTo(a, b) { - if (a === b) { - return true; - } - if (!a || !b) { - return false; - } - return a.containerKind === b.containerKind && a.containerName === b.containerName && a.fileName === b.fileName && a.isCaseSensitive === b.isCaseSensitive && a.kind === b.kind && a.kindModifiers === b.kindModifiers && a.matchKind === b.matchKind && a.name === b.name && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length; - } - } - getSupportedCodeFixes(args) { - if (!args) return getSupportedCodeFixes(); - if (args.file) { - const { file, project: project2 } = this.getFileAndProject(args); - return project2.getLanguageService().getSupportedCodeFixes(file); - } - const project = this.getProject(args.projectFileName); - if (!project) Errors.ThrowNoProject(); - return project.getLanguageService().getSupportedCodeFixes(); - } - isLocation(locationOrSpan) { - return locationOrSpan.line !== void 0; - } - extractPositionOrRange(args, scriptInfo) { - let position; - let textRange; - if (this.isLocation(args)) { - position = getPosition(args); - } else { - textRange = this.getRange(args, scriptInfo); - } - return Debug.checkDefined(position === void 0 ? textRange : position); - function getPosition(loc) { - return loc.position !== void 0 ? loc.position : scriptInfo.lineOffsetToPosition(loc.line, loc.offset); - } - } - getRange(args, scriptInfo) { - const { startPosition, endPosition } = this.getStartAndEndPosition(args, scriptInfo); - return { pos: startPosition, end: endPosition }; - } - getApplicableRefactors(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - const result = project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind, args.includeInteractiveActions); - return result.map((result2) => ({ ...result2, actions: result2.actions.map((action) => ({ ...action, range: action.range ? { start: convertToLocation({ line: action.range.start.line, character: action.range.start.offset }), end: convertToLocation({ line: action.range.end.line, character: action.range.end.offset }) } : void 0 })) })); - } - getEditsForRefactor(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - const result = project.getLanguageService().getEditsForRefactor( - file, - this.getFormatOptions(file), - this.extractPositionOrRange(args, scriptInfo), - args.refactor, - args.action, - this.getPreferences(file), - args.interactiveRefactorArguments - ); - if (result === void 0) { - return { - edits: [] - }; - } - if (simplifiedResult) { - const { renameFilename, renameLocation, edits } = result; - let mappedRenameLocation; - if (renameFilename !== void 0 && renameLocation !== void 0) { - const renameScriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(renameFilename)); - mappedRenameLocation = getLocationInNewDocument(getSnapshotText(renameScriptInfo.getSnapshot()), renameFilename, renameLocation, edits); - } - return { - renameLocation: mappedRenameLocation, - renameFilename, - edits: this.mapTextChangesToCodeEdits(edits), - notApplicableReason: result.notApplicableReason - }; - } - return result; - } - getMoveToRefactoringFileSuggestions(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - return project.getLanguageService().getMoveToRefactoringFileSuggestions(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file)); - } - getPasteEdits(args) { - const { file, project } = this.getFileAndProject(args); - const copiedFrom = args.copiedFrom ? { file: args.copiedFrom.file, range: args.copiedFrom.spans.map((copies) => this.getRange({ file: args.copiedFrom.file, startLine: copies.start.line, startOffset: copies.start.offset, endLine: copies.end.line, endOffset: copies.end.offset }, project.getScriptInfoForNormalizedPath(toNormalizedPath(args.copiedFrom.file)))) } : void 0; - const result = project.getLanguageService().getPasteEdits( - { - targetFile: file, - pastedText: args.pastedText, - pasteLocations: args.pasteLocations.map((paste) => this.getRange({ file, startLine: paste.start.line, startOffset: paste.start.offset, endLine: paste.end.line, endOffset: paste.end.offset }, project.getScriptInfoForNormalizedPath(file))), - copiedFrom, - preferences: this.getPreferences(file) - }, - this.getFormatOptions(file) - ); - return result && this.mapPasteEditsAction(result); - } - organizeImports(args, simplifiedResult) { - Debug.assert(args.scope.type === "file"); - const { file, project } = this.getFileAndProject(args.scope.args); - const changes = project.getLanguageService().organizeImports( - { - fileName: file, - mode: args.mode ?? (args.skipDestructiveCodeActions ? "SortAndCombine" /* SortAndCombine */ : void 0), - type: "file" - }, - this.getFormatOptions(file), - this.getPreferences(file) - ); - if (simplifiedResult) { - return this.mapTextChangesToCodeEdits(changes); - } else { - return changes; - } - } - getEditsForFileRename(args, simplifiedResult) { - const oldPath = toNormalizedPath(args.oldFilePath); - const newPath = toNormalizedPath(args.newFilePath); - const formatOptions = this.getHostFormatOptions(); - const preferences = this.getHostPreferences(); - const seenFiles = /* @__PURE__ */ new Set(); - const textChanges2 = []; - this.projectService.loadAncestorProjectTree(); - this.projectService.forEachEnabledProject((project) => { - const projectTextChanges = project.getLanguageService().getEditsForFileRename(oldPath, newPath, formatOptions, preferences); - const projectFiles = []; - for (const textChange of projectTextChanges) { - if (!seenFiles.has(textChange.fileName)) { - textChanges2.push(textChange); - projectFiles.push(textChange.fileName); - } - } - for (const file of projectFiles) { - seenFiles.add(file); - } - }); - return simplifiedResult ? textChanges2.map((c) => this.mapTextChangeToCodeEdit(c)) : textChanges2; - } - getCodeFixes(args, simplifiedResult) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = project.getScriptInfoForNormalizedPath(file); - const { startPosition, endPosition } = this.getStartAndEndPosition(args, scriptInfo); - let codeActions; - try { - codeActions = project.getLanguageService().getCodeFixesAtPosition(file, startPosition, endPosition, args.errorCodes, this.getFormatOptions(file), this.getPreferences(file)); - } catch (e) { - const ls = project.getLanguageService(); - const existingDiagCodes = [ - ...ls.getSyntacticDiagnostics(file), - ...ls.getSemanticDiagnostics(file), - ...ls.getSuggestionDiagnostics(file) - ].map( - (d) => decodedTextSpanIntersectsWith(startPosition, endPosition - startPosition, d.start, d.length) && d.code - ); - const badCode = args.errorCodes.find((c) => !existingDiagCodes.includes(c)); - if (badCode !== void 0) { - e.message = `BADCLIENT: Bad error code, ${badCode} not found in range ${startPosition}..${endPosition} (found: ${existingDiagCodes.join(", ")}); could have caused this error: -${e.message}`; - } - throw e; - } - return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions; - } - getCombinedCodeFix({ scope, fixId: fixId55 }, simplifiedResult) { - Debug.assert(scope.type === "file"); - const { file, project } = this.getFileAndProject(scope.args); - const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId55, this.getFormatOptions(file), this.getPreferences(file)); - if (simplifiedResult) { - return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands }; - } else { - return res; - } - } - applyCodeActionCommand(args) { - const commands = args.command; - for (const command of toArray(commands)) { - const { file, project } = this.getFileAndProject(command); - project.getLanguageService().applyCodeActionCommand(command, this.getFormatOptions(file)).then( - (_result) => { - }, - (_error) => { - } - ); - } - return {}; - } - getStartAndEndPosition(args, scriptInfo) { - let startPosition, endPosition; - if (args.startPosition !== void 0) { - startPosition = args.startPosition; - } else { - startPosition = scriptInfo.lineOffsetToPosition(args.startLine, args.startOffset); - args.startPosition = startPosition; - } - if (args.endPosition !== void 0) { - endPosition = args.endPosition; - } else { - endPosition = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset); - args.endPosition = endPosition; - } - return { startPosition, endPosition }; - } - mapCodeAction({ description: description3, changes, commands }) { - return { description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands }; - } - mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId55, fixAllDescription }) { - return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId55, fixAllDescription }; - } - mapPasteEditsAction({ edits, fixId: fixId55 }) { - return { edits: this.mapTextChangesToCodeEdits(edits), fixId: fixId55 }; - } - mapTextChangesToCodeEdits(textChanges2) { - return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change)); - } - mapTextChangeToCodeEdit(textChanges2) { - const scriptInfo = this.projectService.getScriptInfoOrConfig(textChanges2.fileName); - if (!!textChanges2.isNewFile === !!scriptInfo) { - if (!scriptInfo) { - this.projectService.logErrorForScriptInfoNotFound(textChanges2.fileName); - } - Debug.fail("Expected isNewFile for (only) new files. " + JSON.stringify({ isNewFile: !!textChanges2.isNewFile, hasScriptInfo: !!scriptInfo })); - } - return scriptInfo ? { fileName: textChanges2.fileName, textChanges: textChanges2.textChanges.map((textChange) => convertTextChangeToCodeEdit(textChange, scriptInfo)) } : convertNewFileTextChangeToCodeEdit(textChanges2); - } - convertTextChangeToCodeEdit(change, scriptInfo) { - return { - start: scriptInfo.positionToLineOffset(change.span.start), - end: scriptInfo.positionToLineOffset(change.span.start + change.span.length), - newText: change.newText ? change.newText : "" - }; - } - getBraceMatching(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const position = this.getPosition(args, scriptInfo); - const spans = languageService.getBraceMatchingAtPosition(file, position); - return !spans ? void 0 : simplifiedResult ? spans.map((span) => toProtocolTextSpan(span, scriptInfo)) : spans; - } - getDiagnosticsForProject(next, delay, fileName) { - if (this.suppressDiagnosticEvents) { - return; - } - const { fileNames, languageServiceDisabled } = this.getProjectInfoWorker( - fileName, - /*projectFileName*/ - void 0, - /*needFileNameList*/ - true, - /*excludeConfigFiles*/ - true - ); - if (languageServiceDisabled) { - return; - } - const fileNamesInProject = fileNames.filter((value) => !value.includes("lib.d.ts")); - if (fileNamesInProject.length === 0) { - return; - } - const highPriorityFiles = []; - const mediumPriorityFiles = []; - const lowPriorityFiles = []; - const veryLowPriorityFiles = []; - const normalizedFileName = toNormalizedPath(fileName); - const project = this.projectService.ensureDefaultProjectForFile(normalizedFileName); - for (const fileNameInProject of fileNamesInProject) { - if (this.getCanonicalFileName(fileNameInProject) === this.getCanonicalFileName(fileName)) { - highPriorityFiles.push(fileNameInProject); - } else { - const info = this.projectService.getScriptInfo(fileNameInProject); - if (!info.isScriptOpen()) { - if (isDeclarationFileName(fileNameInProject)) { - veryLowPriorityFiles.push(fileNameInProject); - } else { - lowPriorityFiles.push(fileNameInProject); - } - } else { - mediumPriorityFiles.push(fileNameInProject); - } - } - } - const sortedFiles = [...highPriorityFiles, ...mediumPriorityFiles, ...lowPriorityFiles, ...veryLowPriorityFiles]; - const checkList = sortedFiles.map((fileName2) => ({ fileName: fileName2, project })); - this.updateErrorCheck( - next, - checkList, - delay, - /*requireOpen*/ - false - ); - } - configurePlugin(args) { - this.projectService.configurePlugin(args); - } - getSmartSelectionRange(args, simplifiedResult) { - const { locations } = args; - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(file)); - return map(locations, (location) => { - const pos = this.getPosition(location, scriptInfo); - const selectionRange = languageService.getSmartSelectionRange(file, pos); - return simplifiedResult ? this.mapSelectionRange(selectionRange, scriptInfo) : selectionRange; - }); - } - toggleLineComment(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfo(file); - const textRange = this.getRange(args, scriptInfo); - const textChanges2 = languageService.toggleLineComment(file, textRange); - if (simplifiedResult) { - const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file); - return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2)); - } - return textChanges2; - } - toggleMultilineComment(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const textRange = this.getRange(args, scriptInfo); - const textChanges2 = languageService.toggleMultilineComment(file, textRange); - if (simplifiedResult) { - const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file); - return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2)); - } - return textChanges2; - } - commentSelection(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const textRange = this.getRange(args, scriptInfo); - const textChanges2 = languageService.commentSelection(file, textRange); - if (simplifiedResult) { - const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file); - return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2)); - } - return textChanges2; - } - uncommentSelection(args, simplifiedResult) { - const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - const textRange = this.getRange(args, scriptInfo); - const textChanges2 = languageService.uncommentSelection(file, textRange); - if (simplifiedResult) { - const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file); - return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2)); - } - return textChanges2; - } - mapSelectionRange(selectionRange, scriptInfo) { - const result = { - textSpan: toProtocolTextSpan(selectionRange.textSpan, scriptInfo) - }; - if (selectionRange.parent) { - result.parent = this.mapSelectionRange(selectionRange.parent, scriptInfo); - } - return result; - } - getScriptInfoFromProjectService(file) { - const normalizedFile = toNormalizedPath(file); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(normalizedFile); - if (!scriptInfo) { - this.projectService.logErrorForScriptInfoNotFound(normalizedFile); - return Errors.ThrowNoProject(); - } - return scriptInfo; - } - toProtocolCallHierarchyItem(item) { - const scriptInfo = this.getScriptInfoFromProjectService(item.file); - return { - name: item.name, - kind: item.kind, - kindModifiers: item.kindModifiers, - file: item.file, - containerName: item.containerName, - span: toProtocolTextSpan(item.span, scriptInfo), - selectionSpan: toProtocolTextSpan(item.selectionSpan, scriptInfo) - }; - } - toProtocolCallHierarchyIncomingCall(incomingCall) { - const scriptInfo = this.getScriptInfoFromProjectService(incomingCall.from.file); - return { - from: this.toProtocolCallHierarchyItem(incomingCall.from), - fromSpans: incomingCall.fromSpans.map((fromSpan) => toProtocolTextSpan(fromSpan, scriptInfo)) - }; - } - toProtocolCallHierarchyOutgoingCall(outgoingCall, scriptInfo) { - return { - to: this.toProtocolCallHierarchyItem(outgoingCall.to), - fromSpans: outgoingCall.fromSpans.map((fromSpan) => toProtocolTextSpan(fromSpan, scriptInfo)) - }; - } - prepareCallHierarchy(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file); - if (scriptInfo) { - const position = this.getPosition(args, scriptInfo); - const result = project.getLanguageService().prepareCallHierarchy(file, position); - return result && mapOneOrMany(result, (item) => this.toProtocolCallHierarchyItem(item)); - } - return void 0; - } - provideCallHierarchyIncomingCalls(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.getScriptInfoFromProjectService(file); - const incomingCalls = project.getLanguageService().provideCallHierarchyIncomingCalls(file, this.getPosition(args, scriptInfo)); - return incomingCalls.map((call) => this.toProtocolCallHierarchyIncomingCall(call)); - } - provideCallHierarchyOutgoingCalls(args) { - const { file, project } = this.getFileAndProject(args); - const scriptInfo = this.getScriptInfoFromProjectService(file); - const outgoingCalls = project.getLanguageService().provideCallHierarchyOutgoingCalls(file, this.getPosition(args, scriptInfo)); - return outgoingCalls.map((call) => this.toProtocolCallHierarchyOutgoingCall(call, scriptInfo)); - } - getCanonicalFileName(fileName) { - const name = this.host.useCaseSensitiveFileNames ? fileName : toFileNameLowerCase(fileName); - return normalizePath(name); - } - exit() { - } - notRequired(request) { - if (request) this.doOutput( - /*info*/ - void 0, - request.command, - request.seq, - /*success*/ - true, - this.performanceData - ); - return { responseRequired: false, performanceData: this.performanceData }; - } - requiredResponse(response) { - return { response, responseRequired: true, performanceData: this.performanceData }; - } - addProtocolHandler(command, handler) { - if (this.handlers.has(command)) { - throw new Error(`Protocol handler already exists for command "${command}"`); - } - this.handlers.set(command, handler); - } - setCurrentRequest(requestId) { - Debug.assert(this.currentRequestId === void 0); - this.currentRequestId = requestId; - this.cancellationToken.setRequest(requestId); - } - resetCurrentRequest(requestId) { - Debug.assert(this.currentRequestId === requestId); - this.currentRequestId = void 0; - this.cancellationToken.resetRequest(requestId); - } - // eslint-disable-line @typescript-eslint/unified-signatures - executeWithRequestId(requestId, f, perfomanceData) { - const currentPerformanceData = this.performanceData; - try { - this.performanceData = perfomanceData; - this.setCurrentRequest(requestId); - return f(); - } finally { - this.resetCurrentRequest(requestId); - this.performanceData = currentPerformanceData; - } - } - executeCommand(request) { - const handler = this.handlers.get(request.command); - if (handler) { - const response = this.executeWithRequestId( - request.seq, - () => handler(request), - /*perfomanceData*/ - void 0 - ); - this.projectService.enableRequestedPlugins(); - return response; - } else { - this.logger.msg(`Unrecognized JSON command:${stringifyIndented(request)}`, "Err" /* Err */); - this.doOutput( - /*info*/ - void 0, - "unknown" /* Unknown */, - request.seq, - /*success*/ - false, - /*performanceData*/ - void 0, - `Unrecognized JSON command: ${request.command}` - ); - return { responseRequired: false }; - } - } - onMessage(message) { - var _a, _b, _c, _d, _e, _f, _g; - this.gcTimer.scheduleCollect(); - let start; - const currentPerformanceData = this.performanceData; - if (this.logger.hasLevel(2 /* requestTime */)) { - start = this.hrtime(); - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`request:${indent2(this.toStringMessage(message))}`); - } - } - let request; - let relevantFile; - try { - request = this.parseMessage(message); - relevantFile = request.arguments && request.arguments.file ? request.arguments : void 0; - (_a = tracing) == null ? void 0 : _a.instant(tracing.Phase.Session, "request", { seq: request.seq, command: request.command }); - (_b = tracing) == null ? void 0 : _b.push( - tracing.Phase.Session, - "executeCommand", - { seq: request.seq, command: request.command }, - /*separateBeginAndEnd*/ - true - ); - const { response, responseRequired, performanceData } = this.executeCommand(request); - (_c = tracing) == null ? void 0 : _c.pop(); - if (this.logger.hasLevel(2 /* requestTime */)) { - const elapsedTime = hrTimeToMilliseconds(this.hrtime(start)).toFixed(4); - if (responseRequired) { - this.logger.perftrc(`${request.seq}::${request.command}: elapsed time (in milliseconds) ${elapsedTime}`); - } else { - this.logger.perftrc(`${request.seq}::${request.command}: async elapsed time (in milliseconds) ${elapsedTime}`); - } - } - (_d = tracing) == null ? void 0 : _d.instant(tracing.Phase.Session, "response", { seq: request.seq, command: request.command, success: !!response }); - if (response) { - this.doOutput( - response, - request.command, - request.seq, - /*success*/ - true, - performanceData - ); - } else if (responseRequired) { - this.doOutput( - /*info*/ - void 0, - request.command, - request.seq, - /*success*/ - false, - performanceData, - "No content available." - ); - } - } catch (err) { - (_e = tracing) == null ? void 0 : _e.popAll(); - if (err instanceof OperationCanceledException) { - (_f = tracing) == null ? void 0 : _f.instant(tracing.Phase.Session, "commandCanceled", { seq: request == null ? void 0 : request.seq, command: request == null ? void 0 : request.command }); - this.doOutput( - { canceled: true }, - request.command, - request.seq, - /*success*/ - true, - this.performanceData - ); - return; - } - this.logErrorWorker(err, this.toStringMessage(message), relevantFile); - (_g = tracing) == null ? void 0 : _g.instant(tracing.Phase.Session, "commandError", { seq: request == null ? void 0 : request.seq, command: request == null ? void 0 : request.command, message: err.message }); - this.doOutput( - /*info*/ - void 0, - request ? request.command : "unknown" /* Unknown */, - request ? request.seq : 0, - /*success*/ - false, - this.performanceData, - "Error processing request. " + err.message + "\n" + err.stack - ); - } finally { - this.performanceData = currentPerformanceData; - } - } - parseMessage(message) { - return JSON.parse(message); - } - toStringMessage(message) { - return message; - } - getFormatOptions(file) { - return this.projectService.getFormatCodeOptions(file); - } - getPreferences(file) { - return this.projectService.getPreferences(file); - } - getHostFormatOptions() { - return this.projectService.getHostFormatCodeOptions(); - } - getHostPreferences() { - return this.projectService.getHostPreferences(); - } -}; -function toProtocolPerformanceData(performanceData) { - const diagnosticsDuration = performanceData.diagnosticsDuration && arrayFrom(performanceData.diagnosticsDuration, ([file, data]) => ({ ...data, file })); - return { ...performanceData, diagnosticsDuration }; -} -function toProtocolTextSpan(textSpan, scriptInfo) { - return { - start: scriptInfo.positionToLineOffset(textSpan.start), - end: scriptInfo.positionToLineOffset(textSpanEnd(textSpan)) - }; -} -function toProtocolTextSpanWithContext(span, contextSpan, scriptInfo) { - const textSpan = toProtocolTextSpan(span, scriptInfo); - const contextTextSpan = contextSpan && toProtocolTextSpan(contextSpan, scriptInfo); - return contextTextSpan ? { ...textSpan, contextStart: contextTextSpan.start, contextEnd: contextTextSpan.end } : textSpan; -} -function convertTextChangeToCodeEdit(change, scriptInfo) { - return { start: positionToLineOffset(scriptInfo, change.span.start), end: positionToLineOffset(scriptInfo, textSpanEnd(change.span)), newText: change.newText }; -} -function positionToLineOffset(info, position) { - return isConfigFile(info) ? locationFromLineAndCharacter(info.getLineAndCharacterOfPosition(position)) : info.positionToLineOffset(position); -} -function convertLinkedEditInfoToRanges(linkedEdit, scriptInfo) { - const ranges = linkedEdit.ranges.map( - (r) => { - return { - start: scriptInfo.positionToLineOffset(r.start), - end: scriptInfo.positionToLineOffset(r.start + r.length) - }; - } - ); - if (!linkedEdit.wordPattern) return { ranges }; - return { ranges, wordPattern: linkedEdit.wordPattern }; -} -function locationFromLineAndCharacter(lc) { - return { line: lc.line + 1, offset: lc.character + 1 }; -} -function convertNewFileTextChangeToCodeEdit(textChanges2) { - Debug.assert(textChanges2.textChanges.length === 1); - const change = first(textChanges2.textChanges); - Debug.assert(change.span.start === 0 && change.span.length === 0); - return { fileName: textChanges2.fileName, textChanges: [{ start: { line: 0, offset: 0 }, end: { line: 0, offset: 0 }, newText: change.newText }] }; -} -function getLocationInNewDocument(oldText, renameFilename, renameLocation, edits) { - const newText = applyEdits(oldText, renameFilename, edits); - const { line, character } = computeLineAndCharacterOfPosition(computeLineStarts(newText), renameLocation); - return { line: line + 1, offset: character + 1 }; -} -function applyEdits(text, textFilename, edits) { - for (const { fileName, textChanges: textChanges2 } of edits) { - if (fileName !== textFilename) { - continue; - } - for (let i = textChanges2.length - 1; i >= 0; i--) { - const { newText, span: { start, length: length2 } } = textChanges2[i]; - text = text.slice(0, start) + newText + text.slice(start + length2); - } - } - return text; -} -function referenceEntryToReferencesResponseItem(projectService, { fileName, textSpan, contextSpan, isWriteAccess: isWriteAccess2, isDefinition }, { disableLineTextInReferences }) { - const scriptInfo = Debug.checkDefined(projectService.getScriptInfo(fileName)); - const span = toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo); - const lineText = disableLineTextInReferences ? void 0 : getLineText(scriptInfo, span); - return { - file: fileName, - ...span, - lineText, - isWriteAccess: isWriteAccess2, - isDefinition - }; -} -function getLineText(scriptInfo, span) { - const lineSpan = scriptInfo.lineToTextSpan(span.start.line - 1); - return scriptInfo.getSnapshot().getText(lineSpan.start, textSpanEnd(lineSpan)).replace(/\r|\n/g, ""); -} -function isCompletionEntryData(data) { - return data === void 0 || data && typeof data === "object" && typeof data.exportName === "string" && (data.fileName === void 0 || typeof data.fileName === "string") && (data.ambientModuleName === void 0 || typeof data.ambientModuleName === "string" && (data.isPackageJsonImport === void 0 || typeof data.isPackageJsonImport === "boolean")); -} - -// src/server/scriptVersionCache.ts -var lineCollectionCapacity = 4; -var CharRangeSection = /* @__PURE__ */ ((CharRangeSection2) => { - CharRangeSection2[CharRangeSection2["PreStart"] = 0] = "PreStart"; - CharRangeSection2[CharRangeSection2["Start"] = 1] = "Start"; - CharRangeSection2[CharRangeSection2["Entire"] = 2] = "Entire"; - CharRangeSection2[CharRangeSection2["Mid"] = 3] = "Mid"; - CharRangeSection2[CharRangeSection2["End"] = 4] = "End"; - CharRangeSection2[CharRangeSection2["PostEnd"] = 5] = "PostEnd"; - return CharRangeSection2; -})(CharRangeSection || {}); -var EditWalker = class { - constructor() { - this.goSubtree = true; - this.lineIndex = new LineIndex(); - this.endBranch = []; - this.state = 2 /* Entire */; - this.initialText = ""; - this.trailingText = ""; - this.lineIndex.root = new LineNode(); - this.startPath = [this.lineIndex.root]; - this.stack = [this.lineIndex.root]; - } - get done() { - return false; - } - insertLines(insertedText, suppressTrailingText) { - if (suppressTrailingText) { - this.trailingText = ""; - } - if (insertedText) { - insertedText = this.initialText + insertedText + this.trailingText; - } else { - insertedText = this.initialText + this.trailingText; - } - const lm = LineIndex.linesFromText(insertedText); - const lines = lm.lines; - if (lines.length > 1 && lines[lines.length - 1] === "") { - lines.pop(); - } - let branchParent; - let lastZeroCount; - for (let k = this.endBranch.length - 1; k >= 0; k--) { - this.endBranch[k].updateCounts(); - if (this.endBranch[k].charCount() === 0) { - lastZeroCount = this.endBranch[k]; - if (k > 0) { - branchParent = this.endBranch[k - 1]; - } else { - branchParent = this.branchNode; - } - } - } - if (lastZeroCount) { - branchParent.remove(lastZeroCount); - } - const leafNode = this.startPath[this.startPath.length - 1]; - if (lines.length > 0) { - leafNode.text = lines[0]; - if (lines.length > 1) { - let insertedNodes = new Array(lines.length - 1); - let startNode2 = leafNode; - for (let i = 1; i < lines.length; i++) { - insertedNodes[i - 1] = new LineLeaf(lines[i]); - } - let pathIndex = this.startPath.length - 2; - while (pathIndex >= 0) { - const insertionNode = this.startPath[pathIndex]; - insertedNodes = insertionNode.insertAt(startNode2, insertedNodes); - pathIndex--; - startNode2 = insertionNode; - } - let insertedNodesLen = insertedNodes.length; - while (insertedNodesLen > 0) { - const newRoot = new LineNode(); - newRoot.add(this.lineIndex.root); - insertedNodes = newRoot.insertAt(this.lineIndex.root, insertedNodes); - insertedNodesLen = insertedNodes.length; - this.lineIndex.root = newRoot; - } - this.lineIndex.root.updateCounts(); - } else { - for (let j = this.startPath.length - 2; j >= 0; j--) { - this.startPath[j].updateCounts(); - } - } - } else { - const insertionNode = this.startPath[this.startPath.length - 2]; - insertionNode.remove(leafNode); - for (let j = this.startPath.length - 2; j >= 0; j--) { - this.startPath[j].updateCounts(); - } - } - return this.lineIndex; - } - post(_relativeStart, _relativeLength, lineCollection) { - if (lineCollection === this.lineCollectionAtBranch) { - this.state = 4 /* End */; - } - this.stack.pop(); - } - pre(_relativeStart, _relativeLength, lineCollection, _parent, nodeType) { - const currentNode = this.stack[this.stack.length - 1]; - if (this.state === 2 /* Entire */ && nodeType === 1 /* Start */) { - this.state = 1 /* Start */; - this.branchNode = currentNode; - this.lineCollectionAtBranch = lineCollection; - } - let child; - function fresh(node) { - if (node.isLeaf()) { - return new LineLeaf(""); - } else return new LineNode(); - } - switch (nodeType) { - case 0 /* PreStart */: - this.goSubtree = false; - if (this.state !== 4 /* End */) { - currentNode.add(lineCollection); - } - break; - case 1 /* Start */: - if (this.state === 4 /* End */) { - this.goSubtree = false; - } else { - child = fresh(lineCollection); - currentNode.add(child); - this.startPath.push(child); - } - break; - case 2 /* Entire */: - if (this.state !== 4 /* End */) { - child = fresh(lineCollection); - currentNode.add(child); - this.startPath.push(child); - } else { - if (!lineCollection.isLeaf()) { - child = fresh(lineCollection); - currentNode.add(child); - this.endBranch.push(child); - } - } - break; - case 3 /* Mid */: - this.goSubtree = false; - break; - case 4 /* End */: - if (this.state !== 4 /* End */) { - this.goSubtree = false; - } else { - if (!lineCollection.isLeaf()) { - child = fresh(lineCollection); - currentNode.add(child); - this.endBranch.push(child); - } - } - break; - case 5 /* PostEnd */: - this.goSubtree = false; - if (this.state !== 1 /* Start */) { - currentNode.add(lineCollection); - } - break; - } - if (this.goSubtree) { - this.stack.push(child); - } - } - // just gather text from the leaves - leaf(relativeStart, relativeLength, ll) { - if (this.state === 1 /* Start */) { - this.initialText = ll.text.substring(0, relativeStart); - } else if (this.state === 2 /* Entire */) { - this.initialText = ll.text.substring(0, relativeStart); - this.trailingText = ll.text.substring(relativeStart + relativeLength); - } else { - this.trailingText = ll.text.substring(relativeStart + relativeLength); - } - } -}; -var TextChange9 = class { - constructor(pos, deleteLen, insertedText) { - this.pos = pos; - this.deleteLen = deleteLen; - this.insertedText = insertedText; - } - getTextChangeRange() { - return createTextChangeRange(createTextSpan(this.pos, this.deleteLen), this.insertedText ? this.insertedText.length : 0); - } -}; -var _ScriptVersionCache = class _ScriptVersionCache { - constructor() { - this.changes = []; - this.versions = new Array(_ScriptVersionCache.maxVersions); - this.minVersion = 0; - // no versions earlier than min version will maintain change history - this.currentVersion = 0; - } - versionToIndex(version2) { - if (version2 < this.minVersion || version2 > this.currentVersion) { - return void 0; - } - return version2 % _ScriptVersionCache.maxVersions; - } - currentVersionToIndex() { - return this.currentVersion % _ScriptVersionCache.maxVersions; - } - // REVIEW: can optimize by coalescing simple edits - edit(pos, deleteLen, insertedText) { - this.changes.push(new TextChange9(pos, deleteLen, insertedText)); - if (this.changes.length > _ScriptVersionCache.changeNumberThreshold || deleteLen > _ScriptVersionCache.changeLengthThreshold || insertedText && insertedText.length > _ScriptVersionCache.changeLengthThreshold) { - this.getSnapshot(); - } - } - getSnapshot() { - return this._getSnapshot(); - } - _getSnapshot() { - let snap = this.versions[this.currentVersionToIndex()]; - if (this.changes.length > 0) { - let snapIndex = snap.index; - for (const change of this.changes) { - snapIndex = snapIndex.edit(change.pos, change.deleteLen, change.insertedText); - } - snap = new LineIndexSnapshot(this.currentVersion + 1, this, snapIndex, this.changes); - this.currentVersion = snap.version; - this.versions[this.currentVersionToIndex()] = snap; - this.changes = []; - if (this.currentVersion - this.minVersion >= _ScriptVersionCache.maxVersions) { - this.minVersion = this.currentVersion - _ScriptVersionCache.maxVersions + 1; - } - } - return snap; - } - getSnapshotVersion() { - return this._getSnapshot().version; - } - getAbsolutePositionAndLineText(oneBasedLine) { - return this._getSnapshot().index.lineNumberToInfo(oneBasedLine); - } - lineOffsetToPosition(line, column) { - return this._getSnapshot().index.absolutePositionOfStartOfLine(line) + (column - 1); - } - positionToLineOffset(position) { - return this._getSnapshot().index.positionToLineOffset(position); - } - lineToTextSpan(line) { - const index = this._getSnapshot().index; - const { lineText, absolutePosition } = index.lineNumberToInfo(line + 1); - const len = lineText !== void 0 ? lineText.length : index.absolutePositionOfStartOfLine(line + 2) - absolutePosition; - return createTextSpan(absolutePosition, len); - } - getTextChangesBetweenVersions(oldVersion, newVersion) { - if (oldVersion < newVersion) { - if (oldVersion >= this.minVersion) { - const textChangeRanges = []; - for (let i = oldVersion + 1; i <= newVersion; i++) { - const snap = this.versions[this.versionToIndex(i)]; - for (const textChange of snap.changesSincePreviousVersion) { - textChangeRanges.push(textChange.getTextChangeRange()); - } - } - return collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges); - } else { - return void 0; - } - } else { - return unchangedTextChangeRange; - } - } - getLineCount() { - return this._getSnapshot().index.getLineCount(); - } - static fromString(script) { - const svc = new _ScriptVersionCache(); - const snap = new LineIndexSnapshot(0, svc, new LineIndex()); - svc.versions[svc.currentVersion] = snap; - const lm = LineIndex.linesFromText(script); - snap.index.load(lm.lines); - return svc; - } -}; -_ScriptVersionCache.changeNumberThreshold = 8; -_ScriptVersionCache.changeLengthThreshold = 256; -_ScriptVersionCache.maxVersions = 8; -var ScriptVersionCache = _ScriptVersionCache; -var LineIndexSnapshot = class _LineIndexSnapshot { - constructor(version2, cache, index, changesSincePreviousVersion = emptyArray2) { - this.version = version2; - this.cache = cache; - this.index = index; - this.changesSincePreviousVersion = changesSincePreviousVersion; - } - getText(rangeStart, rangeEnd) { - return this.index.getText(rangeStart, rangeEnd - rangeStart); - } - getLength() { - return this.index.getLength(); - } - getChangeRange(oldSnapshot) { - if (oldSnapshot instanceof _LineIndexSnapshot && this.cache === oldSnapshot.cache) { - if (this.version <= oldSnapshot.version) { - return unchangedTextChangeRange; - } else { - return this.cache.getTextChangesBetweenVersions(oldSnapshot.version, this.version); - } - } - } -}; -var LineIndex = class _LineIndex { - constructor() { - // set this to true to check each edit for accuracy - this.checkEdits = false; - } - absolutePositionOfStartOfLine(oneBasedLine) { - return this.lineNumberToInfo(oneBasedLine).absolutePosition; - } - positionToLineOffset(position) { - const { oneBasedLine, zeroBasedColumn } = this.root.charOffsetToLineInfo(1, position); - return { line: oneBasedLine, offset: zeroBasedColumn + 1 }; - } - positionToColumnAndLineText(position) { - return this.root.charOffsetToLineInfo(1, position); - } - getLineCount() { - return this.root.lineCount(); - } - lineNumberToInfo(oneBasedLine) { - const lineCount = this.getLineCount(); - if (oneBasedLine <= lineCount) { - const { position, leaf } = this.root.lineNumberToInfo(oneBasedLine, 0); - return { absolutePosition: position, lineText: leaf && leaf.text }; - } else { - return { absolutePosition: this.root.charCount(), lineText: void 0 }; - } - } - load(lines) { - if (lines.length > 0) { - const leaves = []; - for (let i = 0; i < lines.length; i++) { - leaves[i] = new LineLeaf(lines[i]); - } - this.root = _LineIndex.buildTreeFromBottom(leaves); - } else { - this.root = new LineNode(); - } - } - walk(rangeStart, rangeLength, walkFns) { - this.root.walk(rangeStart, rangeLength, walkFns); - } - getText(rangeStart, rangeLength) { - let accum = ""; - if (rangeLength > 0 && rangeStart < this.root.charCount()) { - this.walk(rangeStart, rangeLength, { - goSubtree: true, - done: false, - leaf: (relativeStart, relativeLength, ll) => { - accum = accum.concat(ll.text.substring(relativeStart, relativeStart + relativeLength)); - } - }); - } - return accum; - } - getLength() { - return this.root.charCount(); - } - every(f, rangeStart, rangeEnd) { - if (!rangeEnd) { - rangeEnd = this.root.charCount(); - } - const walkFns = { - goSubtree: true, - done: false, - leaf(relativeStart, relativeLength, ll) { - if (!f(ll, relativeStart, relativeLength)) { - this.done = true; - } - } - }; - this.walk(rangeStart, rangeEnd - rangeStart, walkFns); - return !walkFns.done; - } - edit(pos, deleteLength, newText) { - if (this.root.charCount() === 0) { - Debug.assert(deleteLength === 0); - if (newText !== void 0) { - this.load(_LineIndex.linesFromText(newText).lines); - return this; - } - return void 0; - } else { - let checkText; - if (this.checkEdits) { - const source = this.getText(0, this.root.charCount()); - checkText = source.slice(0, pos) + newText + source.slice(pos + deleteLength); - } - const walker = new EditWalker(); - let suppressTrailingText = false; - if (pos >= this.root.charCount()) { - pos = this.root.charCount() - 1; - const endString = this.getText(pos, 1); - if (newText) { - newText = endString + newText; - } else { - newText = endString; - } - deleteLength = 0; - suppressTrailingText = true; - } else if (deleteLength > 0) { - const e = pos + deleteLength; - const { zeroBasedColumn, lineText } = this.positionToColumnAndLineText(e); - if (zeroBasedColumn === 0) { - deleteLength += lineText.length; - newText = newText ? newText + lineText : lineText; - } - } - this.root.walk(pos, deleteLength, walker); - walker.insertLines(newText, suppressTrailingText); - if (this.checkEdits) { - const updatedText = walker.lineIndex.getText(0, walker.lineIndex.getLength()); - Debug.assert(checkText === updatedText, "buffer edit mismatch"); - } - return walker.lineIndex; - } - } - static buildTreeFromBottom(nodes) { - if (nodes.length < lineCollectionCapacity) { - return new LineNode(nodes); - } - const interiorNodes = new Array(Math.ceil(nodes.length / lineCollectionCapacity)); - let nodeIndex = 0; - for (let i = 0; i < interiorNodes.length; i++) { - const end = Math.min(nodeIndex + lineCollectionCapacity, nodes.length); - interiorNodes[i] = new LineNode(nodes.slice(nodeIndex, end)); - nodeIndex = end; - } - return this.buildTreeFromBottom(interiorNodes); - } - static linesFromText(text) { - const lineMap = computeLineStarts(text); - if (lineMap.length === 0) { - return { lines: [], lineMap }; - } - const lines = new Array(lineMap.length); - const lc = lineMap.length - 1; - for (let lmi = 0; lmi < lc; lmi++) { - lines[lmi] = text.substring(lineMap[lmi], lineMap[lmi + 1]); - } - const endText = text.substring(lineMap[lc]); - if (endText.length > 0) { - lines[lc] = endText; - } else { - lines.pop(); - } - return { lines, lineMap }; - } -}; -var LineNode = class _LineNode { - constructor(children = []) { - this.children = children; - this.totalChars = 0; - this.totalLines = 0; - if (children.length) this.updateCounts(); - } - isLeaf() { - return false; - } - updateCounts() { - this.totalChars = 0; - this.totalLines = 0; - for (const child of this.children) { - this.totalChars += child.charCount(); - this.totalLines += child.lineCount(); - } - } - execWalk(rangeStart, rangeLength, walkFns, childIndex, nodeType) { - if (walkFns.pre) { - walkFns.pre(rangeStart, rangeLength, this.children[childIndex], this, nodeType); - } - if (walkFns.goSubtree) { - this.children[childIndex].walk(rangeStart, rangeLength, walkFns); - if (walkFns.post) { - walkFns.post(rangeStart, rangeLength, this.children[childIndex], this, nodeType); - } - } else { - walkFns.goSubtree = true; - } - return walkFns.done; - } - skipChild(relativeStart, relativeLength, childIndex, walkFns, nodeType) { - if (walkFns.pre && !walkFns.done) { - walkFns.pre(relativeStart, relativeLength, this.children[childIndex], this, nodeType); - walkFns.goSubtree = true; - } - } - walk(rangeStart, rangeLength, walkFns) { - let childIndex = 0; - let childCharCount = this.children[childIndex].charCount(); - let adjustedStart = rangeStart; - while (adjustedStart >= childCharCount) { - this.skipChild(adjustedStart, rangeLength, childIndex, walkFns, 0 /* PreStart */); - adjustedStart -= childCharCount; - childIndex++; - childCharCount = this.children[childIndex].charCount(); - } - if (adjustedStart + rangeLength <= childCharCount) { - if (this.execWalk(adjustedStart, rangeLength, walkFns, childIndex, 2 /* Entire */)) { - return; - } - } else { - if (this.execWalk(adjustedStart, childCharCount - adjustedStart, walkFns, childIndex, 1 /* Start */)) { - return; - } - let adjustedLength = rangeLength - (childCharCount - adjustedStart); - childIndex++; - const child = this.children[childIndex]; - childCharCount = child.charCount(); - while (adjustedLength > childCharCount) { - if (this.execWalk(0, childCharCount, walkFns, childIndex, 3 /* Mid */)) { - return; - } - adjustedLength -= childCharCount; - childIndex++; - childCharCount = this.children[childIndex].charCount(); - } - if (adjustedLength > 0) { - if (this.execWalk(0, adjustedLength, walkFns, childIndex, 4 /* End */)) { - return; - } - } - } - if (walkFns.pre) { - const clen = this.children.length; - if (childIndex < clen - 1) { - for (let ej = childIndex + 1; ej < clen; ej++) { - this.skipChild(0, 0, ej, walkFns, 5 /* PostEnd */); - } - } - } - } - // Input position is relative to the start of this node. - // Output line number is absolute. - charOffsetToLineInfo(lineNumberAccumulator, relativePosition) { - if (this.children.length === 0) { - return { oneBasedLine: lineNumberAccumulator, zeroBasedColumn: relativePosition, lineText: void 0 }; - } - for (const child of this.children) { - if (child.charCount() > relativePosition) { - if (child.isLeaf()) { - return { oneBasedLine: lineNumberAccumulator, zeroBasedColumn: relativePosition, lineText: child.text }; - } else { - return child.charOffsetToLineInfo(lineNumberAccumulator, relativePosition); - } - } else { - relativePosition -= child.charCount(); - lineNumberAccumulator += child.lineCount(); - } - } - const lineCount = this.lineCount(); - if (lineCount === 0) { - return { oneBasedLine: 1, zeroBasedColumn: 0, lineText: void 0 }; - } - const leaf = Debug.checkDefined(this.lineNumberToInfo(lineCount, 0).leaf); - return { oneBasedLine: lineCount, zeroBasedColumn: leaf.charCount(), lineText: void 0 }; - } - /** - * Input line number is relative to the start of this node. - * Output line number is relative to the child. - * positionAccumulator will be an absolute position once relativeLineNumber reaches 0. - */ - lineNumberToInfo(relativeOneBasedLine, positionAccumulator) { - for (const child of this.children) { - const childLineCount = child.lineCount(); - if (childLineCount >= relativeOneBasedLine) { - return child.isLeaf() ? { position: positionAccumulator, leaf: child } : child.lineNumberToInfo(relativeOneBasedLine, positionAccumulator); - } else { - relativeOneBasedLine -= childLineCount; - positionAccumulator += child.charCount(); - } - } - return { position: positionAccumulator, leaf: void 0 }; - } - splitAfter(childIndex) { - let splitNode; - const clen = this.children.length; - childIndex++; - const endLength = childIndex; - if (childIndex < clen) { - splitNode = new _LineNode(); - while (childIndex < clen) { - splitNode.add(this.children[childIndex]); - childIndex++; - } - splitNode.updateCounts(); - } - this.children.length = endLength; - return splitNode; - } - remove(child) { - const childIndex = this.findChildIndex(child); - const clen = this.children.length; - if (childIndex < clen - 1) { - for (let i = childIndex; i < clen - 1; i++) { - this.children[i] = this.children[i + 1]; - } - } - this.children.pop(); - } - findChildIndex(child) { - const childIndex = this.children.indexOf(child); - Debug.assert(childIndex !== -1); - return childIndex; - } - insertAt(child, nodes) { - let childIndex = this.findChildIndex(child); - const clen = this.children.length; - const nodeCount = nodes.length; - if (clen < lineCollectionCapacity && childIndex === clen - 1 && nodeCount === 1) { - this.add(nodes[0]); - this.updateCounts(); - return []; - } else { - const shiftNode = this.splitAfter(childIndex); - let nodeIndex = 0; - childIndex++; - while (childIndex < lineCollectionCapacity && nodeIndex < nodeCount) { - this.children[childIndex] = nodes[nodeIndex]; - childIndex++; - nodeIndex++; - } - let splitNodes = []; - let splitNodeCount = 0; - if (nodeIndex < nodeCount) { - splitNodeCount = Math.ceil((nodeCount - nodeIndex) / lineCollectionCapacity); - splitNodes = new Array(splitNodeCount); - let splitNodeIndex = 0; - for (let i = 0; i < splitNodeCount; i++) { - splitNodes[i] = new _LineNode(); - } - let splitNode = splitNodes[0]; - while (nodeIndex < nodeCount) { - splitNode.add(nodes[nodeIndex]); - nodeIndex++; - if (splitNode.children.length === lineCollectionCapacity) { - splitNodeIndex++; - splitNode = splitNodes[splitNodeIndex]; - } - } - for (let i = splitNodes.length - 1; i >= 0; i--) { - if (splitNodes[i].children.length === 0) { - splitNodes.pop(); - } - } - } - if (shiftNode) { - splitNodes.push(shiftNode); - } - this.updateCounts(); - for (let i = 0; i < splitNodeCount; i++) { - splitNodes[i].updateCounts(); - } - return splitNodes; - } - } - // assume there is room for the item; return true if more room - add(collection) { - this.children.push(collection); - Debug.assert(this.children.length <= lineCollectionCapacity); - } - charCount() { - return this.totalChars; - } - lineCount() { - return this.totalLines; - } -}; -var LineLeaf = class { - constructor(text) { - this.text = text; - } - isLeaf() { - return true; - } - walk(rangeStart, rangeLength, walkFns) { - walkFns.leaf(rangeStart, rangeLength, this); - } - charCount() { - return this.text.length; - } - lineCount() { - return 1; - } -}; - -// src/server/typingInstallerAdapter.ts -var _TypingsInstallerAdapter = class _TypingsInstallerAdapter { - constructor(telemetryEnabled, logger, host, globalTypingsCacheLocation, event, maxActiveRequestCount) { - this.telemetryEnabled = telemetryEnabled; - this.logger = logger; - this.host = host; - this.globalTypingsCacheLocation = globalTypingsCacheLocation; - this.event = event; - this.maxActiveRequestCount = maxActiveRequestCount; - this.activeRequestCount = 0; - this.requestQueue = createQueue(); - this.requestMap = /* @__PURE__ */ new Map(); - // Maps project name to newest requestQueue entry for that project - /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */ - this.requestedRegistry = false; - this.packageInstallId = 0; - } - isKnownTypesPackageName(name) { - var _a; - const validationResult = ts_JsTyping_exports.validatePackageName(name); - if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) { - return false; - } - if (!this.requestedRegistry) { - this.requestedRegistry = true; - this.installer.send({ kind: "typesRegistry" }); - } - return !!((_a = this.typesRegistryCache) == null ? void 0 : _a.has(name)); - } - installPackage(options) { - this.packageInstallId++; - const request = { kind: "installPackage", ...options, id: this.packageInstallId }; - const promise = new Promise((resolve, reject) => { - (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve, reject }); - }); - this.installer.send(request); - return promise; - } - attach(projectService) { - this.projectService = projectService; - this.installer = this.createInstallerProcess(); - } - onProjectClosed(p) { - this.installer.send({ projectName: p.getProjectName(), kind: "closeProject" }); - } - enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) { - const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports); - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Scheduling throttled operation:${stringifyIndented(request)}`); - } - if (this.activeRequestCount < this.maxActiveRequestCount) { - this.scheduleRequest(request); - } else { - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Deferring request for: ${request.projectName}`); - } - this.requestQueue.enqueue(request); - this.requestMap.set(request.projectName, request); - } - } - handleMessage(response) { - var _a, _b; - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Received response:${stringifyIndented(response)}`); - } - switch (response.kind) { - case EventTypesRegistry: - this.typesRegistryCache = new Map(Object.entries(response.typesRegistry)); - break; - case ActionPackageInstalled: { - const promise = (_a = this.packageInstalledPromise) == null ? void 0 : _a.get(response.id); - Debug.assertIsDefined(promise, "Should find the promise for package install"); - (_b = this.packageInstalledPromise) == null ? void 0 : _b.delete(response.id); - if (response.success) { - promise.resolve({ successMessage: response.message }); - } else { - promise.reject(response.message); - } - this.projectService.updateTypingsForProject(response); - this.event(response, "setTypings"); - break; - } - case EventInitializationFailed: { - const body = { - message: response.message - }; - const eventName = "typesInstallerInitializationFailed"; - this.event(body, eventName); - break; - } - case EventBeginInstallTypes: { - const body = { - eventId: response.eventId, - packages: response.packagesToInstall - }; - const eventName = "beginInstallTypes"; - this.event(body, eventName); - break; - } - case EventEndInstallTypes: { - if (this.telemetryEnabled) { - const body2 = { - telemetryEventName: "typingsInstalled", - payload: { - installedPackages: response.packagesToInstall.join(","), - installSuccess: response.installSuccess, - typingsInstallerVersion: response.typingsInstallerVersion - } - }; - const eventName2 = "telemetry"; - this.event(body2, eventName2); - } - const body = { - eventId: response.eventId, - packages: response.packagesToInstall, - success: response.installSuccess - }; - const eventName = "endInstallTypes"; - this.event(body, eventName); - break; - } - case ActionInvalidate: { - this.projectService.updateTypingsForProject(response); - break; - } - case ActionSet: { - if (this.activeRequestCount > 0) { - this.activeRequestCount--; - } else { - Debug.fail("TIAdapter:: Received too many responses"); - } - while (!this.requestQueue.isEmpty()) { - const queuedRequest = this.requestQueue.dequeue(); - if (this.requestMap.get(queuedRequest.projectName) === queuedRequest) { - this.requestMap.delete(queuedRequest.projectName); - this.scheduleRequest(queuedRequest); - break; - } - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Skipping defunct request for: ${queuedRequest.projectName}`); - } - } - this.projectService.updateTypingsForProject(response); - this.event(response, "setTypings"); - break; - } - case ActionWatchTypingLocations: - this.projectService.watchTypingLocations(response); - break; - default: - assertType(response); - } - } - scheduleRequest(request) { - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Scheduling request for: ${request.projectName}`); - } - this.activeRequestCount++; - this.host.setTimeout( - () => { - if (this.logger.hasLevel(3 /* verbose */)) { - this.logger.info(`TIAdapter:: Sending request:${stringifyIndented(request)}`); - } - this.installer.send(request); - }, - _TypingsInstallerAdapter.requestDelayMillis, - `${request.projectName}::${request.kind}` - ); - } -}; -// This number is essentially arbitrary. Processing more than one typings request -// at a time makes sense, but having too many in the pipe results in a hang -// (see https://github.com/nodejs/node/issues/7657). -// It would be preferable to base our limit on the amount of space left in the -// buffer, but we have yet to find a way to retrieve that value. -_TypingsInstallerAdapter.requestDelayMillis = 100; -var TypingsInstallerAdapter = _TypingsInstallerAdapter; - -// src/typescript/_namespaces/ts.server.ts -var ts_server_exports4 = {}; -__export(ts_server_exports4, { - ActionInvalidate: () => ActionInvalidate, - ActionPackageInstalled: () => ActionPackageInstalled, - ActionSet: () => ActionSet, - ActionWatchTypingLocations: () => ActionWatchTypingLocations, - Arguments: () => Arguments, - AutoImportProviderProject: () => AutoImportProviderProject, - AuxiliaryProject: () => AuxiliaryProject, - CharRangeSection: () => CharRangeSection, - CloseFileWatcherEvent: () => CloseFileWatcherEvent, - CommandNames: () => CommandNames, - ConfigFileDiagEvent: () => ConfigFileDiagEvent, - ConfiguredProject: () => ConfiguredProject2, - ConfiguredProjectLoadKind: () => ConfiguredProjectLoadKind, - CreateDirectoryWatcherEvent: () => CreateDirectoryWatcherEvent, - CreateFileWatcherEvent: () => CreateFileWatcherEvent, - Errors: () => Errors, - EventBeginInstallTypes: () => EventBeginInstallTypes, - EventEndInstallTypes: () => EventEndInstallTypes, - EventInitializationFailed: () => EventInitializationFailed, - EventTypesRegistry: () => EventTypesRegistry, - ExternalProject: () => ExternalProject, - GcTimer: () => GcTimer, - InferredProject: () => InferredProject2, - LargeFileReferencedEvent: () => LargeFileReferencedEvent, - LineIndex: () => LineIndex, - LineLeaf: () => LineLeaf, - LineNode: () => LineNode, - LogLevel: () => LogLevel2, - Msg: () => Msg, - OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent, - Project: () => Project2, - ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent, - ProjectKind: () => ProjectKind, - ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent, - ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent, - ProjectLoadingStartEvent: () => ProjectLoadingStartEvent, - ProjectService: () => ProjectService2, - ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent, - ScriptInfo: () => ScriptInfo, - ScriptVersionCache: () => ScriptVersionCache, - Session: () => Session3, - TextStorage: () => TextStorage, - ThrottledOperations: () => ThrottledOperations, - TypingsInstallerAdapter: () => TypingsInstallerAdapter, - allFilesAreJsOrDts: () => allFilesAreJsOrDts, - allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts, - asNormalizedPath: () => asNormalizedPath, - convertCompilerOptions: () => convertCompilerOptions, - convertFormatOptions: () => convertFormatOptions, - convertScriptKindName: () => convertScriptKindName, - convertTypeAcquisition: () => convertTypeAcquisition, - convertUserPreferences: () => convertUserPreferences, - convertWatchOptions: () => convertWatchOptions, - countEachFileTypes: () => countEachFileTypes, - createInstallTypingsRequest: () => createInstallTypingsRequest, - createModuleSpecifierCache: () => createModuleSpecifierCache, - createNormalizedPathMap: () => createNormalizedPathMap, - createPackageJsonCache: () => createPackageJsonCache, - createSortedArray: () => createSortedArray2, - emptyArray: () => emptyArray2, - findArgument: () => findArgument, - formatDiagnosticToProtocol: () => formatDiagnosticToProtocol, - formatMessage: () => formatMessage2, - getBaseConfigFileName: () => getBaseConfigFileName, - getLocationInNewDocument: () => getLocationInNewDocument, - hasArgument: () => hasArgument, - hasNoTypeScriptSource: () => hasNoTypeScriptSource, - indent: () => indent2, - isBackgroundProject: () => isBackgroundProject, - isConfigFile: () => isConfigFile, - isConfiguredProject: () => isConfiguredProject, - isDynamicFileName: () => isDynamicFileName, - isExternalProject: () => isExternalProject, - isInferredProject: () => isInferredProject, - isInferredProjectName: () => isInferredProjectName, - isProjectDeferredClose: () => isProjectDeferredClose, - makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName, - makeAuxiliaryProjectName: () => makeAuxiliaryProjectName, - makeInferredProjectName: () => makeInferredProjectName, - maxFileSize: () => maxFileSize, - maxProgramSizeForNonTsFiles: () => maxProgramSizeForNonTsFiles, - normalizedPathToPath: () => normalizedPathToPath, - nowString: () => nowString, - nullCancellationToken: () => nullCancellationToken, - nullTypingsInstaller: () => nullTypingsInstaller, - protocol: () => ts_server_protocol_exports, - stringifyIndented: () => stringifyIndented, - toEvent: () => toEvent, - toNormalizedPath: () => toNormalizedPath, - tryConvertScriptKindName: () => tryConvertScriptKindName, - typingsInstaller: () => ts_server_typingsInstaller_exports, - updateProjectIfDirty: () => updateProjectIfDirty -}); - // src/typescript/typescript.ts if (typeof console !== "undefined") { Debug.loggingHost = { @@ -194210,6 +182075,7 @@ if (typeof console !== "undefined") { PollingWatchKind, PragmaKindFlags, PredicateSemantics, + PreparePasteEdits, PrivateIdentifierKind, ProcessLevel, ProgramUpdateLevel, @@ -194302,10 +182168,8 @@ if (typeof console !== "undefined") { breakIntoWordSpans, buildLinkParts, buildOpts, - buildOverload, bundlerModuleNameResolver, canBeConvertedToAsync, - canEmitTsBuildInfo, canHaveDecorators, canHaveExportModifier, canHaveFlowNode, @@ -194325,6 +182189,7 @@ if (typeof console !== "undefined") { canWatchAffectingLocation, canWatchAtTypes, canWatchDirectoryOrFile, + canWatchDirectoryOrFilePath, cartesianProduct, cast, chainBundle, @@ -194490,7 +182355,6 @@ if (typeof console !== "undefined") { createNodeConverters, createNodeFactory, createOptionNameMap, - createOverload, createPackageJsonImportFilter, createPackageJsonInfo, createParenthesizerRules, @@ -194596,6 +182460,7 @@ if (typeof console !== "undefined") { escapeTemplateSubstitution, evaluatorResult, every, + exclusivelyPrefixedNodeCoreModules, executeCommandLine, expandPreOrPostfixIncrementOrDecrementExpression, explainFiles, @@ -194608,7 +182473,6 @@ if (typeof console !== "undefined") { extensionsNotSupportingExtensionlessResolution, externalHelpersModuleNameText, factory, - fileContainsPackageImport, fileExtensionIs, fileExtensionIsOneOf, fileIncludeReasonToDiagnostics, @@ -194658,8 +182522,10 @@ if (typeof console !== "undefined") { forEach, forEachAncestor, forEachAncestorDirectory, + forEachAncestorDirectoryStoppingAtGlobalCache, forEachChild, forEachChildRecursively, + forEachDynamicImportOrRequireCall, forEachEmittedFile, forEachEnclosingBlockScopeContainer, forEachEntry, @@ -194700,6 +182566,7 @@ if (typeof console !== "undefined") { getAllKeys, getAllProjectOutputs, getAllSuperTypeNodes, + getAllowImportingTsExtensions, getAllowJSCompilerOption, getAllowSyntheticDefaultImports, getAncestor, @@ -195008,6 +182875,7 @@ if (typeof console !== "undefined") { getPositionOfLineAndCharacter, getPossibleGenericSignatures, getPossibleOriginalInputExtensionForExtension, + getPossibleOriginalInputPathWithoutChangingExt, getPossibleTypeArgumentsInfo, getPreEmitDiagnostics, getPrecedingNonSpaceCharacterPosition, @@ -195271,7 +183139,7 @@ if (typeof console !== "undefined") { isBooleanLiteral, isBreakOrContinueStatement, isBreakStatement, - isBuild, + isBuildCommand, isBuildInfoFile, isBuilderProgram, isBundle, @@ -195458,7 +183326,7 @@ if (typeof console !== "undefined") { isImportSpecifier, isImportTypeAssertionContainer, isImportTypeNode, - isImportableFile, + isImportable, isInComment, isInCompoundLikeAssignment, isInExpressionContext, @@ -195557,6 +183425,7 @@ if (typeof console !== "undefined") { isJsxAttributeLike, isJsxAttributeName, isJsxAttributes, + isJsxCallLike, isJsxChild, isJsxClosingElement, isJsxClosingFragment, @@ -195639,6 +183508,7 @@ if (typeof console !== "undefined") { isNamespaceReexportDeclaration, isNewExpression, isNewExpressionTarget, + isNewScopeNode, isNoSubstitutionTemplateLiteral, isNodeArray, isNodeArrayMultiLine, @@ -195687,6 +183557,7 @@ if (typeof console !== "undefined") { isParseTreeNode, isPartOfParameterDeclaration, isPartOfTypeNode, + isPartOfTypeOnlyImportOrExportDeclaration, isPartOfTypeQuery, isPartiallyEmittedExpression, isPatternMatch, @@ -195755,6 +183626,7 @@ if (typeof console !== "undefined") { isSimpleInlineableExpression, isSimpleParameterList, isSingleOrDoubleQuote, + isSolutionConfig, isSourceElement, isSourceFile, isSourceFileFromLibrary, @@ -195863,7 +183735,6 @@ if (typeof console !== "undefined") { isVariableDeclarationInitializedToRequire, isVariableDeclarationList, isVariableLike, - isVariableLikeOrAccessor, isVariableStatement, isVoidExpression, isWatchSet, @@ -195900,6 +183771,7 @@ if (typeof console !== "undefined") { matchPatternOrExact, matchedText, matchesExclude, + matchesExcludeWorker, maxBy, maybeBind, maybeSetLocalizedDiagnosticMessages, @@ -195939,6 +183811,7 @@ if (typeof console !== "undefined") { noTransformers, noTruncationMaximumTruncationLength, nodeCanBeDecorated, + nodeCoreModules, nodeHasName, nodeIsDecorated, nodeIsMissing, @@ -196083,6 +183956,7 @@ if (typeof console !== "undefined") { returnTrue, returnUndefined, returnsPromise, + rewriteModuleSpecifier, sameFlatMap, sameMap, sameMapping, @@ -196128,6 +184002,7 @@ if (typeof console !== "undefined") { setValueDeclaration, shouldAllowImportingTsExtension, shouldPreserveConstEnums, + shouldRewriteModuleSpecifier, shouldUseUriStyleNodeCoreModules, showModuleSpecifier, signatureHasRestParameter, @@ -196185,6 +184060,7 @@ if (typeof console !== "undefined") { tagNamesAreEquivalent, takeWhile, targetOptionDeclaration, + targetToLibMap, testFormatSettings, textChangeRangeIsUnchanged, textChangeRangeNewSpan, @@ -196278,6 +184154,7 @@ if (typeof console !== "undefined") { tryRemoveExtension, tryRemovePrefix, tryRemoveSuffix, + tscBuildOption, typeAcquisitionDeclarations, typeAliasNamePart, typeDirectiveIsEqualTo, @@ -196289,6 +184166,7 @@ if (typeof console !== "undefined") { unescapeLeadingUnderscores, unmangleScopedPackageName, unorderedRemoveItem, + unprefixedNodeCoreModules, unreachableCodeIsError, unsetNodeChildren, unusedLabelIsError, diff --git a/cli/tsc/97_ts_host.js b/cli/tsc/97_ts_host.js index ba82a12b7c..9bafe82dbb 100644 --- a/cli/tsc/97_ts_host.js +++ b/cli/tsc/97_ts_host.js @@ -234,7 +234,14 @@ function fromRelatedInformation({ } if (start !== undefined && length !== undefined && file) { let startPos = file.getLineAndCharacterOfPosition(start); - let sourceLine = file.getFullText().split("\n")[startPos.line]; + let endPos = file.getLineAndCharacterOfPosition(start + length); + // ok to get because it's cached via file.getLineAndCharacterOfPosition + const lineStarts = file.getLineStarts(); + /** @type {string | undefined} */ + let sourceLine = file.getFullText().slice( + lineStarts[startPos.line], + lineStarts[startPos.line + 1], + ).trimEnd(); const originalFileName = file.fileName; const fileName = ops.op_remap_specifier ? (ops.op_remap_specifier(file.fileName) ?? file.fileName) @@ -244,12 +251,12 @@ function fromRelatedInformation({ if ( fileName.endsWith(".wasm") && originalFileName.endsWith(".wasm.d.mts") ) { - startPos = { line: 0, character: 0 }; + startPos = endPos = { line: 0, character: 0 }; sourceLine = undefined; } return { start: startPos, - end: file.getLineAndCharacterOfPosition(start + length), + end: endPos, fileName, messageChain, messageText, @@ -296,6 +303,9 @@ const IGNORED_DIAGNOSTICS = [ // TS1479: The current file is a CommonJS module whose imports will produce 'require' calls; // however, the referenced file is an ECMAScript module and cannot be imported with 'require'. 1479, + // TS1543: Importing a JSON file into an ECMAScript module requires a 'type: \"json\"' import + // attribute when 'module' is set to 'NodeNext'. + 1543, // TS2306: File '.../index.d.ts' is not a module. // We get this for `x-typescript-types` declaration files which don't export // anything. We prefer to treat these as modules with no exports. @@ -408,10 +418,6 @@ export const host = { return projectVersion; }, // @ts-ignore Undocumented method. - getModuleSpecifierCache() { - return moduleSpecifierCache; - }, - // @ts-ignore Undocumented method. getCachedExportInfoMap() { return exportMapCache; }, @@ -421,7 +427,7 @@ export const host = { // @ts-ignore Undocumented method. toPath(fileName) { // @ts-ignore Undocumented function. - ts.toPath( + return ts.toPath( fileName, this.getCurrentDirectory(), this.getCanonicalFileName.bind(this), @@ -716,9 +722,6 @@ export const host = { }, }; -// @ts-ignore Undocumented function. -const moduleSpecifierCache = ts.server.createModuleSpecifierCache(host); - // @ts-ignore Undocumented function. const exportMapCache = ts.createCacheableExportInfoMap(host); @@ -747,35 +750,6 @@ export function filterMapDiagnostic(diagnostic) { return false; } - // ignore diagnostics resulting from the `ImportMeta` declaration in deno merging with - // the one in @types/node. the types of the filename and dirname properties are different, - // which causes tsc to error. - const importMetaFilenameDirnameModifiersRe = - /^All declarations of '(filename|dirname)'/; - const importMetaFilenameDirnameTypesRe = - /^Subsequent property declarations must have the same type.\s+Property '(filename|dirname)'/; - // Declarations of X must have identical modifiers. - if (diagnostic.code === 2687) { - if ( - typeof diagnostic.messageText === "string" && - (importMetaFilenameDirnameModifiersRe.test(diagnostic.messageText)) && - (diagnostic.file?.fileName.startsWith("asset:///") || - diagnostic.file?.fileName?.includes("@types/node")) - ) { - return false; - } - } - // Subsequent property declarations must have the same type. - if (diagnostic.code === 2717) { - if ( - typeof diagnostic.messageText === "string" && - (importMetaFilenameDirnameTypesRe.test(diagnostic.messageText)) && - (diagnostic.file?.fileName.startsWith("asset:///") || - diagnostic.file?.fileName?.includes("@types/node")) - ) { - return false; - } - } // make the diagnostic for using an `export =` in an es module a warning if (diagnostic.code === 1203) { diagnostic.category = ts.DiagnosticCategory.Warning; @@ -789,33 +763,98 @@ export function filterMapDiagnostic(diagnostic) { } } } + return true; } // list of globals that should be kept in Node's globalThis -ts.deno.setNodeOnlyGlobalNames([ - "__dirname", - "__filename", - "Buffer", - "BufferConstructor", - "BufferEncoding", - "clearImmediate", - "clearInterval", - "clearTimeout", - "console", - "Console", - "ErrorConstructor", - "gc", - "Global", - "localStorage", - "queueMicrotask", - "RequestInit", - "ResponseInit", - "sessionStorage", - "setImmediate", - "setInterval", - "setTimeout", +ts.deno.setNodeOnlyGlobalNames( + new Set([ + "__dirname", + "__filename", + '"buffer"', + "Buffer", + "BufferConstructor", + "BufferEncoding", + "clearImmediate", + "clearInterval", + "clearTimeout", + "console", + "Console", + "crypto", + "ErrorConstructor", + "gc", + "Global", + "localStorage", + "queueMicrotask", + "RequestInit", + "ResponseInit", + "sessionStorage", + "setImmediate", + "setInterval", + "setTimeout", + ]), +); +// List of globals in @types/node that collide with Deno's types. +// When the `@types/node` package attempts to assign to these types +// if the type is already in the global symbol table, then assignment +// will be a no-op, but if the global type does not exist then the package can +// create the global. +const setTypesNodeIgnorableNames = new Set([ + "AbortController", + "AbortSignal", + "AsyncIteratorObject", + "atob", + "Blob", + "BroadcastChannel", + "btoa", + "ByteLengthQueuingStrategy", + "CompressionStream", + "CountQueuingStrategy", + "DecompressionStream", + "Disposable", + "DOMException", + "Event", + "EventSource", + "EventTarget", + "fetch", + "File", + "Float32Array", + "Float64Array", + "FormData", + "Headers", + "ImportMeta", + "MessageChannel", + "MessageEvent", + "MessagePort", + "performance", + "PerformanceEntry", + "PerformanceMark", + "PerformanceMeasure", + "ReadableByteStreamController", + "ReadableStream", + "ReadableStreamBYOBReader", + "ReadableStreamBYOBRequest", + "ReadableStreamDefaultController", + "ReadableStreamDefaultReader", + "ReadonlyArray", + "Request", + "Response", + "Storage", + "TextDecoder", + "TextDecoderStream", + "TextEncoder", + "TextEncoderStream", + "TransformStream", + "TransformStreamDefaultController", + "URL", + "URLSearchParams", + "WebSocket", + "WritableStream", + "WritableStreamDefaultController", + "WritableStreamDefaultWriter", ]); +ts.deno.setTypesNodeIgnorableNames(setTypesNodeIgnorableNames); export function getAssets() { /** @type {{ specifier: string; text: string; }[]} */ diff --git a/cli/tsc/dts/lib.decorators.d.ts b/cli/tsc/dts/lib.decorators.d.ts index 5ac09b8257..5ad7216a1a 100644 --- a/cli/tsc/dts/lib.decorators.d.ts +++ b/cli/tsc/dts/lib.decorators.d.ts @@ -110,9 +110,9 @@ interface ClassMethodDecoratorContext< }; /** - * Adds a callback to be invoked either before static initializers are run (when - * decorating a `static` element), or before instance initializers are run (when - * decorating a non-`static` element). + * Adds a callback to be invoked either after static methods are defined but before + * static initializers are run (when decorating a `static` element), or before instance + * initializers are run (when decorating a non-`static` element). * * @example * ```ts @@ -176,9 +176,9 @@ interface ClassGetterDecoratorContext< }; /** - * Adds a callback to be invoked either before static initializers are run (when - * decorating a `static` element), or before instance initializers are run (when - * decorating a non-`static` element). + * Adds a callback to be invoked either after static methods are defined but before + * static initializers are run (when decorating a `static` element), or before instance + * initializers are run (when decorating a non-`static` element). */ addInitializer(initializer: (this: This) => void): void; @@ -223,9 +223,9 @@ interface ClassSetterDecoratorContext< }; /** - * Adds a callback to be invoked either before static initializers are run (when - * decorating a `static` element), or before instance initializers are run (when - * decorating a non-`static` element). + * Adds a callback to be invoked either after static methods are defined but before + * static initializers are run (when decorating a `static` element), or before instance + * initializers are run (when decorating a non-`static` element). */ addInitializer(initializer: (this: This) => void): void; @@ -279,9 +279,8 @@ interface ClassAccessorDecoratorContext< }; /** - * Adds a callback to be invoked either before static initializers are run (when - * decorating a `static` element), or before instance initializers are run (when - * decorating a non-`static` element). + * Adds a callback to be invoked immediately after the auto `accessor` being + * decorated is initialized (regardless if the `accessor` is `static` or not). */ addInitializer(initializer: (this: This) => void): void; @@ -376,9 +375,8 @@ interface ClassFieldDecoratorContext< }; /** - * Adds a callback to be invoked either before static initializers are run (when - * decorating a `static` element), or before instance initializers are run (when - * decorating a non-`static` element). + * Adds a callback to be invoked immediately after the field being decorated + * is initialized (regardless if the field is `static` or not). */ addInitializer(initializer: (this: This) => void): void; diff --git a/cli/tsc/dts/lib.deno.ns.d.ts b/cli/tsc/dts/lib.deno.ns.d.ts index 7bfc3bb97b..76ca48b1a7 100644 --- a/cli/tsc/dts/lib.deno.ns.d.ts +++ b/cli/tsc/dts/lib.deno.ns.d.ts @@ -1786,7 +1786,7 @@ declare namespace Deno { * } * ``` */ - readonly readable: ReadableStream; + readonly readable: ReadableStream>; /** A {@linkcode WritableStream} instance to write the contents of the * file. This makes it easy to interoperate with other web streams based * APIs. @@ -1801,7 +1801,7 @@ declare namespace Deno { * } * ``` */ - readonly writable: WritableStream; + readonly writable: WritableStream>; /** Write the contents of the array buffer (`p`) to the file. * * Resolves to the number of bytes written. @@ -2268,7 +2268,7 @@ declare namespace Deno { */ close(): void; /** A readable stream interface to `stdin`. */ - readonly readable: ReadableStream; + readonly readable: ReadableStream>; /** * Set TTY to be under raw mode or not. In raw mode, characters are read and * returned as is, without being processed. All special processing of @@ -2346,7 +2346,7 @@ declare namespace Deno { */ close(): void; /** A writable stream interface to `stdout`. */ - readonly writable: WritableStream; + readonly writable: WritableStream>; /** * Checks if `stdout` is a TTY (terminal). * @@ -2410,7 +2410,7 @@ declare namespace Deno { */ close(): void; /** A writable stream interface to `stderr`. */ - readonly writable: WritableStream; + readonly writable: WritableStream>; /** * Checks if `stderr` is a TTY (terminal). * @@ -2921,7 +2921,7 @@ declare namespace Deno { export function readFile( path: string | URL, options?: ReadFileOptions, - ): Promise; + ): Promise>; /** Synchronously reads and returns the entire contents of a file as an array * of bytes. `TextDecoder` can be used to transform the bytes to string if @@ -2938,7 +2938,7 @@ declare namespace Deno { * @tags allow-read * @category File System */ - export function readFileSync(path: string | URL): Uint8Array; + export function readFileSync(path: string | URL): Uint8Array; /** Provides information about a file and is returned by * {@linkcode Deno.stat}, {@linkcode Deno.lstat}, {@linkcode Deno.statSync}, @@ -3731,9 +3731,9 @@ declare namespace Deno { * @category Subprocess */ export class ChildProcess implements AsyncDisposable { - get stdin(): WritableStream; - get stdout(): ReadableStream; - get stderr(): ReadableStream; + get stdin(): WritableStream>; + get stdout(): ReadableStream>; + get stderr(): ReadableStream>; readonly pid: number; /** Get the status of the child. */ readonly status: Promise; @@ -3845,9 +3845,9 @@ declare namespace Deno { */ export interface CommandOutput extends CommandStatus { /** The buffered output from the child process' `stdout`. */ - readonly stdout: Uint8Array; + readonly stdout: Uint8Array; /** The buffered output from the child process' `stderr`. */ - readonly stderr: Uint8Array; + readonly stderr: Uint8Array; } /** Option which can be specified when performing {@linkcode Deno.inspect}. diff --git a/cli/tsc/dts/lib.deno.unstable.d.ts b/cli/tsc/dts/lib.deno.unstable.d.ts index 4c47ad003c..6c901b864c 100644 --- a/cli/tsc/dts/lib.deno.unstable.d.ts +++ b/cli/tsc/dts/lib.deno.unstable.d.ts @@ -77,7 +77,8 @@ declare namespace Deno { * @category Network * @experimental */ - export interface DatagramConn extends AsyncIterable<[Uint8Array, Addr]> { + export interface DatagramConn + extends AsyncIterable<[Uint8Array, Addr]> { /** Joins an IPv4 multicast group. */ joinMulticastV4( address: string, @@ -95,7 +96,7 @@ declare namespace Deno { * Messages are received in the format of a tuple containing the data array * and the address information. */ - receive(p?: Uint8Array): Promise<[Uint8Array, Addr]>; + receive(p?: Uint8Array): Promise<[Uint8Array, Addr]>; /** Sends a message to the target via the connection. The method resolves * with the number of bytes sent. */ send(p: Uint8Array, addr: Addr): Promise; @@ -104,7 +105,9 @@ declare namespace Deno { close(): void; /** Return the address of the instance. */ readonly addr: Addr; - [Symbol.asyncIterator](): AsyncIterableIterator<[Uint8Array, Addr]>; + [Symbol.asyncIterator](): AsyncIterableIterator< + [Uint8Array, Addr] + >; } /** @@ -1402,8 +1405,8 @@ interface WebSocketStreamOptions { * @experimental */ interface WebSocketConnection { - readable: ReadableStream; - writable: WritableStream; + readable: ReadableStream>; + writable: WritableStream>; extensions: string; protocol: string; } @@ -3110,7 +3113,7 @@ declare namespace Intl { * @category Platform * @experimental */ -interface Float16Array { +interface Float16Array { /** * The size in bytes of each element in the array. */ @@ -3119,7 +3122,7 @@ interface Float16Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -3131,6 +3134,12 @@ interface Float16Array { */ readonly byteOffset: number; + /** + * Returns the item located at the specified index. + * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. + */ + at(index: number): number | undefined; + /** * Returns the this object after copying a section of the array identified by start and end * to the same array starting at position target @@ -3151,7 +3160,7 @@ interface Float16Array { * If thisArg is omitted, undefined is used as the this value. */ every( - predicate: (value: number, index: number, array: Float16Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): boolean; @@ -3173,9 +3182,9 @@ interface Float16Array { * If thisArg is omitted, undefined is used as the this value. */ filter( - predicate: (value: number, index: number, array: Float16Array) => any, + predicate: (value: number, index: number, array: this) => any, thisArg?: any, - ): Float16Array; + ): Float16Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3187,7 +3196,7 @@ interface Float16Array { * predicate. If it is not provided, undefined is used instead. */ find( - predicate: (value: number, index: number, obj: Float16Array) => boolean, + predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any, ): number | undefined; @@ -3201,7 +3210,51 @@ interface Float16Array { * predicate. If it is not provided, undefined is used instead. */ findIndex( - predicate: (value: number, index: number, obj: Float16Array) => boolean, + predicate: (value: number, index: number, obj: this) => boolean, + thisArg?: any, + ): number; + + /** + * Returns the value of the last element in the array where predicate is true, and undefined + * otherwise. + * @param predicate findLast calls predicate once for each element of the array, in descending + * order, until it finds one where predicate returns true. If such an element is found, findLast + * immediately returns that element value. Otherwise, findLast returns undefined. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findLast( + predicate: ( + value: number, + index: number, + array: this, + ) => value is S, + thisArg?: any, + ): S | undefined; + findLast( + predicate: ( + value: number, + index: number, + array: this, + ) => unknown, + thisArg?: any, + ): number | undefined; + + /** + * Returns the index of the last element in the array where predicate is true, and -1 + * otherwise. + * @param predicate findLastIndex calls predicate once for each element of the array, in descending + * order, until it finds one where predicate returns true. If such an element is found, + * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. + * @param thisArg If provided, it will be used as the this value for each invocation of + * predicate. If it is not provided, undefined is used instead. + */ + findLastIndex( + predicate: ( + value: number, + index: number, + array: this, + ) => unknown, thisArg?: any, ): number; @@ -3213,10 +3266,17 @@ interface Float16Array { * If thisArg is omitted, undefined is used as the this value. */ forEach( - callbackfn: (value: number, index: number, array: Float16Array) => void, + callbackfn: (value: number, index: number, array: this) => void, thisArg?: any, ): void; + /** + * Determines whether an array includes a certain element, returning true or false as appropriate. + * @param searchElement The element to search for. + * @param fromIndex The position in this array at which to begin searching for searchElement. + */ + includes(searchElement: number, fromIndex?: number): boolean; + /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. @@ -3254,9 +3314,9 @@ interface Float16Array { * If thisArg is omitted, undefined is used as the this value. */ map( - callbackfn: (value: number, index: number, array: Float16Array) => number, + callbackfn: (value: number, index: number, array: this) => number, thisArg?: any, - ): Float16Array; + ): Float16Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3273,7 +3333,7 @@ interface Float16Array { previousValue: number, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => number, ): number; reduce( @@ -3281,7 +3341,7 @@ interface Float16Array { previousValue: number, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => number, initialValue: number, ): number; @@ -3301,7 +3361,7 @@ interface Float16Array { previousValue: U, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => U, initialValue: U, ): U; @@ -3321,7 +3381,7 @@ interface Float16Array { previousValue: number, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => number, ): number; reduceRight( @@ -3329,7 +3389,7 @@ interface Float16Array { previousValue: number, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => number, initialValue: number, ): number; @@ -3349,7 +3409,7 @@ interface Float16Array { previousValue: U, currentValue: number, currentIndex: number, - array: Float16Array, + array: this, ) => U, initialValue: U, ): U; @@ -3357,7 +3417,7 @@ interface Float16Array { /** * Reverses the elements in an Array. */ - reverse(): Float16Array; + reverse(): this; /** * Sets a value or an array of values. @@ -3371,7 +3431,7 @@ interface Float16Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Float16Array; + slice(start?: number, end?: number): Float16Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -3382,7 +3442,7 @@ interface Float16Array { * If thisArg is omitted, undefined is used as the this value. */ some( - predicate: (value: number, index: number, array: Float16Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): boolean; @@ -3403,12 +3463,34 @@ interface Float16Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Float16Array; + subarray(begin?: number, end?: number): Float16Array; /** * Converts a number to a string by using the current locale. */ - toLocaleString(): string; + toLocaleString( + locales?: string | string[], + options?: Intl.NumberFormatOptions, + ): string; + + /** + * Copies the array and returns the copy with the elements in reverse order. + */ + toReversed(): Float16Array; + + /** + * Copies and sorts the array. + * @param compareFn Function used to determine the order of the elements. It is expected to return + * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive + * value otherwise. If omitted, the elements are sorted in ascending order. + * ```ts + * const myNums = Float16Array.from([11.25, 2, -22.5, 1]); + * myNums.toSorted((a, b) => a - b) // Float16Array(4) [-22.5, 1, 2, 11.5] + * ``` + */ + toSorted( + compareFn?: (a: number, b: number) => number, + ): Float16Array; /** * Returns a string representation of an array. @@ -3416,9 +3498,37 @@ interface Float16Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Float16Array; + valueOf(): this; + + /** + * Copies the array and inserts the given number at the provided index. + * @param index The index of the value to overwrite. If the index is + * negative, then it replaces from the end of the array. + * @param value The value to insert into the copied array. + * @returns A copy of the original array with the inserted value. + */ + with(index: number, value: number): Float16Array; [index: number]: number; + + [Symbol.iterator](): ArrayIterator; + + /** + * Returns an array of key, value pairs for every entry in the array + */ + entries(): ArrayIterator<[number, number]>; + + /** + * Returns an list of keys in the array + */ + keys(): ArrayIterator; + + /** + * Returns an list of values in the array + */ + values(): ArrayIterator; + + readonly [Symbol.toStringTag]: "Float16Array"; } /** @@ -3426,14 +3536,14 @@ interface Float16Array { * @experimental */ interface Float16ArrayConstructor { - readonly prototype: Float16Array; - new (length: number): Float16Array; - new (array: ArrayLike | ArrayBufferLike): Float16Array; - new ( - buffer: ArrayBufferLike, + readonly prototype: Float16Array; + new (length?: number): Float16Array; + new (array: ArrayLike | Iterable): Float16Array; + new ( + buffer: TArrayBuffer, byteOffset?: number, length?: number, - ): Float16Array; + ): Float16Array; /** * The size in bytes of each element in the array. @@ -3444,17 +3554,17 @@ interface Float16ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Float16Array; + of(...items: number[]): Float16Array; /** * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. + * @param arrayLike An array-like object to convert to an array. */ - from(arrayLike: ArrayLike): Float16Array; + from(arrayLike: ArrayLike): Float16Array; /** * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. + * @param arrayLike An array-like object to convert to an array. * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ @@ -3462,8 +3572,27 @@ interface Float16ArrayConstructor { arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any, - ): Float16Array; + ): Float16Array; + + /** + * Creates an array from an array-like or iterable object. + * @param elements An iterable object to convert to an array. + */ + from(elements: Iterable): Float16Array; + + /** + * Creates an array from an array-like or iterable object. + * @param elements An iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from( + elements: Iterable, + mapfn?: (v: T, k: number) => number, + thisArg?: any, + ): Float16Array; } + /** * @category Platform * @experimental @@ -3474,169 +3603,30 @@ declare var Float16Array: Float16ArrayConstructor; * @category Platform * @experimental */ -interface Float16Array { - [Symbol.iterator](): IterableIterator; +interface Math { /** - * Returns an array of key, value pairs for every entry in the array + * Returns the nearest half precision float representation of a number. + * @param x A numeric expression. + * + * @category Platform + * @experimental */ - entries(): IterableIterator<[number, number]>; - /** - * Returns an list of keys in the array - */ - keys(): IterableIterator; - /** - * Returns an list of values in the array - */ - values(): IterableIterator; + f16round(x: number): number; } /** * @category Platform * @experimental */ -interface Float16Constructor { - new (elements: Iterable): Float16Array; - - /** - * Creates an array from an array-like or iterable object. - * @param arrayLike An array-like or iterable object to convert to an array. - * @param mapfn A mapping function to call on every element of the array. - * @param thisArg Value of 'this' used to invoke the mapfn. - */ - from( - arrayLike: Iterable, - mapfn?: (v: number, k: number) => number, - thisArg?: any, - ): Float16Array; -} - -/** - * @category Platform - * @experimental - */ -interface Float16Array { - readonly [Symbol.toStringTag]: "Float16Array"; -} - -/** - * @category Platform - * @experimental - */ -interface Float16Array { - /** - * Determines whether an array includes a certain element, returning true or false as appropriate. - * @param searchElement The element to search for. - * @param fromIndex The position in this array at which to begin searching for searchElement. - */ - includes(searchElement: number, fromIndex?: number): boolean; -} - -/** - * @category Platform - * @experimental - */ -interface Float16ArrayConstructor { - new (): Float16Array; -} - -/** - * @category Platform - * @experimental - */ -interface Float16Array { - /** - * Returns the item located at the specified index. - * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. - */ - at(index: number): number | undefined; -} - -/** - * @category Platform - * @experimental - */ -interface Float16Array { - /** - * Returns the value of the last element in the array where predicate is true, and undefined - * otherwise. - * @param predicate findLast calls predicate once for each element of the array, in descending - * order, until it finds one where predicate returns true. If such an element is found, findLast - * immediately returns that element value. Otherwise, findLast returns undefined. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ - findLast( - predicate: ( - value: number, - index: number, - array: Float16Array, - ) => value is S, - thisArg?: any, - ): S | undefined; - findLast( - predicate: ( - value: number, - index: number, - array: Float16Array, - ) => unknown, - thisArg?: any, - ): number | undefined; - - /** - * Returns the index of the last element in the array where predicate is true, and -1 - * otherwise. - * @param predicate findLastIndex calls predicate once for each element of the array, in descending - * order, until it finds one where predicate returns true. If such an element is found, - * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. - * @param thisArg If provided, it will be used as the this value for each invocation of - * predicate. If it is not provided, undefined is used instead. - */ - findLastIndex( - predicate: ( - value: number, - index: number, - array: Float16Array, - ) => unknown, - thisArg?: any, - ): number; - - /** - * Copies the array and returns the copy with the elements in reverse order. - */ - toReversed(): Float16Array; - - /** - * Copies and sorts the array. - * @param compareFn Function used to determine the order of the elements. It is expected to return - * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive - * value otherwise. If omitted, the elements are sorted in ascending order. - * ```ts - * const myNums = Float16Array.from([11.25, 2, -22.5, 1]); - * myNums.toSorted((a, b) => a - b) // Float16Array(4) [-22.5, 1, 2, 11.5] - * ``` - */ - toSorted(compareFn?: (a: number, b: number) => number): Float16Array; - - /** - * Copies the array and inserts the given number at the provided index. - * @param index The index of the value to overwrite. If the index is - * negative, then it replaces from the end of the array. - * @param value The value to insert into the copied array. - * @returns A copy of the original array with the inserted value. - */ - with(index: number, value: number): Float16Array; -} - -/** - * @category Platform - * @experimental - */ -interface DataView { +interface DataView { /** * Gets the Float16 value at the specified byte offset from the start of the view. There is * no alignment constraint; multi-byte values may be fetched from any offset. * @param byteOffset The place in the buffer at which the value should be retrieved. * @param littleEndian If false or undefined, a big-endian value should be read. + * + * @category Platform + * @experimental */ getFloat16(byteOffset: number, littleEndian?: boolean): number; @@ -3645,6 +3635,9 @@ interface DataView { * @param byteOffset The place in the buffer at which the value should be set. * @param value The value to set. * @param littleEndian If false or undefined, a big-endian value should be written. + * + * @category Platform + * @experimental */ setFloat16(byteOffset: number, value: number, littleEndian?: boolean): void; } diff --git a/cli/tsc/dts/lib.dom.d.ts b/cli/tsc/dts/lib.dom.d.ts index 2684735597..9714699205 100644 --- a/cli/tsc/dts/lib.dom.d.ts +++ b/cli/tsc/dts/lib.dom.d.ts @@ -27,6 +27,19 @@ interface AddEventListenerOptions extends EventListenerOptions { signal?: AbortSignal; } +interface AddressErrors { + addressLine?: string; + city?: string; + country?: string; + dependentLocality?: string; + organization?: string; + phone?: string; + postalCode?: string; + recipient?: string; + region?: string; + sortingCode?: string; +} + interface AesCbcParams extends Algorithm { iv: BufferSource; } @@ -108,6 +121,59 @@ interface AudioContextOptions { sampleRate?: number; } +interface AudioDataCopyToOptions { + format?: AudioSampleFormat; + frameCount?: number; + frameOffset?: number; + planeIndex: number; +} + +interface AudioDataInit { + data: BufferSource; + format: AudioSampleFormat; + numberOfChannels: number; + numberOfFrames: number; + sampleRate: number; + timestamp: number; + transfer?: ArrayBuffer[]; +} + +interface AudioDecoderConfig { + codec: string; + description?: BufferSource; + numberOfChannels: number; + sampleRate: number; +} + +interface AudioDecoderInit { + error: WebCodecsErrorCallback; + output: AudioDataOutputCallback; +} + +interface AudioDecoderSupport { + config?: AudioDecoderConfig; + supported?: boolean; +} + +interface AudioEncoderConfig { + bitrate?: number; + bitrateMode?: BitrateMode; + codec: string; + numberOfChannels: number; + opus?: OpusEncoderConfig; + sampleRate: number; +} + +interface AudioEncoderInit { + error: WebCodecsErrorCallback; + output: EncodedAudioChunkOutputCallback; +} + +interface AudioEncoderSupport { + config?: AudioEncoderConfig; + supported?: boolean; +} + interface AudioNodeOptions { channelCount?: number; channelCountMode?: ChannelCountMode; @@ -138,12 +204,32 @@ interface AuthenticationExtensionsClientInputs { credProps?: boolean; hmacCreateSecret?: boolean; minPinLength?: boolean; + prf?: AuthenticationExtensionsPRFInputs; +} + +interface AuthenticationExtensionsClientInputsJSON { } interface AuthenticationExtensionsClientOutputs { appid?: boolean; credProps?: CredentialPropertiesOutput; hmacCreateSecret?: boolean; + prf?: AuthenticationExtensionsPRFOutputs; +} + +interface AuthenticationExtensionsPRFInputs { + eval?: AuthenticationExtensionsPRFValues; + evalByCredential?: Record; +} + +interface AuthenticationExtensionsPRFOutputs { + enabled?: boolean; + results?: AuthenticationExtensionsPRFValues; +} + +interface AuthenticationExtensionsPRFValues { + first: BufferSource; + second?: BufferSource; } interface AuthenticatorSelectionCriteria { @@ -209,6 +295,10 @@ interface CanvasRenderingContext2DSettings { willReadFrequently?: boolean; } +interface CaretPositionFromPointOptions { + shadowRoots?: ShadowRoot[]; +} + interface ChannelMergerOptions extends AudioNodeOptions { numberOfInputs?: number; } @@ -469,6 +559,18 @@ interface ElementDefinitionOptions { extends?: string; } +interface EncodedAudioChunkInit { + data: AllowSharedBufferSource; + duration?: number; + timestamp: number; + transfer?: ArrayBuffer[]; + type: EncodedAudioChunkType; +} + +interface EncodedAudioChunkMetadata { + decoderConfig?: AudioDecoderConfig; +} + interface EncodedVideoChunkInit { data: AllowSharedBufferSource; duration?: number; @@ -699,16 +801,6 @@ interface InputEventInit extends UIEventInit { targetRanges?: StaticRange[]; } -interface IntersectionObserverEntryInit { - boundingClientRect: DOMRectInit; - intersectionRatio: number; - intersectionRect: DOMRectInit; - isIntersecting: boolean; - rootBounds: DOMRectInit | null; - target: Element; - time: DOMHighResTimeStamp; -} - interface IntersectionObserverInit { root?: Element | Document | null; rootMargin?: string; @@ -918,6 +1010,7 @@ interface MediaStreamTrackEventInit extends EventInit { interface MediaTrackCapabilities { aspectRatio?: DoubleRange; autoGainControl?: boolean[]; + backgroundBlur?: boolean[]; channelCount?: ULongRange; deviceId?: string; displaySurface?: string; @@ -935,6 +1028,7 @@ interface MediaTrackCapabilities { interface MediaTrackConstraintSet { aspectRatio?: ConstrainDouble; autoGainControl?: ConstrainBoolean; + backgroundBlur?: ConstrainBoolean; channelCount?: ConstrainULong; deviceId?: ConstrainDOMString; displaySurface?: ConstrainDOMString; @@ -956,6 +1050,7 @@ interface MediaTrackConstraints extends MediaTrackConstraintSet { interface MediaTrackSettings { aspectRatio?: number; autoGainControl?: boolean; + backgroundBlur?: boolean; channelCount?: number; deviceId?: string; displaySurface?: string; @@ -973,6 +1068,7 @@ interface MediaTrackSettings { interface MediaTrackSupportedConstraints { aspectRatio?: boolean; autoGainControl?: boolean; + backgroundBlur?: boolean; channelCount?: boolean; deviceId?: boolean; displaySurface?: boolean; @@ -1067,6 +1163,15 @@ interface OptionalEffectTiming { playbackRate?: number; } +interface OpusEncoderConfig { + complexity?: number; + format?: OpusBitstreamFormat; + frameDuration?: number; + packetlossperc?: number; + usedtx?: boolean; + useinbandfec?: boolean; +} + interface OscillatorOptions extends AudioNodeOptions { detune?: number; frequency?: number; @@ -1095,6 +1200,12 @@ interface PannerOptions extends AudioNodeOptions { rolloffFactor?: number; } +interface PayerErrors { + email?: string; + name?: string; + phone?: string; +} + interface PaymentCurrencyAmount { currency: string; value: string; @@ -1103,6 +1214,7 @@ interface PaymentCurrencyAmount { interface PaymentDetailsBase { displayItems?: PaymentItem[]; modifiers?: PaymentDetailsModifier[]; + shippingOptions?: PaymentShippingOption[]; } interface PaymentDetailsInit extends PaymentDetailsBase { @@ -1118,7 +1230,9 @@ interface PaymentDetailsModifier { } interface PaymentDetailsUpdate extends PaymentDetailsBase { + error?: string; paymentMethodErrors?: any; + shippingAddressErrors?: AddressErrors; total?: PaymentItem; } @@ -1138,12 +1252,28 @@ interface PaymentMethodData { supportedMethods: string; } +interface PaymentOptions { + requestPayerEmail?: boolean; + requestPayerName?: boolean; + requestPayerPhone?: boolean; + requestShipping?: boolean; + shippingType?: PaymentShippingType; +} + interface PaymentRequestUpdateEventInit extends EventInit { } +interface PaymentShippingOption { + amount: PaymentCurrencyAmount; + id: string; + label: string; + selected?: boolean; +} + interface PaymentValidationErrors { error?: string; - paymentMethod?: any; + payer?: PayerErrors; + shippingAddress?: AddressErrors; } interface Pbkdf2Params extends Algorithm { @@ -1193,6 +1323,8 @@ interface PlaneLayout { } interface PointerEventInit extends MouseEventInit { + altitudeAngle?: number; + azimuthAngle?: number; coalescedEvents?: PointerEvent[]; height?: number; isPrimary?: boolean; @@ -1258,12 +1390,31 @@ interface PublicKeyCredentialCreationOptions { user: PublicKeyCredentialUserEntity; } +interface PublicKeyCredentialCreationOptionsJSON { + attestation?: string; + authenticatorSelection?: AuthenticatorSelectionCriteria; + challenge: Base64URLString; + excludeCredentials?: PublicKeyCredentialDescriptorJSON[]; + extensions?: AuthenticationExtensionsClientInputsJSON; + hints?: string[]; + pubKeyCredParams: PublicKeyCredentialParameters[]; + rp: PublicKeyCredentialRpEntity; + timeout?: number; + user: PublicKeyCredentialUserEntityJSON; +} + interface PublicKeyCredentialDescriptor { id: BufferSource; transports?: AuthenticatorTransport[]; type: PublicKeyCredentialType; } +interface PublicKeyCredentialDescriptorJSON { + id: Base64URLString; + transports?: string[]; + type: string; +} + interface PublicKeyCredentialEntity { name: string; } @@ -1282,6 +1433,16 @@ interface PublicKeyCredentialRequestOptions { userVerification?: UserVerificationRequirement; } +interface PublicKeyCredentialRequestOptionsJSON { + allowCredentials?: PublicKeyCredentialDescriptorJSON[]; + challenge: Base64URLString; + extensions?: AuthenticationExtensionsClientInputsJSON; + hints?: string[]; + rpId?: string; + timeout?: number; + userVerification?: string; +} + interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity { id?: string; } @@ -1291,6 +1452,12 @@ interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity { id: BufferSource; } +interface PublicKeyCredentialUserEntityJSON { + displayName: string; + id: Base64URLString; + name: string; +} + interface PushSubscriptionJSON { endpoint?: string; expirationTime?: EpochTimeStamp | null; @@ -2013,6 +2180,7 @@ interface VideoConfiguration { colorGamut?: ColorGamut; contentType: string; framerate: number; + hasAlphaChannel?: boolean; hdrMetadataType?: HdrMetadataType; height: number; scalabilityMode?: string; @@ -2048,6 +2216,7 @@ interface VideoEncoderConfig { bitrate?: number; bitrateMode?: VideoEncoderBitrateMode; codec: string; + contentHint?: string; displayHeight?: number; displayWidth?: number; framerate?: number; @@ -2059,9 +2228,14 @@ interface VideoEncoderConfig { } interface VideoEncoderEncodeOptions { + avc?: VideoEncoderEncodeOptionsForAvc; keyFrame?: boolean; } +interface VideoEncoderEncodeOptionsForAvc { + quantizer?: number | null; +} + interface VideoEncoderInit { error: WebCodecsErrorCallback; output: EncodedVideoChunkOutputCallback; @@ -2099,6 +2273,8 @@ interface VideoFrameCallbackMetadata { } interface VideoFrameCopyToOptions { + colorSpace?: PredefinedColorSpace; + format?: VideoPixelFormat; layout?: PlaneLayout[]; rect?: DOMRectInit; } @@ -2242,6 +2418,8 @@ interface ARIAMixin { ariaColCount: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaColIndex) */ ariaColIndex: string | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaColIndexText) */ + ariaColIndexText: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaColSpan) */ ariaColSpan: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaCurrent) */ @@ -2289,6 +2467,8 @@ interface ARIAMixin { ariaRowCount: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaRowIndex) */ ariaRowIndex: string | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaRowIndexText) */ + ariaRowIndexText: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaRowSpan) */ ariaRowSpan: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/ariaSelected) */ @@ -2465,7 +2645,7 @@ interface Animatable { interface AnimationEventMap { "cancel": AnimationPlaybackEvent; "finish": AnimationPlaybackEvent; - "remove": Event; + "remove": AnimationPlaybackEvent; } /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation) */ @@ -2483,7 +2663,7 @@ interface Animation extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/finish_event) */ onfinish: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/remove_event) */ - onremove: ((this: Animation, ev: Event) => any) | null; + onremove: ((this: Animation, ev: AnimationPlaybackEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/pending) */ readonly pending: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Animation/playState) */ @@ -2715,6 +2895,74 @@ declare var AudioContext: { new(contextOptions?: AudioContextOptions): AudioContext; }; +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData) */ +interface AudioData { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/duration) */ + readonly duration: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/format) */ + readonly format: AudioSampleFormat | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfChannels) */ + readonly numberOfChannels: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfFrames) */ + readonly numberOfFrames: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/sampleRate) */ + readonly sampleRate: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/timestamp) */ + readonly timestamp: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/allocationSize) */ + allocationSize(options: AudioDataCopyToOptions): number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/clone) */ + clone(): AudioData; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/copyTo) */ + copyTo(destination: AllowSharedBufferSource, options: AudioDataCopyToOptions): void; +} + +declare var AudioData: { + prototype: AudioData; + new(init: AudioDataInit): AudioData; +}; + +interface AudioDecoderEventMap { + "dequeue": Event; +} + +/** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder) + */ +interface AudioDecoder extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decodeQueueSize) */ + readonly decodeQueueSize: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/dequeue_event) */ + ondequeue: ((this: AudioDecoder, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/state) */ + readonly state: CodecState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/configure) */ + configure(config: AudioDecoderConfig): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decode) */ + decode(chunk: EncodedAudioChunk): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/flush) */ + flush(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/reset) */ + reset(): void; + addEventListener(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioDecoder: { + prototype: AudioDecoder; + new(init: AudioDecoderInit): AudioDecoder; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/isConfigSupported_static) */ + isConfigSupported(config: AudioDecoderConfig): Promise; +}; + /** * AudioDestinationNode has no output (as it is the output, no more AudioNode can be linked after it in the audio graph) and one input. The number of channels in the input must be between 0 and the maxChannelCount value or an exception is raised. * @@ -2730,6 +2978,45 @@ declare var AudioDestinationNode: { new(): AudioDestinationNode; }; +interface AudioEncoderEventMap { + "dequeue": Event; +} + +/** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder) + */ +interface AudioEncoder extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encodeQueueSize) */ + readonly encodeQueueSize: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/dequeue_event) */ + ondequeue: ((this: AudioEncoder, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/state) */ + readonly state: CodecState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/configure) */ + configure(config: AudioEncoderConfig): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encode) */ + encode(data: AudioData): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/flush) */ + flush(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/reset) */ + reset(): void; + addEventListener(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioEncoder: { + prototype: AudioEncoder; + new(init: AudioEncoderInit): AudioEncoder; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/isConfigSupported_static) */ + isConfigSupported(config: AudioEncoderConfig): Promise; +}; + /** * The position and orientation of the unique person listening to the audio scene, and is used in audio spatialization. All PannerNodes spatialize in relation to the AudioListener stored in the BaseAudioContext.listener attribute. * @@ -2925,7 +3212,7 @@ declare var AudioWorklet: { }; interface AudioWorkletNodeEventMap { - "processorerror": Event; + "processorerror": ErrorEvent; } /** @@ -2935,7 +3222,7 @@ interface AudioWorkletNodeEventMap { */ interface AudioWorkletNode extends AudioNode { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioWorkletNode/processorerror_event) */ - onprocessorerror: ((this: AudioWorkletNode, ev: Event) => any) | null; + onprocessorerror: ((this: AudioWorkletNode, ev: ErrorEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioWorkletNode/parameters) */ readonly parameters: AudioParamMap; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioWorkletNode/port) */ @@ -3418,7 +3705,7 @@ interface CSSImportRule extends CSSRule { readonly layerName: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImportRule/media) */ readonly media: MediaList; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImportRule/stylesheet) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImportRule/styleSheet) */ readonly styleSheet: CSSStyleSheet | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSImportRule/supportsText) */ readonly supportsText: string | null; @@ -3454,6 +3741,7 @@ declare var CSSKeyframeRule: { interface CSSKeyframesRule extends CSSRule { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeyframesRule/cssRules) */ readonly cssRules: CSSRuleList; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeyframesRule/length) */ readonly length: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSKeyframesRule/name) */ name: string; @@ -3711,7 +3999,7 @@ declare var CSSPerspective: { interface CSSPropertyRule extends CSSRule { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPropertyRule/inherits) */ readonly inherits: boolean; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPropertyRule/initialvalue) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPropertyRule/initialValue) */ readonly initialValue: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CSSPropertyRule/name) */ readonly name: string; @@ -4102,11 +4390,13 @@ interface CSSStyleDeclaration { clip: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/clip-path) */ clipPath: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/clip-rule) */ clipRule: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/color) */ color: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/color-interpolation) */ colorInterpolation: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/color-interpolation-filters) */ colorInterpolationFilters: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/color-scheme) */ colorScheme: string; @@ -4132,9 +4422,11 @@ interface CSSStyleDeclaration { columns: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/contain) */ contain: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/contain-intrinsic-block-size) */ containIntrinsicBlockSize: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/contain-intrinsic-height) */ containIntrinsicHeight: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/contain-intrinsic-inline-size) */ containIntrinsicInlineSize: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/contain-intrinsic-size) */ containIntrinsicSize: string; @@ -4162,18 +4454,25 @@ interface CSSStyleDeclaration { cssText: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/cursor) */ cursor: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/cx) */ cx: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/cy) */ cy: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/d) */ d: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/direction) */ direction: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/display) */ display: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/dominant-baseline) */ dominantBaseline: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/empty-cells) */ emptyCells: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/fill) */ fill: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/fill-opacity) */ fillOpacity: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/fill-rule) */ fillRule: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/filter) */ filter: string; @@ -4360,9 +4659,13 @@ interface CSSStyleDeclaration { marginRight: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/margin-top) */ marginTop: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/marker) */ marker: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/marker-end) */ markerEnd: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/marker-mid) */ markerMid: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/marker-start) */ markerStart: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/mask) */ mask: string; @@ -4512,6 +4815,7 @@ interface CSSStyleDeclaration { printColorAdjust: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/quotes) */ quotes: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/r) */ r: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/resize) */ resize: string; @@ -4521,9 +4825,13 @@ interface CSSStyleDeclaration { rotate: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/row-gap) */ rowGap: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/ruby-align) */ + rubyAlign: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/ruby-position) */ rubyPosition: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/rx) */ rx: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/ry) */ ry: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/scale) */ scale: string; @@ -4591,16 +4899,27 @@ interface CSSStyleDeclaration { shapeMargin: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/shape-outside) */ shapeOutside: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/shape-rendering) */ shapeRendering: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stop-color) */ stopColor: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stop-opacity) */ stopOpacity: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke) */ stroke: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-dasharray) */ strokeDasharray: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-dashoffset) */ strokeDashoffset: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-linecap) */ strokeLinecap: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-linejoin) */ strokeLinejoin: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-miterlimit) */ strokeMiterlimit: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-opacity) */ strokeOpacity: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/stroke-width) */ strokeWidth: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/tab-size) */ tabSize: string; @@ -4610,6 +4929,7 @@ interface CSSStyleDeclaration { textAlign: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/text-align-last) */ textAlignLast: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/text-anchor) */ textAnchor: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/text-combine-upright) */ textCombineUpright: string; @@ -4685,6 +5005,7 @@ interface CSSStyleDeclaration { unicodeBidi: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/user-select) */ userSelect: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/vector-effect) */ vectorEffect: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/vertical-align) */ verticalAlign: string; @@ -5114,7 +5435,9 @@ interface CSSStyleDeclaration { wordWrap: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/writing-mode) */ writingMode: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/x) */ x: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/y) */ y: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/CSS/z-index) */ zIndex: string; @@ -5652,6 +5975,18 @@ interface CanvasUserInterface { drawFocusIfNeeded(path: Path2D, element: Element): void; } +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CaretPosition) */ +interface CaretPosition { + readonly offset: number; + readonly offsetNode: Node; + getClientRect(): DOMRect | null; +} + +declare var CaretPosition: { + prototype: CaretPosition; + new(): CaretPosition; +}; + /** * The ChannelMergerNode interface, often used in conjunction with its opposite, ChannelSplitterNode, reunites different mono inputs into a single output. Each input is used to fill a channel of the output. This is useful for accessing each channels separately, e.g. for performing channel mixing where gain must be separately controlled on each channel. * @@ -5867,6 +6202,8 @@ declare var CompositionEvent: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream) */ interface CompressionStream extends GenericTransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; } declare var CompressionStream: { @@ -6171,27 +6508,49 @@ declare var DOMImplementation: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix) */ interface DOMMatrix extends DOMMatrixReadOnly { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ a: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ b: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ c: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ d: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ e: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ f: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m11: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m12: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m13: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m14: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m21: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m22: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m23: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m24: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m31: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m32: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m33: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m34: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m41: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m42: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m43: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m44: number; invertSelf(): DOMMatrix; multiplySelf(other?: DOMMatrixInit): DOMMatrix; @@ -6223,29 +6582,51 @@ declare var WebKitCSSMatrix: typeof DOMMatrix; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly) */ interface DOMMatrixReadOnly { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly a: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly b: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly c: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly d: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly e: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly f: number; readonly is2D: boolean; readonly isIdentity: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m11: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m12: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m13: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m14: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m21: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m22: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m23: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m24: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m31: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m32: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m33: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m34: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m41: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m42: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m43: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m44: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipX) */ flipX(): DOMMatrix; @@ -6717,6 +7098,8 @@ declare var DataTransferItemList: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DecompressionStream) */ interface DecompressionStream extends GenericTransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; } declare var DecompressionStream: { @@ -6979,6 +7362,8 @@ interface Document extends Node, DocumentOrShadowRoot, FontFaceSource, GlobalEve * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/forms) */ readonly forms: HTMLCollectionOf; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/fragmentDirective) */ + readonly fragmentDirective: FragmentDirective; /** * @deprecated * @@ -7123,6 +7508,8 @@ interface Document extends Node, DocumentOrShadowRoot, FontFaceSource, GlobalEve adoptNode(node: T): T; /** @deprecated */ captureEvents(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/caretPositionFromPoint) */ + caretPositionFromPoint(x: number, y: number, options?: CaretPositionFromPointOptions): CaretPosition | null; /** @deprecated */ caretRangeFromPoint(x: number, y: number): Range | null; /** @@ -7233,8 +7620,6 @@ interface Document extends Node, DocumentOrShadowRoot, FontFaceSource, GlobalEve createEvent(eventInterface: "MessageEvent"): MessageEvent; createEvent(eventInterface: "MouseEvent"): MouseEvent; createEvent(eventInterface: "MouseEvents"): MouseEvent; - createEvent(eventInterface: "MutationEvent"): MutationEvent; - createEvent(eventInterface: "MutationEvents"): MutationEvent; createEvent(eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent; createEvent(eventInterface: "PageTransitionEvent"): PageTransitionEvent; createEvent(eventInterface: "PaymentMethodChangeEvent"): PaymentMethodChangeEvent; @@ -7441,7 +7826,7 @@ interface Document extends Node, DocumentOrShadowRoot, FontFaceSource, GlobalEve /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/requestStorageAccess) */ requestStorageAccess(): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/startViewTransition) */ - startViewTransition(callbackOptions?: UpdateCallback): ViewTransition; + startViewTransition(callbackOptions?: ViewTransitionUpdateCallback): ViewTransition; /** * Writes one or more HTML expressions to a document in the specified window. * @param content Specifies the text and HTML tags to write. @@ -7710,6 +8095,8 @@ interface Element extends Node, ARIAMixin, Animatable, ChildNode, NonDocumentTyp readonly clientTop: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/clientWidth) */ readonly clientWidth: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/currentCSSZoom) */ + readonly currentCSSZoom: number; /** * Returns the value of element's id content attribute. Can be set to change it. * @@ -8041,6 +8428,25 @@ declare var ElementInternals: { new(): ElementInternals; }; +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk) */ +interface EncodedAudioChunk { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/byteLength) */ + readonly byteLength: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/duration) */ + readonly duration: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/timestamp) */ + readonly timestamp: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/type) */ + readonly type: EncodedAudioChunkType; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/copyTo) */ + copyTo(destination: AllowSharedBufferSource): void; +} + +declare var EncodedAudioChunk: { + prototype: EncodedAudioChunk; + new(init: EncodedAudioChunkInit): EncodedAudioChunk; +}; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk) */ interface EncodedVideoChunk { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/byteLength) */ @@ -8636,23 +9042,23 @@ interface FontFace { declare var FontFace: { prototype: FontFace; - new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace; + new(family: string, source: string | BufferSource, descriptors?: FontFaceDescriptors): FontFace; }; interface FontFaceSetEventMap { - "loading": Event; - "loadingdone": Event; - "loadingerror": Event; + "loading": FontFaceSetLoadEvent; + "loadingdone": FontFaceSetLoadEvent; + "loadingerror": FontFaceSetLoadEvent; } /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet) */ interface FontFaceSet extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loading_event) */ - onloading: ((this: FontFaceSet, ev: Event) => any) | null; + onloading: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingdone_event) */ - onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null; + onloadingdone: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingerror_event) */ - onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null; + onloadingerror: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/ready) */ readonly ready: Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/status) */ @@ -8670,7 +9076,7 @@ interface FontFaceSet extends EventTarget { declare var FontFaceSet: { prototype: FontFaceSet; - new(initialFaces: FontFace[]): FontFaceSet; + new(): FontFaceSet; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent) */ @@ -8734,6 +9140,15 @@ declare var FormDataEvent: { new(type: string, eventInitDict: FormDataEventInit): FormDataEvent; }; +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FragmentDirective) */ +interface FragmentDirective { +} + +declare var FragmentDirective: { + prototype: FragmentDirective; + new(): FragmentDirective; +}; + /** * A change in volume. It is an AudioNode audio-processing module that causes a given gain to be applied to the input data before its propagation to the output. A GainNode always has exactly one input and one output, both with the same number of channels. * @@ -8798,7 +9213,7 @@ declare var GamepadButton: { }; /** - * This Gamepad API interface contains references to gamepads connected to the system, which is what the gamepad events globalThis.gamepadconnected and globalThis.gamepaddisconnected are fired in response to. + * This Gamepad API interface contains references to gamepads connected to the system, which is what the gamepad events Window.gamepadconnected and Window.gamepaddisconnected are fired in response to. * * [MDN Reference](https://developer.mozilla.org/docs/Web/API/GamepadEvent) */ @@ -8820,6 +9235,7 @@ declare var GamepadEvent: { interface GamepadHapticActuator { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GamepadHapticActuator/playEffect) */ playEffect(type: GamepadHapticEffectType, params?: GamepadEffectParameters): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/GamepadHapticActuator/reset) */ reset(): Promise; } @@ -9668,7 +10084,11 @@ declare var HTMLBRElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLBaseElement) */ interface HTMLBaseElement extends HTMLElement { - /** Gets or sets the baseline URL on which relative links are based. */ + /** + * Gets or sets the baseline URL on which relative links are based. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLBaseElement/href) + */ href: string; /** * Sets or retrieves the window or frame at which to target content. @@ -9727,7 +10147,11 @@ declare var HTMLBodyElement: { interface HTMLButtonElement extends HTMLElement, PopoverInvokerElement { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/disabled) */ disabled: boolean; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/form) + */ readonly form: HTMLFormElement | null; /** Overrides the action attribute (where the data on a form is sent) on the parent form element. */ formAction: string; @@ -9741,7 +10165,11 @@ interface HTMLButtonElement extends HTMLElement, PopoverInvokerElement { formTarget: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/labels) */ readonly labels: NodeListOf; - /** Sets or retrieves the name of the object. */ + /** + * Sets or retrieves the name of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/name) + */ name: string; /** * Gets the classification and default behavior of the button. @@ -9749,20 +10177,43 @@ interface HTMLButtonElement extends HTMLElement, PopoverInvokerElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/type) */ type: "submit" | "reset" | "button"; - /** Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. */ + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/validationMessage) + */ readonly validationMessage: string; - /** Returns a ValidityState object that represents the validity states of an element. */ + /** + * Returns a ValidityState object that represents the validity states of an element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/validity) + */ readonly validity: ValidityState; - /** Sets or retrieves the default or selected value of the control. */ + /** + * Sets or retrieves the default or selected value of the control. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/value) + */ value: string; - /** Returns whether an element will successfully validate based on forms validation rules and constraints. */ + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/willValidate) + */ readonly willValidate: boolean; - /** Returns whether a form will validate when it is submitted, without having to submit it. */ + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/checkValidity) + */ checkValidity(): boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/reportValidity) */ reportValidity(): boolean; /** * Sets a custom error message that is displayed when a form is submitted. * @param error Sets a custom error message that is displayed when a form is submitted. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLButtonElement/setCustomValidity) */ setCustomValidity(error: string): void; addEventListener(type: K, listener: (this: HTMLButtonElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; @@ -9914,7 +10365,11 @@ declare var HTMLDataElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDataListElement) */ interface HTMLDataListElement extends HTMLElement { - /** Returns an HTMLCollection of the option elements of the datalist element. */ + /** + * Returns an HTMLCollection of the option elements of the datalist element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDataListElement/options) + */ readonly options: HTMLCollectionOf; addEventListener(type: K, listener: (this: HTMLDataListElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -9929,6 +10384,7 @@ declare var HTMLDataListElement: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDetailsElement) */ interface HTMLDetailsElement extends HTMLElement { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDetailsElement/open) */ name: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLDetailsElement/open) */ open: boolean; @@ -10075,6 +10531,7 @@ interface HTMLElement extends Element, ElementCSSInlineStyle, ElementContentEdit title: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/translate) */ translate: boolean; + writingSuggestions: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/attachInternals) */ attachInternals(): ElementInternals; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLElement/click) */ @@ -10146,26 +10603,59 @@ declare var HTMLEmbedElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement) */ interface HTMLFieldSetElement extends HTMLElement { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/disabled) */ disabled: boolean; - /** Returns an HTMLCollection of the form controls in the element. */ + /** + * Returns an HTMLCollection of the form controls in the element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/elements) + */ readonly elements: HTMLCollection; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/form) + */ readonly form: HTMLFormElement | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/name) */ name: string; - /** Returns the string "fieldset". */ + /** + * Returns the string "fieldset". + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/type) + */ readonly type: string; - /** Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. */ + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/validationMessage) + */ readonly validationMessage: string; - /** Returns a ValidityState object that represents the validity states of an element. */ + /** + * Returns a ValidityState object that represents the validity states of an element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/validity) + */ readonly validity: ValidityState; - /** Returns whether an element will successfully validate based on forms validation rules and constraints. */ + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/willValidate) + */ readonly willValidate: boolean; - /** Returns whether a form will validate when it is submitted, without having to submit it. */ + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/checkValidity) + */ checkValidity(): boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/reportValidity) */ reportValidity(): boolean; /** * Sets a custom error message that is displayed when a form is submitted. * @param error Sets a custom error message that is displayed when a form is submitted. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFieldSetElement/setCustomValidity) */ setCustomValidity(error: string): void; addEventListener(type: K, listener: (this: HTMLFieldSetElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; @@ -10304,7 +10794,11 @@ interface HTMLFormElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/target) */ target: string; - /** Returns whether a form will validate when it is submitted, without having to submit it. */ + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/checkValidity) + */ checkValidity(): boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLFormElement/reportValidity) */ reportValidity(): boolean; @@ -10867,23 +11361,48 @@ declare var HTMLImageElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement) */ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { - /** Sets or retrieves a comma-separated list of content types. */ + /** + * Sets or retrieves a comma-separated list of content types. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/accept) + */ accept: string; /** * Sets or retrieves how the object is aligned with adjacent text. * @deprecated */ align: string; - /** Sets or retrieves a text alternative to the graphic. */ + /** + * Sets or retrieves a text alternative to the graphic. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/alt) + */ alt: string; - /** Specifies whether autocomplete is applied to an editable text field. */ + /** + * Specifies whether autocomplete is applied to an editable text field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/autocomplete) + */ autocomplete: AutoFill; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/capture) */ capture: string; - /** Sets or retrieves the state of the check box or radio button. */ + /** + * Sets or retrieves the state of the check box or radio button. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/checked) + */ checked: boolean; - /** Sets or retrieves the state of the check box or radio button. */ + /** + * Sets or retrieves the state of the check box or radio button. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/defaultChecked) + */ defaultChecked: boolean; - /** Sets or retrieves the initial contents of the object. */ + /** + * Sets or retrieves the initial contents of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/defaultValue) + */ defaultValue: string; dirName: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/disabled) */ @@ -10894,7 +11413,11 @@ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/files) */ files: FileList | null; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/form) + */ readonly form: HTMLFormElement | null; /** Overrides the action attribute (where the data on a form is sent) on the parent form element. */ formAction: string; @@ -10906,20 +11429,45 @@ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { formNoValidate: boolean; /** Overrides the target attribute on a form element. */ formTarget: string; - /** Sets or retrieves the height of the object. */ + /** + * Sets or retrieves the height of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/height) + */ height: number; - /** When set, overrides the rendering of checkbox controls so that the current value is not visible. */ + /** + * When set, overrides the rendering of checkbox controls so that the current value is not visible. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/indeterminate) + */ indeterminate: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/labels) */ readonly labels: NodeListOf | null; - /** Specifies the ID of a pre-defined datalist of options for an input element. */ + /** + * Specifies the ID of a pre-defined datalist of options for an input element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/list) + */ readonly list: HTMLDataListElement | null; - /** Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field. */ + /** + * Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/max) + */ max: string; - /** Sets or retrieves the maximum number of characters that the user can enter in a text control. */ + /** + * Sets or retrieves the maximum number of characters that the user can enter in a text control. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/maxLength) + */ maxLength: number; - /** Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field. */ + /** + * Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/min) + */ min: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/minLength) */ minLength: number; /** * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. @@ -10927,14 +11475,31 @@ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/multiple) */ multiple: boolean; - /** Sets or retrieves the name of the object. */ + /** + * Sets or retrieves the name of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/name) + */ name: string; - /** Gets or sets a string containing a regular expression that the user's input must match. */ + /** + * Gets or sets a string containing a regular expression that the user's input must match. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/pattern) + */ pattern: string; - /** Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. */ + /** + * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/placeholder) + */ placeholder: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/readOnly) */ readOnly: boolean; - /** When present, marks an element that can't be submitted without a value. */ + /** + * When present, marks an element that can't be submitted without a value. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/required) + */ required: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/selectionDirection) */ selectionDirection: "forward" | "backward" | "none" | null; @@ -10950,10 +11515,19 @@ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/selectionStart) */ selectionStart: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/size) */ size: number; - /** The address or URL of the a media resource that is to be considered. */ + /** + * The address or URL of the a media resource that is to be considered. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/src) + */ src: string; - /** Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field. */ + /** + * Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/step) + */ step: string; /** * Returns the content type of the object. @@ -10966,23 +11540,51 @@ interface HTMLInputElement extends HTMLElement, PopoverInvokerElement { * @deprecated */ useMap: string; - /** Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. */ + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/validationMessage) + */ readonly validationMessage: string; - /** Returns a ValidityState object that represents the validity states of an element. */ + /** + * Returns a ValidityState object that represents the validity states of an element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/validity) + */ readonly validity: ValidityState; - /** Returns the value of the data at the cursor's current position. */ + /** + * Returns the value of the data at the cursor's current position. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/value) + */ value: string; - /** Returns a Date object representing the form control's value, if applicable; otherwise, returns null. Can be set, to change the value. Throws an "InvalidStateError" DOMException if the control isn't date- or time-based. */ + /** + * Returns a Date object representing the form control's value, if applicable; otherwise, returns null. Can be set, to change the value. Throws an "InvalidStateError" DOMException if the control isn't date- or time-based. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/valueAsDate) + */ valueAsDate: Date | null; - /** Returns the input field value as a number. */ + /** + * Returns the input field value as a number. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/valueAsNumber) + */ valueAsNumber: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/webkitEntries) */ readonly webkitEntries: ReadonlyArray; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/webkitdirectory) */ webkitdirectory: boolean; - /** Sets or retrieves the width of the object. */ + /** + * Sets or retrieves the width of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/width) + */ width: number; - /** Returns whether an element will successfully validate based on forms validation rules and constraints. */ + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement/willValidate) + */ readonly willValidate: boolean; /** * Returns whether a form will validate when it is submitted, without having to submit it. @@ -11108,7 +11710,11 @@ declare var HTMLLabelElement: { interface HTMLLegendElement extends HTMLElement { /** @deprecated */ align: string; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLegendElement/form) + */ readonly form: HTMLFormElement | null; addEventListener(type: K, listener: (this: HTMLLegendElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -11140,7 +11746,11 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle { disabled: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement/fetchPriority) */ fetchPriority: string; - /** Sets or retrieves a destination URL or an anchor point. */ + /** + * Sets or retrieves a destination URL or an anchor point. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement/href) + */ href: string; /** * Sets or retrieves the language code of the object. @@ -11152,7 +11762,11 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle { imageSrcset: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement/integrity) */ integrity: string; - /** Sets or retrieves the media type. */ + /** + * Sets or retrieves the media type. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement/media) + */ media: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement/referrerPolicy) */ referrerPolicy: string; @@ -11198,7 +11812,11 @@ declare var HTMLLinkElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMapElement) */ interface HTMLMapElement extends HTMLElement { - /** Retrieves a collection of the area objects defined for the given map object. */ + /** + * Retrieves a collection of the area objects defined for the given map object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMapElement/areas) + */ readonly areas: HTMLCollection; /** * Sets or retrieves the name of the object. @@ -11549,13 +12167,19 @@ declare var HTMLMetaElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement) */ interface HTMLMeterElement extends HTMLElement { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/high) */ high: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/labels) */ readonly labels: NodeListOf; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/low) */ low: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/max) */ max: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/min) */ min: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/optimum) */ optimum: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMeterElement/value) */ value: number; addEventListener(type: K, listener: (this: HTMLMeterElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -11735,6 +12359,7 @@ interface HTMLObjectElement extends HTMLElement { */ checkValidity(): boolean; getSVGDocument(): Document | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLObjectElement/reportValidity) */ reportValidity(): boolean; /** * Sets a custom error message that is displayed when a form is submitted. @@ -11760,8 +12385,13 @@ declare var HTMLObjectElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptGroupElement) */ interface HTMLOptGroupElement extends HTMLElement { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptGroupElement/disabled) */ disabled: boolean; - /** Sets or retrieves a value that you can use to implement your own label functionality for the object. */ + /** + * Sets or retrieves a value that you can use to implement your own label functionality for the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptGroupElement/label) + */ label: string; addEventListener(type: K, listener: (this: HTMLOptGroupElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -11780,20 +12410,49 @@ declare var HTMLOptGroupElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement) */ interface HTMLOptionElement extends HTMLElement { - /** Sets or retrieves the status of an option. */ + /** + * Sets or retrieves the status of an option. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/defaultSelected) + */ defaultSelected: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/disabled) */ disabled: boolean; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/form) + */ readonly form: HTMLFormElement | null; - /** Sets or retrieves the ordinal position of an option in a list box. */ + /** + * Sets or retrieves the ordinal position of an option in a list box. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/index) + */ readonly index: number; - /** Sets or retrieves a value that you can use to implement your own label functionality for the object. */ + /** + * Sets or retrieves a value that you can use to implement your own label functionality for the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/label) + */ label: string; - /** Sets or retrieves whether the option in the list box is the default item. */ + /** + * Sets or retrieves whether the option in the list box is the default item. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/selected) + */ selected: boolean; - /** Sets or retrieves the text string specified by the option tag. */ + /** + * Sets or retrieves the text string specified by the option tag. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/text) + */ text: string; - /** Sets or retrieves the value which is returned to the server when the form control is submitted. */ + /** + * Sets or retrieves the value which is returned to the server when the form control is submitted. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOptionElement/value) + */ value: string; addEventListener(type: K, listener: (this: HTMLOptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -11867,24 +12526,38 @@ interface HTMLOrSVGElement { */ interface HTMLOutputElement extends HTMLElement { defaultValue: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/form) */ readonly form: HTMLFormElement | null; readonly htmlFor: DOMTokenList; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/labels) */ readonly labels: NodeListOf; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/name) */ name: string; - /** Returns the string "output". */ + /** + * Returns the string "output". + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/type) + */ readonly type: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/validationMessage) */ readonly validationMessage: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/validity) */ readonly validity: ValidityState; /** * Returns the element's current value. * * Can be set, to change the value. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/value) */ value: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/willValidate) */ readonly willValidate: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/checkValidity) */ checkValidity(): boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/reportValidity) */ reportValidity(): boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOutputElement/setCustomValidity) */ setCustomValidity(error: string): void; addEventListener(type: K, listener: (this: HTMLOutputElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; @@ -12140,11 +12813,23 @@ interface HTMLSelectElement extends HTMLElement { readonly form: HTMLFormElement | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/labels) */ readonly labels: NodeListOf; - /** Sets or retrieves the number of objects in a collection. */ + /** + * Sets or retrieves the number of objects in a collection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/length) + */ length: number; - /** Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. */ + /** + * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/multiple) + */ multiple: boolean; - /** Sets or retrieves the name of the object. */ + /** + * Sets or retrieves the name of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/name) + */ name: string; /** * Returns an HTMLOptionsCollection of the list of options. @@ -12152,7 +12837,11 @@ interface HTMLSelectElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/options) */ readonly options: HTMLOptionsCollection; - /** When present, marks an element that can't be submitted without a value. */ + /** + * When present, marks an element that can't be submitted without a value. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/required) + */ required: boolean; /** * Sets or retrieves the index of the selected option in a select object. @@ -12162,7 +12851,11 @@ interface HTMLSelectElement extends HTMLElement { selectedIndex: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/selectedOptions) */ readonly selectedOptions: HTMLCollectionOf; - /** Sets or retrieves the number of rows in the list box. */ + /** + * Sets or retrieves the number of rows in the list box. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/size) + */ size: number; /** * Retrieves the type of select control based on the value of the MULTIPLE attribute. @@ -12170,9 +12863,17 @@ interface HTMLSelectElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/type) */ readonly type: "select-one" | "select-multiple"; - /** Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. */ + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/validationMessage) + */ readonly validationMessage: string; - /** Returns a ValidityState object that represents the validity states of an element. */ + /** + * Returns a ValidityState object that represents the validity states of an element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/validity) + */ readonly validity: ValidityState; /** * Sets or retrieves the value which is returned to the server when the form control is submitted. @@ -12180,7 +12881,11 @@ interface HTMLSelectElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/value) */ value: string; - /** Returns whether an element will successfully validate based on forms validation rules and constraints. */ + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/willValidate) + */ readonly willValidate: boolean; /** * Adds an element to the areas, controlRange, or options collection. @@ -12219,6 +12924,7 @@ interface HTMLSelectElement extends HTMLElement { */ remove(): void; remove(index: number): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSelectElement/reportValidity) */ reportValidity(): boolean; /** * Sets a custom error message that is displayed when a form is submitted. @@ -12353,6 +13059,8 @@ interface HTMLTableCaptionElement extends HTMLElement { /** * Sets or retrieves the alignment of the caption or legend. * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableCaptionElement/align) */ align: string; addEventListener(type: K, listener: (this: HTMLTableCaptionElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; @@ -12715,6 +13423,8 @@ interface HTMLTableRowElement extends HTMLElement { /** * Sets or retrieves how the object is aligned with adjacent text. * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableRowElement/align) */ align: string; /** @@ -12753,7 +13463,11 @@ interface HTMLTableRowElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableRowElement/sectionRowIndex) */ readonly sectionRowIndex: number; - /** @deprecated */ + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableRowElement/vAlign) + */ vAlign: string; /** * Removes the specified cell from the table row, as well as from the cells collection. @@ -12789,6 +13503,8 @@ interface HTMLTableSectionElement extends HTMLElement { /** * Sets or retrieves a value that indicates the table alignment. * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement/align) */ align: string; /** @@ -12809,7 +13525,11 @@ interface HTMLTableSectionElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement/rows) */ readonly rows: HTMLCollectionOf; - /** @deprecated */ + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement/vAlign) + */ vAlign: string; /** * Removes the specified row (tr) from the element and from the rows collection. @@ -12873,35 +13593,84 @@ declare var HTMLTemplateElement: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement) */ interface HTMLTextAreaElement extends HTMLElement { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/autocomplete) */ autocomplete: AutoFill; - /** Sets or retrieves the width of the object. */ + /** + * Sets or retrieves the width of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/cols) + */ cols: number; - /** Sets or retrieves the initial contents of the object. */ + /** + * Sets or retrieves the initial contents of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/defaultValue) + */ defaultValue: string; dirName: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/disabled) */ disabled: boolean; - /** Retrieves a reference to the form that the object is embedded in. */ + /** + * Retrieves a reference to the form that the object is embedded in. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/form) + */ readonly form: HTMLFormElement | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/labels) */ readonly labels: NodeListOf; - /** Sets or retrieves the maximum number of characters that the user can enter in a text control. */ + /** + * Sets or retrieves the maximum number of characters that the user can enter in a text control. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/maxLength) + */ maxLength: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/minLength) */ minLength: number; - /** Sets or retrieves the name of the object. */ + /** + * Sets or retrieves the name of the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/name) + */ name: string; - /** Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. */ + /** + * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/placeholder) + */ placeholder: string; - /** Sets or retrieves the value indicated whether the content of the object is read-only. */ + /** + * Sets or retrieves the value indicated whether the content of the object is read-only. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/readOnly) + */ readOnly: boolean; - /** When present, marks an element that can't be submitted without a value. */ + /** + * When present, marks an element that can't be submitted without a value. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/required) + */ required: boolean; - /** Sets or retrieves the number of horizontal rows contained in the object. */ + /** + * Sets or retrieves the number of horizontal rows contained in the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/rows) + */ rows: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/selectionDirection) */ selectionDirection: "forward" | "backward" | "none"; - /** Gets or sets the end position or offset of a text selection. */ + /** + * Gets or sets the end position or offset of a text selection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/selectionEnd) + */ selectionEnd: number; - /** Gets or sets the starting position or offset of a text selection. */ + /** + * Gets or sets the starting position or offset of a text selection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/selectionStart) + */ selectionStart: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/textLength) */ readonly textLength: number; /** * Retrieves the type of control. @@ -12909,26 +13678,58 @@ interface HTMLTextAreaElement extends HTMLElement { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/type) */ readonly type: string; - /** Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. */ + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/validationMessage) + */ readonly validationMessage: string; - /** Returns a ValidityState object that represents the validity states of an element. */ + /** + * Returns a ValidityState object that represents the validity states of an element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/validity) + */ readonly validity: ValidityState; - /** Retrieves or sets the text in the entry field of the textArea element. */ + /** + * Retrieves or sets the text in the entry field of the textArea element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/value) + */ value: string; - /** Returns whether an element will successfully validate based on forms validation rules and constraints. */ + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/willValidate) + */ readonly willValidate: boolean; - /** Sets or retrieves how to handle wordwrapping in the object. */ + /** + * Sets or retrieves how to handle wordwrapping in the object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/wrap) + */ wrap: string; - /** Returns whether a form will validate when it is submitted, without having to submit it. */ + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/checkValidity) + */ checkValidity(): boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/reportValidity) */ reportValidity(): boolean; - /** Highlights the input area of a form element. */ + /** + * Highlights the input area of a form element. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/select) + */ select(): void; /** * Sets a custom error message that is displayed when a form is submitted. * @param error Sets a custom error message that is displayed when a form is submitted. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/setCustomValidity) */ setCustomValidity(error: string): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/setRangeText) */ setRangeText(replacement: string): void; setRangeText(replacement: string, start: number, end: number, selectionMode?: SelectionMode): void; /** @@ -12936,6 +13737,8 @@ interface HTMLTextAreaElement extends HTMLElement { * @param start The offset into the text field for the start of the selection. * @param end The offset into the text field for the end of the selection. * @param direction The direction in which the selection is performed. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTextAreaElement/setSelectionRange) */ setSelectionRange(start: number | null, end: number | null, direction?: "forward" | "backward" | "none"): void; addEventListener(type: K, listener: (this: HTMLTextAreaElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; @@ -13064,8 +13867,8 @@ declare var HTMLUnknownElement: { }; interface HTMLVideoElementEventMap extends HTMLMediaElementEventMap { - "enterpictureinpicture": Event; - "leavepictureinpicture": Event; + "enterpictureinpicture": PictureInPictureEvent; + "leavepictureinpicture": PictureInPictureEvent; } /** @@ -13083,9 +13886,9 @@ interface HTMLVideoElement extends HTMLMediaElement { */ height: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLVideoElement/enterpictureinpicture_event) */ - onenterpictureinpicture: ((this: HTMLVideoElement, ev: Event) => any) | null; + onenterpictureinpicture: ((this: HTMLVideoElement, ev: PictureInPictureEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLVideoElement/leavepictureinpicture_event) */ - onleavepictureinpicture: ((this: HTMLVideoElement, ev: Event) => any) | null; + onleavepictureinpicture: ((this: HTMLVideoElement, ev: PictureInPictureEvent) => any) | null; /** Gets or sets the playsinline of the video element. for example, On iPhone, video elements will now be allowed to play inline, and will not automatically enter fullscreen mode when playback begins. */ playsInline: boolean; /** @@ -13864,7 +14667,7 @@ interface IDBTransaction extends EventTarget { /** * Returns a list of the names of object stores in the transaction's scope. For an upgrade transaction this is all object stores in the database. * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/ObjectStoreNames) + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/objectStoreNames) */ readonly objectStoreNames: DOMStringList; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/abort_event) */ @@ -13972,7 +14775,11 @@ declare var ImageBitmap: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmapRenderingContext) */ interface ImageBitmapRenderingContext { - /** Returns the canvas element that the context is bound to. */ + /** + * Returns the canvas element that the context is bound to. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ImageBitmapRenderingContext/canvas) + */ readonly canvas: HTMLCanvasElement | OffscreenCanvas; /** * Transfers the underlying bitmap data from imageBitmap to context, and the bitmap becomes the contents of the canvas element to which context is bound. @@ -14111,7 +14918,7 @@ interface IntersectionObserverEntry { declare var IntersectionObserverEntry: { prototype: IntersectionObserverEntry; - new(intersectionObserverEntryInit: IntersectionObserverEntryInit): IntersectionObserverEntry; + new(): IntersectionObserverEntry; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KHR_parallel_shader_compile) */ @@ -14372,7 +15179,7 @@ declare var LockManager: { }; interface MIDIAccessEventMap { - "statechange": Event; + "statechange": MIDIConnectionEvent; } /** @@ -14384,7 +15191,7 @@ interface MIDIAccess extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/inputs) */ readonly inputs: MIDIInputMap; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/statechange_event) */ - onstatechange: ((this: MIDIAccess, ev: Event) => any) | null; + onstatechange: ((this: MIDIAccess, ev: MIDIConnectionEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/outputs) */ readonly outputs: MIDIOutputMap; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MIDIAccess/sysexEnabled) */ @@ -14792,6 +15599,7 @@ declare var MediaKeySystemAccess: { interface MediaKeys { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaKeys/createSession) */ createSession(sessionType?: MediaKeySessionType): MediaKeySession; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaKeys/getStatusForPolicy) */ getStatusForPolicy(policy?: MediaKeysPolicy): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaKeys/setServerCertificate) */ setServerCertificate(serverCertificate: BufferSource): Promise; @@ -14894,7 +15702,7 @@ declare var MediaQueryListEvent: { interface MediaRecorderEventMap { "dataavailable": BlobEvent; - "error": Event; + "error": ErrorEvent; "pause": Event; "resume": Event; "start": Event; @@ -14910,7 +15718,7 @@ interface MediaRecorder extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaRecorder/dataavailable_event) */ ondataavailable: ((this: MediaRecorder, ev: BlobEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaRecorder/error_event) */ - onerror: ((this: MediaRecorder, ev: Event) => any) | null; + onerror: ((this: MediaRecorder, ev: ErrorEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaRecorder/pause_event) */ onpause: ((this: MediaRecorder, ev: Event) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaRecorder/resume_event) */ @@ -15401,63 +16209,6 @@ declare var MouseEvent: { new(type: string, eventInitDict?: MouseEventInit): MouseEvent; }; -/** - * Provides event properties that are specific to modifications to the Document Object Model (DOM) hierarchy and nodes. - * @deprecated DOM4 [DOM] provides a new mechanism using a MutationObserver interface which addresses the use cases that mutation events solve, but in a more performant manner. Thus, this specification describes mutation events for reference and completeness of legacy behavior, but deprecates the use of the MutationEvent interface. - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent) - */ -interface MutationEvent extends Event { - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/attrChange) - */ - readonly attrChange: number; - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/attrName) - */ - readonly attrName: string; - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/newValue) - */ - readonly newValue: string; - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/prevValue) - */ - readonly prevValue: string; - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/relatedNode) - */ - readonly relatedNode: Node | null; - /** - * @deprecated - * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MutationEvent/initMutationEvent) - */ - initMutationEvent(typeArg: string, bubblesArg?: boolean, cancelableArg?: boolean, relatedNodeArg?: Node | null, prevValueArg?: string, newValueArg?: string, attrNameArg?: string, attrChangeArg?: number): void; - readonly MODIFICATION: 1; - readonly ADDITION: 2; - readonly REMOVAL: 3; -} - -/** @deprecated */ -declare var MutationEvent: { - prototype: MutationEvent; - new(): MutationEvent; - readonly MODIFICATION: 1; - readonly ADDITION: 2; - readonly REMOVAL: 3; -}; - /** * Provides the ability to watch for changes being made to the DOM tree. It is designed as a replacement for the older Mutation Events feature which was part of the DOM3 Events specification. * @@ -16267,7 +17018,7 @@ interface OES_vertex_array_object { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/bindVertexArrayOES) */ bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/createVertexArrayOES) */ - createVertexArrayOES(): WebGLVertexArrayObjectOES | null; + createVertexArrayOES(): WebGLVertexArrayObjectOES; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/deleteVertexArrayOES) */ deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/isVertexArrayOES) */ @@ -16400,6 +17151,7 @@ declare var OffscreenCanvas: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvasRenderingContext2D) */ interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/canvas) */ readonly canvas: OffscreenCanvas; } @@ -16613,6 +17365,37 @@ declare var Path2D: { new(path?: Path2D | string): Path2D; }; +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress) */ +interface PaymentAddress { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/addressLine) */ + readonly addressLine: ReadonlyArray; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/city) */ + readonly city: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/country) */ + readonly country: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/dependentLocality) */ + readonly dependentLocality: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/organization) */ + readonly organization: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/phone) */ + readonly phone: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/postalCode) */ + readonly postalCode: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/recipient) */ + readonly recipient: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/region) */ + readonly region: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/sortingCode) */ + readonly sortingCode: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ContactAddress/toJSON) */ + toJSON(): any; +} + +declare var PaymentAddress: { + prototype: PaymentAddress; + new(): PaymentAddress; +}; + /** * Available only in secure contexts. * @@ -16631,7 +17414,9 @@ declare var PaymentMethodChangeEvent: { }; interface PaymentRequestEventMap { - "paymentmethodchange": Event; + "paymentmethodchange": PaymentMethodChangeEvent; + "shippingaddresschange": PaymentRequestUpdateEvent; + "shippingoptionchange": PaymentRequestUpdateEvent; } /** @@ -16644,7 +17429,37 @@ interface PaymentRequest extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/id) */ readonly id: string; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/paymentmethodchange_event) */ - onpaymentmethodchange: ((this: PaymentRequest, ev: Event) => any) | null; + onpaymentmethodchange: ((this: PaymentRequest, ev: PaymentMethodChangeEvent) => any) | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/shippingaddresschange_event) + */ + onshippingaddresschange: ((this: PaymentRequest, ev: PaymentRequestUpdateEvent) => any) | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/shippingoptionchange_event) + */ + onshippingoptionchange: ((this: PaymentRequest, ev: PaymentRequestUpdateEvent) => any) | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/shippingAddress) + */ + readonly shippingAddress: PaymentAddress | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/shippingOption) + */ + readonly shippingOption: string | null; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/shippingType) + */ + readonly shippingType: PaymentShippingType | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/abort) */ abort(): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentRequest/canMakePayment) */ @@ -16659,7 +17474,7 @@ interface PaymentRequest extends EventTarget { declare var PaymentRequest: { prototype: PaymentRequest; - new(methodData: PaymentMethodData[], details: PaymentDetailsInit): PaymentRequest; + new(methodData: PaymentMethodData[], details: PaymentDetailsInit, options?: PaymentOptions): PaymentRequest; }; /** @@ -16678,6 +17493,10 @@ declare var PaymentRequestUpdateEvent: { new(type: string, eventInitDict?: PaymentRequestUpdateEventInit): PaymentRequestUpdateEvent; }; +interface PaymentResponseEventMap { + "payerdetailchange": PaymentRequestUpdateEvent; +} + /** * This Payment Request API interface is returned after a user selects a payment method and approves a payment request. * Available only in secure contexts. @@ -16689,14 +17508,30 @@ interface PaymentResponse extends EventTarget { readonly details: any; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/methodName) */ readonly methodName: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/payerdetailchange_event) */ + onpayerdetailchange: ((this: PaymentResponse, ev: PaymentRequestUpdateEvent) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/payerEmail) */ + readonly payerEmail: string | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/payerName) */ + readonly payerName: string | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/payerPhone) */ + readonly payerPhone: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/requestId) */ readonly requestId: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/shippingAddress) */ + readonly shippingAddress: PaymentAddress | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/shippingOption) */ + readonly shippingOption: string | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/complete) */ complete(result?: PaymentComplete): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/retry) */ retry(errorFields?: PaymentValidationErrors): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PaymentResponse/toJSON) */ toJSON(): any; + addEventListener(type: K, listener: (this: PaymentResponse, ev: PaymentResponseEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: PaymentResponse, ev: PaymentResponseEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; } declare var PaymentResponse: { @@ -16988,6 +17823,8 @@ interface PerformanceResourceTiming extends PerformanceEntry { readonly responseEnd: DOMHighResTimeStamp; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStart) */ readonly responseStart: DOMHighResTimeStamp; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStatus) */ + readonly responseStatus: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/secureConnectionStart) */ readonly secureConnectionStart: DOMHighResTimeStamp; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/serverTiming) */ @@ -17323,6 +18160,10 @@ declare var PluginArray: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/PointerEvent) */ interface PointerEvent extends MouseEvent { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PointerEvent/altitudeAngle) */ + readonly altitudeAngle: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PointerEvent/azimuthAngle) */ + readonly azimuthAngle: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PointerEvent/height) */ readonly height: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PointerEvent/isPrimary) */ @@ -17448,15 +18289,21 @@ interface PublicKeyCredential extends Credential { readonly response: AuthenticatorResponse; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/getClientExtensionResults) */ getClientExtensionResults(): AuthenticationExtensionsClientOutputs; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/toJSON) */ + toJSON(): PublicKeyCredentialJSON; } declare var PublicKeyCredential: { prototype: PublicKeyCredential; new(): PublicKeyCredential; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/isConditionalMediationAvailable) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/isConditionalMediationAvailable_static) */ isConditionalMediationAvailable(): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/isUserVerifyingPlatformAuthenticatorAvailable_static) */ isUserVerifyingPlatformAuthenticatorAvailable(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/parseCreationOptionsFromJSON_static) */ + parseCreationOptionsFromJSON(options: PublicKeyCredentialCreationOptionsJSON): PublicKeyCredentialCreationOptions; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/parseRequestOptionsFromJSON_static) */ + parseRequestOptionsFromJSON(options: PublicKeyCredentialRequestOptionsJSON): PublicKeyCredentialRequestOptions; }; /** @@ -17581,7 +18428,7 @@ interface RTCDataChannelEventMap { "bufferedamountlow": Event; "close": Event; "closing": Event; - "error": Event; + "error": RTCErrorEvent; "message": MessageEvent; "open": Event; } @@ -17611,7 +18458,7 @@ interface RTCDataChannel extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/closing_event) */ onclosing: ((this: RTCDataChannel, ev: Event) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/error_event) */ - onerror: ((this: RTCDataChannel, ev: Event) => any) | null; + onerror: ((this: RTCDataChannel, ev: RTCErrorEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/message_event) */ onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDataChannel/open_event) */ @@ -17652,7 +18499,7 @@ declare var RTCDataChannelEvent: { }; interface RTCDtlsTransportEventMap { - "error": Event; + "error": RTCErrorEvent; "statechange": Event; } @@ -17661,7 +18508,7 @@ interface RTCDtlsTransport extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDtlsTransport/iceTransport) */ readonly iceTransport: RTCIceTransport; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDtlsTransport/error_event) */ - onerror: ((this: RTCDtlsTransport, ev: Event) => any) | null; + onerror: ((this: RTCDtlsTransport, ev: RTCErrorEvent) => any) | null; onstatechange: ((this: RTCDtlsTransport, ev: Event) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCDtlsTransport/state) */ readonly state: RTCDtlsTransportState; @@ -17883,9 +18730,9 @@ interface RTCPeerConnection extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCPeerConnection/signalingState) */ readonly signalingState: RTCSignalingState; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCPeerConnection/addIceCandidate) */ - addIceCandidate(candidate?: RTCIceCandidateInit): Promise; + addIceCandidate(candidate?: RTCIceCandidateInit | null): Promise; /** @deprecated */ - addIceCandidate(candidate: RTCIceCandidateInit, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise; + addIceCandidate(candidate: RTCIceCandidateInit | null, successCallback: VoidFunction, failureCallback: RTCPeerConnectionErrorCallback): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCPeerConnection/addTrack) */ addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCPeerConnection/addTransceiver) */ @@ -18277,7 +19124,7 @@ declare var ReadableStream: { new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; - from(asyncIterable: AsyncIterable | Iterable> & object): ReadableStream; + from(asyncIterable: AsyncIterable | Iterable>): ReadableStream; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */ @@ -18290,7 +19137,7 @@ interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { declare var ReadableStreamBYOBReader: { prototype: ReadableStreamBYOBReader; - new(stream: ReadableStream): ReadableStreamBYOBReader; + new(stream: ReadableStream): ReadableStreamBYOBReader; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */ @@ -19872,14 +20719,23 @@ declare var SVGLength: { * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList) */ interface SVGLengthList { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/length) */ readonly length: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/numberOfItems) */ readonly numberOfItems: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/appendItem) */ appendItem(newItem: SVGLength): SVGLength; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/clear) */ clear(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/getItem) */ getItem(index: number): SVGLength; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/initialize) */ initialize(newItem: SVGLength): SVGLength; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/insertItemBefore) */ insertItemBefore(newItem: SVGLength, index: number): SVGLength; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/removeItem) */ removeItem(index: number): SVGLength; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGLengthList/replaceItem) */ replaceItem(newItem: SVGLength, index: number): SVGLength; [index: number]: SVGLength; } @@ -21603,7 +22459,7 @@ declare var SubmitEvent: { }; /** - * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via globalThis.crypto). + * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). * Available only in secure contexts. * * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto) @@ -21612,7 +22468,7 @@ interface SubtleCrypto { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt) */ decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits) */ - deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise; + deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length?: number | null): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */ deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest) */ @@ -21777,11 +22633,27 @@ declare var TextEncoderStream: { new(): TextEncoderStream; }; +/** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEvent) + */ interface TextEvent extends UIEvent { + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEvent/data) + */ readonly data: string; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEvent/initTextEvent) + */ initTextEvent(type: string, bubbles?: boolean, cancelable?: boolean, view?: Window | null, data?: string): void; } +/** @deprecated */ declare var TextEvent: { prototype: TextEvent; new(): TextEvent; @@ -22063,7 +22935,7 @@ interface TextTrackList extends EventTarget { onaddtrack: ((this: TextTrackList, ev: TrackEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextTrackList/change_event) */ onchange: ((this: TextTrackList, ev: Event) => any) | null; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextTrackList/removeTrack_event) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextTrackList/removetrack_event) */ onremovetrack: ((this: TextTrackList, ev: TrackEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextTrackList/getTrackById) */ getTrackById(id: string): TextTrack | null; @@ -22448,7 +23320,7 @@ declare var URLSearchParams: { interface UserActivation { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/UserActivation/hasBeenActive) */ readonly hasBeenActive: boolean; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/UserActivation/hasBeenActive) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/UserActivation/isActive) */ readonly isActive: boolean; } @@ -22517,6 +23389,7 @@ declare var VTTRegion: { interface ValidityState { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/badInput) */ readonly badInput: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/customError) */ readonly customError: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/patternMismatch) */ readonly patternMismatch: boolean; @@ -22532,6 +23405,7 @@ interface ValidityState { readonly tooShort: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/typeMismatch) */ readonly typeMismatch: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/valid) */ readonly valid: boolean; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ValidityState/valueMissing) */ readonly valueMissing: boolean; @@ -23595,13 +24469,13 @@ interface WebGL2RenderingContextBase { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/copyTexSubImage3D) */ copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createQuery) */ - createQuery(): WebGLQuery | null; + createQuery(): WebGLQuery; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createSampler) */ - createSampler(): WebGLSampler | null; + createSampler(): WebGLSampler; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createTransformFeedback) */ - createTransformFeedback(): WebGLTransformFeedback | null; + createTransformFeedback(): WebGLTransformFeedback; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createVertexArray) */ - createVertexArray(): WebGLVertexArrayObject | null; + createVertexArray(): WebGLVertexArrayObject; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteQuery) */ deleteQuery(query: WebGLQuery | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteSampler) */ @@ -24516,17 +25390,17 @@ interface WebGLRenderingContextBase { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/copyTexSubImage2D) */ copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createBuffer) */ - createBuffer(): WebGLBuffer | null; + createBuffer(): WebGLBuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createFramebuffer) */ - createFramebuffer(): WebGLFramebuffer | null; + createFramebuffer(): WebGLFramebuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createProgram) */ - createProgram(): WebGLProgram | null; + createProgram(): WebGLProgram; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createRenderbuffer) */ - createRenderbuffer(): WebGLRenderbuffer | null; + createRenderbuffer(): WebGLRenderbuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createShader) */ createShader(type: GLenum): WebGLShader | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createTexture) */ - createTexture(): WebGLTexture | null; + createTexture(): WebGLTexture; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/cullFace) */ cullFace(mode: GLenum): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/deleteBuffer) */ @@ -25784,7 +26658,7 @@ interface WindowOrWorkerGlobalScope { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */ createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise; createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */ fetch(input: RequestInfo | URL, init?: RequestInit): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */ queueMicrotask(callback: VoidFunction): void; @@ -26173,7 +27047,11 @@ declare var XPathEvaluator: { interface XPathEvaluatorBase { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createExpression) */ createExpression(expression: string, resolver?: XPathNSResolver | null): XPathExpression; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createNSResolver) */ + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createNSResolver) + */ createNSResolver(nodeResolver: Node): Node; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/evaluate) */ evaluate(expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null): XPathResult; @@ -26282,7 +27160,7 @@ interface Console { clear(): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */ count(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countreset_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */ countReset(label?: string): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */ debug(...data: any[]): void; @@ -26294,9 +27172,9 @@ interface Console { error(...data: any[]): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */ group(...data: any[]): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupcollapsed_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */ groupCollapsed(...data: any[]): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupend_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */ groupEnd(): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */ info(...data: any[]): void; @@ -26306,9 +27184,9 @@ interface Console { table(tabularData?: any, properties?: string[]): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */ time(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeend_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */ timeEnd(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timelog_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */ timeLog(label?: string, ...data: any[]): void; timeStamp(label?: string): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */ @@ -26607,6 +27485,10 @@ declare namespace WebAssembly { function validate(bytes: BufferSource): boolean; } +interface AudioDataOutputCallback { + (output: AudioData): void; +} + interface BlobCallback { (blob: Blob | null): void; } @@ -26623,6 +27505,10 @@ interface DecodeSuccessCallback { (decodedData: AudioBuffer): void; } +interface EncodedAudioChunkOutputCallback { + (output: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void; +} + interface EncodedVideoChunkOutputCallback { (chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void; } @@ -26759,10 +27645,6 @@ interface UnderlyingSourceStartCallback { (controller: ReadableStreamController): any; } -interface UpdateCallback { - (): any; -} - interface VideoFrameOutputCallback { (output: VideoFrame): void; } @@ -26771,6 +27653,10 @@ interface VideoFrameRequestCallback { (now: DOMHighResTimeStamp, metadata: VideoFrameCallbackMetadata): void; } +interface ViewTransitionUpdateCallback { + (): any; +} + interface VoidFunction { (): void; } @@ -27820,7 +28706,7 @@ declare function clearTimeout(id: number | undefined): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */ declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise; declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; -/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */ +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */ declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */ declare function queueMicrotask(callback: VoidFunction): void; @@ -27843,8 +28729,8 @@ type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView; type AutoFill = AutoFillBase | `${OptionalPrefixToken}${OptionalPrefixToken}${AutoFillField}${OptionalPostfixToken}`; type AutoFillField = AutoFillNormalField | `${OptionalPrefixToken}${AutoFillContactField}`; type AutoFillSection = `section-${string}`; +type Base64URLString = string; type BigInteger = Uint8Array; -type BinaryData = ArrayBuffer | ArrayBufferView; type BlobPart = BufferSource | Blob | string; type BodyInit = ReadableStream | XMLHttpRequestBodyInit; type BufferSource = ArrayBufferView | ArrayBuffer; @@ -27896,6 +28782,7 @@ type OnErrorEventHandler = OnErrorEventHandlerNonNull | null; type OptionalPostfixToken = ` ${T}` | ""; type OptionalPrefixToken = `${T} ` | ""; type PerformanceEntryList = PerformanceEntry[]; +type PublicKeyCredentialJSON = any; type RTCRtpTransform = RTCRtpScriptTransform; type ReadableStreamController = ReadableStreamDefaultController | ReadableByteStreamController; type ReadableStreamReadResult = ReadableStreamReadValueResult | ReadableStreamReadDoneResult; @@ -27905,7 +28792,7 @@ type ReportList = Report[]; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | VideoFrame; type TimerHandler = string | Function; -type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | MediaSourceHandle | ReadableStream | WritableStream | TransformStream | VideoFrame | ArrayBuffer; +type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | MediaSourceHandle | ReadableStream | WritableStream | TransformStream | AudioData | VideoFrame | ArrayBuffer; type Uint32List = Uint32Array | GLuint[]; type VibratePattern = number | number[]; type WindowProxy = Window; @@ -27918,6 +28805,7 @@ type AppendMode = "segments" | "sequence"; type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none"; type AudioContextLatencyCategory = "balanced" | "interactive" | "playback"; type AudioContextState = "closed" | "running" | "suspended"; +type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar"; type AuthenticatorAttachment = "cross-platform" | "platform"; type AuthenticatorTransport = "ble" | "hybrid" | "internal" | "nfc" | "usb"; type AutoFillAddressKind = "billing" | "shipping"; @@ -27931,6 +28819,7 @@ type AutomationRate = "a-rate" | "k-rate"; type AvcBitstreamFormat = "annexb" | "avc"; type BinaryType = "arraybuffer" | "blob"; type BiquadFilterType = "allpass" | "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking"; +type BitrateMode = "constant" | "variable"; type CSSMathOperator = "clamp" | "invert" | "max" | "min" | "negate" | "product" | "sum"; type CSSNumericBaseType = "angle" | "flex" | "frequency" | "length" | "percent" | "resolution" | "time"; type CanPlayTypeResult = "" | "maybe" | "probably"; @@ -27960,6 +28849,7 @@ type DisplayCaptureSurfaceType = "browser" | "monitor" | "window"; type DistanceModelType = "exponential" | "inverse" | "linear"; type DocumentReadyState = "complete" | "interactive" | "loading"; type DocumentVisibilityState = "hidden" | "visible"; +type EncodedAudioChunkType = "delta" | "key"; type EncodedVideoChunkType = "delta" | "key"; type EndOfStreamError = "decode" | "network"; type EndingType = "native" | "transparent"; @@ -28008,12 +28898,14 @@ type NavigationTimingType = "back_forward" | "navigate" | "prerender" | "reload" type NotificationDirection = "auto" | "ltr" | "rtl"; type NotificationPermission = "default" | "denied" | "granted"; type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu"; +type OpusBitstreamFormat = "ogg" | "opus"; type OrientationType = "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary"; type OscillatorType = "custom" | "sawtooth" | "sine" | "square" | "triangle"; type OverSampleType = "2x" | "4x" | "none"; type PanningModelType = "HRTF" | "equalpower"; type PaymentComplete = "fail" | "success" | "unknown"; -type PermissionName = "geolocation" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "xr-spatial-tracking"; +type PaymentShippingType = "delivery" | "pickup" | "shipping"; +type PermissionName = "geolocation" | "midi" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "storage-access"; type PermissionState = "denied" | "granted" | "prompt"; type PlaybackDirection = "alternate" | "alternate-reverse" | "normal" | "reverse"; type PositionAlignSetting = "auto" | "center" | "line-left" | "line-right"; diff --git a/cli/tsc/dts/lib.es2015.core.d.ts b/cli/tsc/dts/lib.es2015.core.d.ts index 1b22b29b42..d70f9cdc0a 100644 --- a/cli/tsc/dts/lib.es2015.core.d.ts +++ b/cli/tsc/dts/lib.es2015.core.d.ts @@ -560,38 +560,38 @@ interface StringConstructor { raw(template: { raw: readonly string[] | ArrayLike; }, ...substitutions: any[]): string; } -interface Int8Array { +interface Int8Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Uint8Array { +interface Uint8Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Int16Array { +interface Int16Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Uint16Array { +interface Uint16Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Int32Array { +interface Int32Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Uint32Array { +interface Uint32Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Float32Array { +interface Float32Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } -interface Float64Array { +interface Float64Array { toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string; } diff --git a/cli/tsc/dts/lib.es2015.iterable.d.ts b/cli/tsc/dts/lib.es2015.iterable.d.ts index eaff26d9a3..e5cdcd2411 100644 --- a/cli/tsc/dts/lib.es2015.iterable.d.ts +++ b/cli/tsc/dts/lib.es2015.iterable.d.ts @@ -270,7 +270,7 @@ interface String { [Symbol.iterator](): StringIterator; } -interface Int8Array { +interface Int8Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -287,7 +287,7 @@ interface Int8Array { } interface Int8ArrayConstructor { - new (elements: Iterable): Int8Array; + new (elements: Iterable): Int8Array; /** * Creates an array from an array-like or iterable object. @@ -295,10 +295,17 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; + from(arrayLike: Iterable): Int8Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Int8Array; } -interface Uint8Array { +interface Uint8Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -315,7 +322,7 @@ interface Uint8Array { } interface Uint8ArrayConstructor { - new (elements: Iterable): Uint8Array; + new (elements: Iterable): Uint8Array; /** * Creates an array from an array-like or iterable object. @@ -323,10 +330,17 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; + from(arrayLike: Iterable): Uint8Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -345,7 +359,7 @@ interface Uint8ClampedArray { } interface Uint8ClampedArrayConstructor { - new (elements: Iterable): Uint8ClampedArray; + new (elements: Iterable): Uint8ClampedArray; /** * Creates an array from an array-like or iterable object. @@ -353,10 +367,17 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; + from(arrayLike: Iterable): Uint8ClampedArray; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray; } -interface Int16Array { +interface Int16Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -375,7 +396,7 @@ interface Int16Array { } interface Int16ArrayConstructor { - new (elements: Iterable): Int16Array; + new (elements: Iterable): Int16Array; /** * Creates an array from an array-like or iterable object. @@ -383,10 +404,17 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; + from(arrayLike: Iterable): Int16Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Int16Array; } -interface Uint16Array { +interface Uint16Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -403,7 +431,7 @@ interface Uint16Array { } interface Uint16ArrayConstructor { - new (elements: Iterable): Uint16Array; + new (elements: Iterable): Uint16Array; /** * Creates an array from an array-like or iterable object. @@ -411,10 +439,17 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; + from(arrayLike: Iterable): Uint16Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint16Array; } -interface Int32Array { +interface Int32Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -431,7 +466,7 @@ interface Int32Array { } interface Int32ArrayConstructor { - new (elements: Iterable): Int32Array; + new (elements: Iterable): Int32Array; /** * Creates an array from an array-like or iterable object. @@ -439,10 +474,17 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; + from(arrayLike: Iterable): Int32Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Int32Array; } -interface Uint32Array { +interface Uint32Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -459,7 +501,7 @@ interface Uint32Array { } interface Uint32ArrayConstructor { - new (elements: Iterable): Uint32Array; + new (elements: Iterable): Uint32Array; /** * Creates an array from an array-like or iterable object. @@ -467,10 +509,17 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; + from(arrayLike: Iterable): Uint32Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint32Array; } -interface Float32Array { +interface Float32Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -487,7 +536,7 @@ interface Float32Array { } interface Float32ArrayConstructor { - new (elements: Iterable): Float32Array; + new (elements: Iterable): Float32Array; /** * Creates an array from an array-like or iterable object. @@ -495,10 +544,17 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; + from(arrayLike: Iterable): Float32Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Float32Array; } -interface Float64Array { +interface Float64Array { [Symbol.iterator](): ArrayIterator; /** * Returns an array of key, value pairs for every entry in the array @@ -515,7 +571,7 @@ interface Float64Array { } interface Float64ArrayConstructor { - new (elements: Iterable): Float64Array; + new (elements: Iterable): Float64Array; /** * Creates an array from an array-like or iterable object. @@ -523,5 +579,12 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: Iterable, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; + from(arrayLike: Iterable): Float64Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: Iterable, mapfn?: (v: T, k: number) => number, thisArg?: any): Float64Array; } diff --git a/cli/tsc/dts/lib.es2015.symbol.wellknown.d.ts b/cli/tsc/dts/lib.es2015.symbol.wellknown.d.ts index 06bcc35b3d..42678a0e45 100644 --- a/cli/tsc/dts/lib.es2015.symbol.wellknown.d.ts +++ b/cli/tsc/dts/lib.es2015.symbol.wellknown.d.ts @@ -272,43 +272,43 @@ interface ArrayBuffer { readonly [Symbol.toStringTag]: string; } -interface DataView { +interface DataView { readonly [Symbol.toStringTag]: string; } -interface Int8Array { +interface Int8Array { readonly [Symbol.toStringTag]: "Int8Array"; } -interface Uint8Array { +interface Uint8Array { readonly [Symbol.toStringTag]: "Uint8Array"; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { readonly [Symbol.toStringTag]: "Uint8ClampedArray"; } -interface Int16Array { +interface Int16Array { readonly [Symbol.toStringTag]: "Int16Array"; } -interface Uint16Array { +interface Uint16Array { readonly [Symbol.toStringTag]: "Uint16Array"; } -interface Int32Array { +interface Int32Array { readonly [Symbol.toStringTag]: "Int32Array"; } -interface Uint32Array { +interface Uint32Array { readonly [Symbol.toStringTag]: "Uint32Array"; } -interface Float32Array { +interface Float32Array { readonly [Symbol.toStringTag]: "Float32Array"; } -interface Float64Array { +interface Float64Array { readonly [Symbol.toStringTag]: "Float64Array"; } diff --git a/cli/tsc/dts/lib.es2016.array.include.d.ts b/cli/tsc/dts/lib.es2016.array.include.d.ts index 3aa5a044e0..6548c91908 100644 --- a/cli/tsc/dts/lib.es2016.array.include.d.ts +++ b/cli/tsc/dts/lib.es2016.array.include.d.ts @@ -34,7 +34,7 @@ interface ReadonlyArray { includes(searchElement: T, fromIndex?: number): boolean; } -interface Int8Array { +interface Int8Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -43,7 +43,7 @@ interface Int8Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Uint8Array { +interface Uint8Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -52,7 +52,7 @@ interface Uint8Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -61,7 +61,7 @@ interface Uint8ClampedArray { includes(searchElement: number, fromIndex?: number): boolean; } -interface Int16Array { +interface Int16Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -70,7 +70,7 @@ interface Int16Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Uint16Array { +interface Uint16Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -79,7 +79,7 @@ interface Uint16Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Int32Array { +interface Int32Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -88,7 +88,7 @@ interface Int32Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Uint32Array { +interface Uint32Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -97,7 +97,7 @@ interface Uint32Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Float32Array { +interface Float32Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. @@ -106,7 +106,7 @@ interface Float32Array { includes(searchElement: number, fromIndex?: number): boolean; } -interface Float64Array { +interface Float64Array { /** * Determines whether an array includes a certain element, returning true or false as appropriate. * @param searchElement The element to search for. diff --git a/cli/tsc/dts/lib.es2016.intl.d.ts b/cli/tsc/dts/lib.es2016.intl.d.ts index 7af6efc2b0..83ca380f0b 100644 --- a/cli/tsc/dts/lib.es2016.intl.d.ts +++ b/cli/tsc/dts/lib.es2016.intl.d.ts @@ -22,7 +22,7 @@ declare namespace Intl { * the canonical locale names. Duplicates will be omitted and elements * will be validated as structurally valid language tags. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales) + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales) * * @param locale A list of String values for which to get the canonical locale names * @returns An array containing the canonical and validated locale names. diff --git a/cli/tsc/dts/lib.es2017.arraybuffer.d.ts b/cli/tsc/dts/lib.es2017.arraybuffer.d.ts new file mode 100644 index 0000000000..e2f00b8340 --- /dev/null +++ b/cli/tsc/dts/lib.es2017.arraybuffer.d.ts @@ -0,0 +1,21 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +interface ArrayBufferConstructor { + new (): ArrayBuffer; +} diff --git a/cli/tsc/dts/lib.es2017.d.ts b/cli/tsc/dts/lib.es2017.d.ts index e0bd4eeb72..234a01f956 100644 --- a/cli/tsc/dts/lib.es2017.d.ts +++ b/cli/tsc/dts/lib.es2017.d.ts @@ -17,9 +17,10 @@ and limitations under the License. /// /// +/// +/// +/// /// /// /// -/// /// -/// diff --git a/cli/tsc/dts/lib.es2017.sharedmemory.d.ts b/cli/tsc/dts/lib.es2017.sharedmemory.d.ts index a46c5ccb13..89b703982b 100644 --- a/cli/tsc/dts/lib.es2017.sharedmemory.d.ts +++ b/cli/tsc/dts/lib.es2017.sharedmemory.d.ts @@ -28,14 +28,14 @@ interface SharedArrayBuffer { /** * Returns a section of an SharedArrayBuffer. */ - slice(begin: number, end?: number): SharedArrayBuffer; + slice(begin?: number, end?: number): SharedArrayBuffer; readonly [Symbol.species]: SharedArrayBuffer; readonly [Symbol.toStringTag]: "SharedArrayBuffer"; } interface SharedArrayBufferConstructor { readonly prototype: SharedArrayBuffer; - new (byteLength: number): SharedArrayBuffer; + new (byteLength?: number): SharedArrayBuffer; } declare var SharedArrayBuffer: SharedArrayBufferConstructor; @@ -49,28 +49,28 @@ interface Atomics { * Until this atomic operation completes, any other read or write operation against the array * will block. */ - add(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + add(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * Stores the bitwise AND of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or * write operation against the array will block. */ - and(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + and(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * Replaces the value at the given position in the array if the original value equals the given * expected value, returning the original value. Until this atomic operation completes, any * other read or write operation against the array will block. */ - compareExchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, expectedValue: number, replacementValue: number): number; + compareExchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, expectedValue: number, replacementValue: number): number; /** * Replaces the value at the given position in the array, returning the original value. Until * this atomic operation completes, any other read or write operation against the array will * block. */ - exchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + exchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * Returns a value indicating whether high-performance algorithms can use atomic operations @@ -83,27 +83,27 @@ interface Atomics { * Returns the value at the given position in the array. Until this atomic operation completes, * any other read or write operation against the array will block. */ - load(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number): number; + load(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number): number; /** * Stores the bitwise OR of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or write * operation against the array will block. */ - or(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + or(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * Stores a value at the given position in the array, returning the new value. Until this * atomic operation completes, any other read or write operation against the array will block. */ - store(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + store(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * Subtracts a value from the value at the given position in the array, returning the original * value. Until this atomic operation completes, any other read or write operation against the * array will block. */ - sub(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + sub(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; /** * If the value at the given position in the array is equal to the provided value, the current @@ -111,23 +111,23 @@ interface Atomics { * `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns * `"not-equal"`. */ - wait(typedArray: Int32Array, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out"; + wait(typedArray: Int32Array, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out"; /** * Wakes up sleeping agents that are waiting on the given index of the array, returning the * number of agents that were awoken. - * @param typedArray A shared Int32Array. + * @param typedArray A shared Int32Array. * @param index The position in the typedArray to wake up on. * @param count The number of sleeping agents to notify. Defaults to +Infinity. */ - notify(typedArray: Int32Array, index: number, count?: number): number; + notify(typedArray: Int32Array, index: number, count?: number): number; /** * Stores the bitwise XOR of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or write * operation against the array will block. */ - xor(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; + xor(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number; readonly [Symbol.toStringTag]: "Atomics"; } diff --git a/cli/tsc/dts/lib.es2017.typedarrays.d.ts b/cli/tsc/dts/lib.es2017.typedarrays.d.ts index 2182ec12f8..aed22e3ee2 100644 --- a/cli/tsc/dts/lib.es2017.typedarrays.d.ts +++ b/cli/tsc/dts/lib.es2017.typedarrays.d.ts @@ -17,37 +17,37 @@ and limitations under the License. /// interface Int8ArrayConstructor { - new (): Int8Array; + new (): Int8Array; } interface Uint8ArrayConstructor { - new (): Uint8Array; + new (): Uint8Array; } interface Uint8ClampedArrayConstructor { - new (): Uint8ClampedArray; + new (): Uint8ClampedArray; } interface Int16ArrayConstructor { - new (): Int16Array; + new (): Int16Array; } interface Uint16ArrayConstructor { - new (): Uint16Array; + new (): Uint16Array; } interface Int32ArrayConstructor { - new (): Int32Array; + new (): Int32Array; } interface Uint32ArrayConstructor { - new (): Uint32Array; + new (): Uint32Array; } interface Float32ArrayConstructor { - new (): Float32Array; + new (): Float32Array; } interface Float64ArrayConstructor { - new (): Float64Array; + new (): Float64Array; } diff --git a/cli/tsc/dts/lib.es2020.bigint.d.ts b/cli/tsc/dts/lib.es2020.bigint.d.ts index 9997ac0003..2d6204e2d5 100644 --- a/cli/tsc/dts/lib.es2020.bigint.d.ts +++ b/cli/tsc/dts/lib.es2020.bigint.d.ts @@ -20,7 +20,7 @@ and limitations under the License. interface BigIntToLocaleStringOptions { /** - * The locale matching algorithm to use.The default is "best fit". For information about this option, see the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation Intl page}. + * The locale matching algorithm to use.The default is "best fit". For information about this option, see the {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation Intl page}. */ localeMatcher?: string; /** @@ -146,12 +146,12 @@ declare var BigInt: BigIntConstructor; * A typed array of 64-bit signed integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated, an exception is raised. */ -interface BigInt64Array { +interface BigInt64Array { /** The size in bytes of each element in the array. */ readonly BYTES_PER_ELEMENT: number; /** The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** The length in bytes of the array. */ readonly byteLength: number; @@ -181,7 +181,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; + every(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -200,7 +200,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array; + filter(predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -211,7 +211,7 @@ interface BigInt64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined; + find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -222,7 +222,7 @@ interface BigInt64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -231,7 +231,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void; /** * Determines whether an array includes a certain element, returning true or false as appropriate. @@ -277,7 +277,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array; + map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -289,7 +289,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; + reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -301,7 +301,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -313,7 +313,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; + reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -325,7 +325,7 @@ interface BigInt64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U; /** Reverses the elements in the array. */ reverse(): this; @@ -342,7 +342,7 @@ interface BigInt64Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. */ - slice(start?: number, end?: number): BigInt64Array; + slice(start?: number, end?: number): BigInt64Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -352,7 +352,7 @@ interface BigInt64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; + some(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean; /** * Sorts the array. @@ -366,7 +366,7 @@ interface BigInt64Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): BigInt64Array; + subarray(begin?: number, end?: number): BigInt64Array; /** Converts the array to a string by using the current locale. */ toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string; @@ -375,7 +375,7 @@ interface BigInt64Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): BigInt64Array; + valueOf(): BigInt64Array; /** Yields each value in the array. */ values(): ArrayIterator; @@ -386,12 +386,12 @@ interface BigInt64Array { [index: number]: bigint; } - interface BigInt64ArrayConstructor { - readonly prototype: BigInt64Array; - new (length?: number): BigInt64Array; - new (array: Iterable): BigInt64Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigInt64Array; + readonly prototype: BigInt64Array; + new (length?: number): BigInt64Array; + new (array: ArrayLike | Iterable): BigInt64Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): BigInt64Array; + new (array: ArrayLike | ArrayBuffer): BigInt64Array; /** The size in bytes of each element in the array. */ readonly BYTES_PER_ELEMENT: number; @@ -400,7 +400,7 @@ interface BigInt64ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: bigint[]): BigInt64Array; + of(...items: bigint[]): BigInt64Array; /** * Creates an array from an array-like or iterable object. @@ -408,22 +408,27 @@ interface BigInt64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike): BigInt64Array; - from(arrayLike: ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array; + from(arrayLike: ArrayLike): BigInt64Array; + /** + * Creates an array from an array-like or iterable object. + * @param arrayLike An array-like or iterable object to convert to an array. + * @param mapfn A mapping function to call on every element of the array. + * @param thisArg Value of 'this' used to invoke the mapfn. + */ + from(arrayLike: ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array; } - declare var BigInt64Array: BigInt64ArrayConstructor; /** * A typed array of 64-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated, an exception is raised. */ -interface BigUint64Array { +interface BigUint64Array { /** The size in bytes of each element in the array. */ readonly BYTES_PER_ELEMENT: number; /** The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** The length in bytes of the array. */ readonly byteLength: number; @@ -453,7 +458,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; + every(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -472,7 +477,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array; + filter(predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -483,7 +488,7 @@ interface BigUint64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined; + find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -494,7 +499,7 @@ interface BigUint64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -503,7 +508,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void; /** * Determines whether an array includes a certain element, returning true or false as appropriate. @@ -549,7 +554,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array; + map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -561,7 +566,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; + reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -573,7 +578,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -585,7 +590,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; + reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -597,7 +602,7 @@ interface BigUint64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U; /** Reverses the elements in the array. */ reverse(): this; @@ -614,7 +619,7 @@ interface BigUint64Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. */ - slice(start?: number, end?: number): BigUint64Array; + slice(start?: number, end?: number): BigUint64Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -624,7 +629,7 @@ interface BigUint64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; + some(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean; /** * Sorts the array. @@ -638,7 +643,7 @@ interface BigUint64Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): BigUint64Array; + subarray(begin?: number, end?: number): BigUint64Array; /** Converts the array to a string by using the current locale. */ toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string; @@ -647,7 +652,7 @@ interface BigUint64Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): BigUint64Array; + valueOf(): BigUint64Array; /** Yields each value in the array. */ values(): ArrayIterator; @@ -658,12 +663,12 @@ interface BigUint64Array { [index: number]: bigint; } - interface BigUint64ArrayConstructor { - readonly prototype: BigUint64Array; - new (length?: number): BigUint64Array; - new (array: Iterable): BigUint64Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigUint64Array; + readonly prototype: BigUint64Array; + new (length?: number): BigUint64Array; + new (array: ArrayLike | Iterable): BigUint64Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): BigUint64Array; + new (array: ArrayLike | ArrayBuffer): BigUint64Array; /** The size in bytes of each element in the array. */ readonly BYTES_PER_ELEMENT: number; @@ -672,7 +677,7 @@ interface BigUint64ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: bigint[]): BigUint64Array; + of(...items: bigint[]): BigUint64Array; /** * Creates an array from an array-like or iterable object. @@ -683,10 +688,9 @@ interface BigUint64ArrayConstructor { from(arrayLike: ArrayLike): BigUint64Array; from(arrayLike: ArrayLike, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array; } - declare var BigUint64Array: BigUint64ArrayConstructor; -interface DataView { +interface DataView { /** * Gets the BigInt64 value at the specified byte offset from the start of the view. There is * no alignment constraint; multi-byte values may be fetched from any offset. diff --git a/cli/tsc/dts/lib.es2020.intl.d.ts b/cli/tsc/dts/lib.es2020.intl.d.ts index 0da854e161..b945d3801c 100644 --- a/cli/tsc/dts/lib.es2020.intl.d.ts +++ b/cli/tsc/dts/lib.es2020.intl.d.ts @@ -23,14 +23,14 @@ declare namespace Intl { * * For example: "fa", "es-MX", "zh-Hant-TW". * - * See [MDN - Intl - locales argument](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument). + * See [MDN - Intl - locales argument](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument). */ type UnicodeBCP47LocaleIdentifier = string; /** * Unit to use in the relative time internationalized message. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format#Parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format#Parameters). */ type RelativeTimeFormatUnit = | "year" @@ -57,7 +57,7 @@ declare namespace Intl { * but `formatToParts` only outputs singular (e.g. "day") not plural (e.g. * "days"). * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts). */ type RelativeTimeFormatUnitSingular = | "year" @@ -79,21 +79,21 @@ declare namespace Intl { /** * The format of output message. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). */ type RelativeTimeFormatNumeric = "always" | "auto"; /** * The length of the internationalized message. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). */ type RelativeTimeFormatStyle = "long" | "short" | "narrow"; /** * The locale or locales to use * - * See [MDN - Intl - locales argument](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument). + * See [MDN - Intl - locales argument](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument). */ type LocalesArgument = UnicodeBCP47LocaleIdentifier | Locale | readonly (UnicodeBCP47LocaleIdentifier | Locale)[] | undefined; @@ -101,7 +101,7 @@ declare namespace Intl { * An object with some or all of properties of `options` parameter * of `Intl.RelativeTimeFormat` constructor. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters). */ interface RelativeTimeFormatOptions { /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */ @@ -117,7 +117,7 @@ declare namespace Intl { * and formatting options computed during initialization * of the `Intl.RelativeTimeFormat` object * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/resolvedOptions#Description). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/resolvedOptions#Description). */ interface ResolvedRelativeTimeFormatOptions { locale: UnicodeBCP47LocaleIdentifier; @@ -130,7 +130,7 @@ declare namespace Intl { * An object representing the relative time format in parts * that can be used for custom locale-aware formatting. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts#Using_formatToParts). */ type RelativeTimeFormatPart = | { @@ -166,7 +166,7 @@ declare namespace Intl { * * @returns {string} Internationalized relative time message as string * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format). */ format(value: number, unit: RelativeTimeFormatUnit): string; @@ -179,14 +179,14 @@ declare namespace Intl { * * @throws `RangeError` if `unit` was given something other than `unit` possible values * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts). */ formatToParts(value: number, unit: RelativeTimeFormatUnit): RelativeTimeFormatPart[]; /** * Provides access to the locale and options computed during initialization of this `Intl.RelativeTimeFormat` object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/resolvedOptions). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/resolvedOptions). */ resolvedOptions(): ResolvedRelativeTimeFormatOptions; } @@ -195,22 +195,22 @@ declare namespace Intl { * The [`Intl.RelativeTimeFormat`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat) * object is a constructor for objects that enable language-sensitive relative time formatting. * - * [Compatibility](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat#Browser_compatibility). + * [Compatibility](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat#Browser_compatibility). */ const RelativeTimeFormat: { /** - * Creates [Intl.RelativeTimeFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat) objects + * Creates [Intl.RelativeTimeFormat](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat) objects * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the locales argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters) + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters) * with some or all of options of `RelativeTimeFormatOptions`. * - * @returns [Intl.RelativeTimeFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat) object. + * @returns [Intl.RelativeTimeFormat](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat) object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat). */ new ( locales?: LocalesArgument, @@ -224,16 +224,16 @@ declare namespace Intl { * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the locales argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters) + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat#Parameters) * with some or all of options of the formatting. * * @returns An array containing those of the provided locales * that are supported in date and time formatting * without having to fall back to the runtime's default locale. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/supportedLocalesOf). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/supportedLocalesOf). */ supportedLocalesOf( locales?: LocalesArgument, @@ -336,18 +336,18 @@ declare namespace Intl { } /** - * Constructor creates [Intl.Locale](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) + * Constructor creates [Intl.Locale](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) * objects * * @param tag - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646). * For the general form and interpretation of the locales argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/Locale#Parameters) with some or all of options of the locale. + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/Locale#Parameters) with some or all of options of the locale. * - * @returns [Intl.Locale](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) object. + * @returns [Intl.Locale](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale). */ const Locale: { new (tag: UnicodeBCP47LocaleIdentifier | Locale, options?: LocaleOptions): Locale; @@ -388,7 +388,7 @@ declare namespace Intl { interface DisplayNames { /** * Receives a code and returns a string based on the locale and options provided when instantiating - * [`Intl.DisplayNames()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) + * [`Intl.DisplayNames()`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) * * @param code The `code` to provide depends on the `type` passed to display name during creation: * - If the type is `"region"`, code should be either an [ISO-3166 two letters region code](https://www.iso.org/iso-3166-country-codes.html), @@ -399,35 +399,35 @@ declare namespace Intl { * `languageCode` is either a two letters ISO 639-1 language code or a three letters ISO 639-2 language code. * - If the type is `"currency"`, code should be a [3-letter ISO 4217 currency code](https://www.iso.org/iso-4217-currency-codes.html). * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/of). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/of). */ of(code: string): string | undefined; /** * Returns a new object with properties reflecting the locale and style formatting options computed during the construction of the current - * [`Intl/DisplayNames`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) object. + * [`Intl/DisplayNames`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/resolvedOptions). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/resolvedOptions). */ resolvedOptions(): ResolvedDisplayNamesOptions; } /** - * The [`Intl.DisplayNames()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) + * The [`Intl.DisplayNames()`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) * object enables the consistent translation of language, region and script display names. * - * [Compatibility](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames#browser_compatibility). + * [Compatibility](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames#browser_compatibility). */ const DisplayNames: { prototype: DisplayNames; /** * @param locales A string with a BCP 47 language tag, or an array of such strings. - * For the general form and interpretation of the `locales` argument, see the [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) + * For the general form and interpretation of the `locales` argument, see the [Intl](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) * page. * * @param options An object for setting up a display name. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames). */ new (locales: LocalesArgument, options: DisplayNamesOptions): DisplayNames; @@ -435,14 +435,14 @@ declare namespace Intl { * Returns an array containing those of the provided locales that are supported in display names without having to fall back to the runtime's default locale. * * @param locales A string with a BCP 47 language tag, or an array of such strings. - * For the general form and interpretation of the `locales` argument, see the [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) + * For the general form and interpretation of the `locales` argument, see the [Intl](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) * page. * * @param options An object with a locale matcher. * * @returns An array of strings representing a subset of the given locale tags that are supported in display names without having to fall back to the runtime's default locale. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/supportedLocalesOf). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/supportedLocalesOf). */ supportedLocalesOf(locales?: LocalesArgument, options?: { localeMatcher?: RelativeTimeFormatLocaleMatcher; }): UnicodeBCP47LocaleIdentifier[]; }; diff --git a/cli/tsc/dts/lib.es2020.sharedmemory.d.ts b/cli/tsc/dts/lib.es2020.sharedmemory.d.ts index 3c7c14f4bd..35641a6426 100644 --- a/cli/tsc/dts/lib.es2020.sharedmemory.d.ts +++ b/cli/tsc/dts/lib.es2020.sharedmemory.d.ts @@ -16,60 +16,62 @@ and limitations under the License. /// +/// + interface Atomics { /** * Adds a value to the value at the given position in the array, returning the original value. * Until this atomic operation completes, any other read or write operation against the array * will block. */ - add(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + add(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * Stores the bitwise AND of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or * write operation against the array will block. */ - and(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + and(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * Replaces the value at the given position in the array if the original value equals the given * expected value, returning the original value. Until this atomic operation completes, any * other read or write operation against the array will block. */ - compareExchange(typedArray: BigInt64Array | BigUint64Array, index: number, expectedValue: bigint, replacementValue: bigint): bigint; + compareExchange(typedArray: BigInt64Array | BigUint64Array, index: number, expectedValue: bigint, replacementValue: bigint): bigint; /** * Replaces the value at the given position in the array, returning the original value. Until * this atomic operation completes, any other read or write operation against the array will * block. */ - exchange(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + exchange(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * Returns the value at the given position in the array. Until this atomic operation completes, * any other read or write operation against the array will block. */ - load(typedArray: BigInt64Array | BigUint64Array, index: number): bigint; + load(typedArray: BigInt64Array | BigUint64Array, index: number): bigint; /** * Stores the bitwise OR of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or write * operation against the array will block. */ - or(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + or(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * Stores a value at the given position in the array, returning the new value. Until this * atomic operation completes, any other read or write operation against the array will block. */ - store(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + store(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * Subtracts a value from the value at the given position in the array, returning the original * value. Until this atomic operation completes, any other read or write operation against the * array will block. */ - sub(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + sub(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; /** * If the value at the given position in the array is equal to the provided value, the current @@ -77,7 +79,7 @@ interface Atomics { * `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns * `"not-equal"`. */ - wait(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): "ok" | "not-equal" | "timed-out"; + wait(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): "ok" | "not-equal" | "timed-out"; /** * Wakes up sleeping agents that are waiting on the given index of the array, returning the @@ -86,12 +88,12 @@ interface Atomics { * @param index The position in the typedArray to wake up on. * @param count The number of sleeping agents to notify. Defaults to +Infinity. */ - notify(typedArray: BigInt64Array, index: number, count?: number): number; + notify(typedArray: BigInt64Array, index: number, count?: number): number; /** * Stores the bitwise XOR of a value with the value at the given position in the array, * returning the original value. Until this atomic operation completes, any other read or write * operation against the array will block. */ - xor(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; + xor(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint; } diff --git a/cli/tsc/dts/lib.es2020.string.d.ts b/cli/tsc/dts/lib.es2020.string.d.ts index cdb38e0d86..4c2a4ded06 100644 --- a/cli/tsc/dts/lib.es2020.string.d.ts +++ b/cli/tsc/dts/lib.es2020.string.d.ts @@ -16,6 +16,8 @@ and limitations under the License. /// +/// +/// /// interface String { diff --git a/cli/tsc/dts/lib.es2021.intl.d.ts b/cli/tsc/dts/lib.es2021.intl.d.ts index ec90ad1b2c..a0fe4825e7 100644 --- a/cli/tsc/dts/lib.es2021.intl.d.ts +++ b/cli/tsc/dts/lib.es2021.intl.d.ts @@ -50,28 +50,28 @@ declare namespace Intl { /** * The locale matching algorithm to use. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). */ type ListFormatLocaleMatcher = "lookup" | "best fit"; /** * The format of output message. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). */ type ListFormatType = "conjunction" | "disjunction" | "unit"; /** * The length of the formatted message. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). */ type ListFormatStyle = "long" | "short" | "narrow"; /** * An object with some or all properties of the `Intl.ListFormat` constructor `options` parameter. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters). */ interface ListFormatOptions { /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */ @@ -92,26 +92,26 @@ declare namespace Intl { /** * Returns a string with a language-specific representation of the list. * - * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array). + * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array). * * @throws `TypeError` if `list` includes something other than the possible values. * * @returns {string} A language-specific formatted string representing the elements of the list. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format). */ format(list: Iterable): string; /** * Returns an Array of objects representing the different components that can be used to format a list of values in a locale-aware fashion. * - * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), to be formatted according to a locale. + * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array), to be formatted according to a locale. * * @throws `TypeError` if `list` includes something other than the possible values. * * @returns {{ type: "element" | "literal", value: string; }[]} An Array of components which contains the formatted parts from the list. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts). */ formatToParts(list: Iterable): { type: "element" | "literal"; value: string; }[]; @@ -120,7 +120,7 @@ declare namespace Intl { * formatting options computed during the construction of the current * `Intl.ListFormat` object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/resolvedOptions). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/resolvedOptions). */ resolvedOptions(): ResolvedListFormatOptions; } @@ -129,19 +129,19 @@ declare namespace Intl { prototype: ListFormat; /** - * Creates [Intl.ListFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) objects that + * Creates [Intl.ListFormat](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) objects that * enable language-sensitive list formatting. * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the `locales` argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters) + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters) * with some or all options of `ListFormatOptions`. * - * @returns [Intl.ListFormatOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) object. + * @returns [Intl.ListFormatOptions](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat). */ new (locales?: LocalesArgument, options?: ListFormatOptions): ListFormat; @@ -151,15 +151,15 @@ declare namespace Intl { * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the `locales` argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf#parameters). + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf#parameters). * with some or all possible options. * * @returns An array of strings representing a subset of the given locale tags that are supported in list * formatting without having to fall back to the runtime's default locale. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf). */ supportedLocalesOf(locales: LocalesArgument, options?: Pick): UnicodeBCP47LocaleIdentifier[]; }; diff --git a/cli/tsc/dts/lib.es2021.weakref.d.ts b/cli/tsc/dts/lib.es2021.weakref.d.ts index 48e76265a2..9e03365a20 100644 --- a/cli/tsc/dts/lib.es2021.weakref.d.ts +++ b/cli/tsc/dts/lib.es2021.weakref.d.ts @@ -16,6 +16,8 @@ and limitations under the License. /// +/// + interface WeakRef { readonly [Symbol.toStringTag]: "WeakRef"; diff --git a/cli/tsc/dts/lib.es2022.array.d.ts b/cli/tsc/dts/lib.es2022.array.d.ts index 621857ba08..6f4dc417a3 100644 --- a/cli/tsc/dts/lib.es2022.array.d.ts +++ b/cli/tsc/dts/lib.es2022.array.d.ts @@ -32,7 +32,7 @@ interface ReadonlyArray { at(index: number): T | undefined; } -interface Int8Array { +interface Int8Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -40,7 +40,7 @@ interface Int8Array { at(index: number): number | undefined; } -interface Uint8Array { +interface Uint8Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -48,7 +48,7 @@ interface Uint8Array { at(index: number): number | undefined; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -56,7 +56,7 @@ interface Uint8ClampedArray { at(index: number): number | undefined; } -interface Int16Array { +interface Int16Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -64,7 +64,7 @@ interface Int16Array { at(index: number): number | undefined; } -interface Uint16Array { +interface Uint16Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -72,7 +72,7 @@ interface Uint16Array { at(index: number): number | undefined; } -interface Int32Array { +interface Int32Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -80,7 +80,7 @@ interface Int32Array { at(index: number): number | undefined; } -interface Uint32Array { +interface Uint32Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -88,7 +88,7 @@ interface Uint32Array { at(index: number): number | undefined; } -interface Float32Array { +interface Float32Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -96,7 +96,7 @@ interface Float32Array { at(index: number): number | undefined; } -interface Float64Array { +interface Float64Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -104,7 +104,7 @@ interface Float64Array { at(index: number): number | undefined; } -interface BigInt64Array { +interface BigInt64Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. @@ -112,7 +112,7 @@ interface BigInt64Array { at(index: number): bigint | undefined; } -interface BigUint64Array { +interface BigUint64Array { /** * Returns the item located at the specified index. * @param index The zero-based index of the desired code unit. A negative index will count back from the last item. diff --git a/cli/tsc/dts/lib.es2022.d.ts b/cli/tsc/dts/lib.es2022.d.ts index 2ae78aba3f..ca7cc91ac9 100644 --- a/cli/tsc/dts/lib.es2022.d.ts +++ b/cli/tsc/dts/lib.es2022.d.ts @@ -21,6 +21,5 @@ and limitations under the License. /// /// /// -/// -/// /// +/// diff --git a/cli/tsc/dts/lib.es2022.error.d.ts b/cli/tsc/dts/lib.es2022.error.d.ts index 782c485e7c..5e02521b42 100644 --- a/cli/tsc/dts/lib.es2022.error.d.ts +++ b/cli/tsc/dts/lib.es2022.error.d.ts @@ -16,6 +16,8 @@ and limitations under the License. /// +/// + interface ErrorOptions { cause?: unknown; } diff --git a/cli/tsc/dts/lib.es2022.intl.d.ts b/cli/tsc/dts/lib.es2022.intl.d.ts index cd8eb11408..3f4a2ca1e4 100644 --- a/cli/tsc/dts/lib.es2022.intl.d.ts +++ b/cli/tsc/dts/lib.es2022.intl.d.ts @@ -20,7 +20,7 @@ declare namespace Intl { /** * An object with some or all properties of the `Intl.Segmenter` constructor `options` parameter. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters) + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters) */ interface SegmenterOptions { /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */ @@ -84,14 +84,14 @@ declare namespace Intl { * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the `locales` argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters) + * @param options - An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/Segmenter#parameters) * with some or all options of `SegmenterOptions`. * - * @returns [Intl.Segmenter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segments) object. + * @returns [Intl.Segmenter](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segments) object. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter). + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter). */ new (locales?: LocalesArgument, options?: SegmenterOptions): Segmenter; @@ -100,19 +100,19 @@ declare namespace Intl { * * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings. * For the general form and interpretation of the `locales` argument, - * see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). + * see the [`Intl` page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation). * - * @param options An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf#parameters). + * @param options An [object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf#parameters). * with some or all possible options. * - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf) + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter/supportedLocalesOf) */ supportedLocalesOf(locales: LocalesArgument, options?: Pick): UnicodeBCP47LocaleIdentifier[]; }; /** * Returns a sorted array of the supported collation, calendar, currency, numbering system, timezones, and units by the implementation. - * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf) + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf) * * @param key A string indicating the category of values to return. * @returns A sorted array of the supported values. diff --git a/cli/tsc/dts/lib.es2023.array.d.ts b/cli/tsc/dts/lib.es2023.array.d.ts index 57362da53c..2fe8b55a0c 100644 --- a/cli/tsc/dts/lib.es2023.array.d.ts +++ b/cli/tsc/dts/lib.es2023.array.d.ts @@ -163,7 +163,7 @@ interface ReadonlyArray { with(index: number, value: T): T[]; } -interface Int8Array { +interface Int8Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -177,12 +177,12 @@ interface Int8Array { predicate: ( value: number, index: number, - array: Int8Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int8Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number | undefined; @@ -196,14 +196,14 @@ interface Int8Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int8Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number; /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Int8Array; + toReversed(): Int8Array; /** * Copies and sorts the array. @@ -211,11 +211,11 @@ interface Int8Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Int8Array.from([11, 2, 22, 1]); - * myNums.toSorted((a, b) => a - b) // Int8Array(4) [1, 2, 11, 22] + * const myNums = Int8Array.from([11, 2, 22, 1]); + * myNums.toSorted((a, b) => a - b) // Int8Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int8Array; + toSorted(compareFn?: (a: number, b: number) => number): Int8Array; /** * Copies the array and inserts the given number at the provided index. @@ -224,10 +224,10 @@ interface Int8Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Int8Array; + with(index: number, value: number): Int8Array; } -interface Uint8Array { +interface Uint8Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -241,12 +241,12 @@ interface Uint8Array { predicate: ( value: number, index: number, - array: Uint8Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Uint8Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number | undefined; @@ -260,14 +260,14 @@ interface Uint8Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Uint8Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number; /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Uint8Array; + toReversed(): Uint8Array; /** * Copies and sorts the array. @@ -275,11 +275,11 @@ interface Uint8Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Uint8Array.from([11, 2, 22, 1]); - * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22] + * const myNums = Uint8Array.from([11, 2, 22, 1]); + * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint8Array; + toSorted(compareFn?: (a: number, b: number) => number): Uint8Array; /** * Copies the array and inserts the given number at the provided index. @@ -288,10 +288,10 @@ interface Uint8Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Uint8Array; + with(index: number, value: number): Uint8Array; } -interface Uint8ClampedArray { +interface Uint8ClampedArray { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -305,7 +305,7 @@ interface Uint8ClampedArray { predicate: ( value: number, index: number, - array: Uint8ClampedArray, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -313,7 +313,7 @@ interface Uint8ClampedArray { predicate: ( value: number, index: number, - array: Uint8ClampedArray, + array: this, ) => unknown, thisArg?: any, ): number | undefined; @@ -331,7 +331,7 @@ interface Uint8ClampedArray { predicate: ( value: number, index: number, - array: Uint8ClampedArray, + array: this, ) => unknown, thisArg?: any, ): number; @@ -339,7 +339,7 @@ interface Uint8ClampedArray { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Uint8ClampedArray; + toReversed(): Uint8ClampedArray; /** * Copies and sorts the array. @@ -347,11 +347,11 @@ interface Uint8ClampedArray { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Uint8ClampedArray.from([11, 2, 22, 1]); - * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22] + * const myNums = Uint8ClampedArray.from([11, 2, 22, 1]); + * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray; + toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray; /** * Copies the array and inserts the given number at the provided index. @@ -360,10 +360,10 @@ interface Uint8ClampedArray { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Uint8ClampedArray; + with(index: number, value: number): Uint8ClampedArray; } -interface Int16Array { +interface Int16Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -377,12 +377,12 @@ interface Int16Array { predicate: ( value: number, index: number, - array: Int16Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int16Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number | undefined; @@ -396,14 +396,14 @@ interface Int16Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int16Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number; /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Int16Array; + toReversed(): Int16Array; /** * Copies and sorts the array. @@ -411,11 +411,11 @@ interface Int16Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Int16Array.from([11, 2, -22, 1]); - * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11] + * const myNums = Int16Array.from([11, 2, -22, 1]); + * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int16Array; + toSorted(compareFn?: (a: number, b: number) => number): Int16Array; /** * Copies the array and inserts the given number at the provided index. @@ -424,10 +424,10 @@ interface Int16Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Int16Array; + with(index: number, value: number): Int16Array; } -interface Uint16Array { +interface Uint16Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -441,7 +441,7 @@ interface Uint16Array { predicate: ( value: number, index: number, - array: Uint16Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -449,7 +449,7 @@ interface Uint16Array { predicate: ( value: number, index: number, - array: Uint16Array, + array: this, ) => unknown, thisArg?: any, ): number | undefined; @@ -467,7 +467,7 @@ interface Uint16Array { predicate: ( value: number, index: number, - array: Uint16Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -475,7 +475,7 @@ interface Uint16Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Uint16Array; + toReversed(): Uint16Array; /** * Copies and sorts the array. @@ -483,11 +483,11 @@ interface Uint16Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Uint16Array.from([11, 2, 22, 1]); - * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22] + * const myNums = Uint16Array.from([11, 2, 22, 1]); + * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint16Array; + toSorted(compareFn?: (a: number, b: number) => number): Uint16Array; /** * Copies the array and inserts the given number at the provided index. @@ -496,10 +496,10 @@ interface Uint16Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Uint16Array; + with(index: number, value: number): Uint16Array; } -interface Int32Array { +interface Int32Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -513,12 +513,12 @@ interface Int32Array { predicate: ( value: number, index: number, - array: Int32Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; findLast( - predicate: (value: number, index: number, array: Int32Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number | undefined; @@ -532,14 +532,14 @@ interface Int32Array { * predicate. If it is not provided, undefined is used instead. */ findLastIndex( - predicate: (value: number, index: number, array: Int32Array) => unknown, + predicate: (value: number, index: number, array: this) => unknown, thisArg?: any, ): number; /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Int32Array; + toReversed(): Int32Array; /** * Copies and sorts the array. @@ -547,11 +547,11 @@ interface Int32Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Int32Array.from([11, 2, -22, 1]); - * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11] + * const myNums = Int32Array.from([11, 2, -22, 1]); + * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Int32Array; + toSorted(compareFn?: (a: number, b: number) => number): Int32Array; /** * Copies the array and inserts the given number at the provided index. @@ -560,10 +560,10 @@ interface Int32Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Int32Array; + with(index: number, value: number): Int32Array; } -interface Uint32Array { +interface Uint32Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -577,7 +577,7 @@ interface Uint32Array { predicate: ( value: number, index: number, - array: Uint32Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -585,7 +585,7 @@ interface Uint32Array { predicate: ( value: number, index: number, - array: Uint32Array, + array: this, ) => unknown, thisArg?: any, ): number | undefined; @@ -603,7 +603,7 @@ interface Uint32Array { predicate: ( value: number, index: number, - array: Uint32Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -611,7 +611,7 @@ interface Uint32Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Uint32Array; + toReversed(): Uint32Array; /** * Copies and sorts the array. @@ -619,11 +619,11 @@ interface Uint32Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Uint32Array.from([11, 2, 22, 1]); - * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22] + * const myNums = Uint32Array.from([11, 2, 22, 1]); + * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Uint32Array; + toSorted(compareFn?: (a: number, b: number) => number): Uint32Array; /** * Copies the array and inserts the given number at the provided index. @@ -632,10 +632,10 @@ interface Uint32Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Uint32Array; + with(index: number, value: number): Uint32Array; } -interface Float32Array { +interface Float32Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -649,7 +649,7 @@ interface Float32Array { predicate: ( value: number, index: number, - array: Float32Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -657,7 +657,7 @@ interface Float32Array { predicate: ( value: number, index: number, - array: Float32Array, + array: this, ) => unknown, thisArg?: any, ): number | undefined; @@ -675,7 +675,7 @@ interface Float32Array { predicate: ( value: number, index: number, - array: Float32Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -683,7 +683,7 @@ interface Float32Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Float32Array; + toReversed(): Float32Array; /** * Copies and sorts the array. @@ -691,11 +691,11 @@ interface Float32Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Float32Array.from([11.25, 2, -22.5, 1]); - * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5] + * const myNums = Float32Array.from([11.25, 2, -22.5, 1]); + * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Float32Array; + toSorted(compareFn?: (a: number, b: number) => number): Float32Array; /** * Copies the array and inserts the given number at the provided index. @@ -704,10 +704,10 @@ interface Float32Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Float32Array; + with(index: number, value: number): Float32Array; } -interface Float64Array { +interface Float64Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -721,7 +721,7 @@ interface Float64Array { predicate: ( value: number, index: number, - array: Float64Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -729,7 +729,7 @@ interface Float64Array { predicate: ( value: number, index: number, - array: Float64Array, + array: this, ) => unknown, thisArg?: any, ): number | undefined; @@ -747,7 +747,7 @@ interface Float64Array { predicate: ( value: number, index: number, - array: Float64Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -755,7 +755,7 @@ interface Float64Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): Float64Array; + toReversed(): Float64Array; /** * Copies and sorts the array. @@ -763,11 +763,11 @@ interface Float64Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = Float64Array.from([11.25, 2, -22.5, 1]); - * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5] + * const myNums = Float64Array.from([11.25, 2, -22.5, 1]); + * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5] * ``` */ - toSorted(compareFn?: (a: number, b: number) => number): Float64Array; + toSorted(compareFn?: (a: number, b: number) => number): Float64Array; /** * Copies the array and inserts the given number at the provided index. @@ -776,10 +776,10 @@ interface Float64Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: number): Float64Array; + with(index: number, value: number): Float64Array; } -interface BigInt64Array { +interface BigInt64Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -793,7 +793,7 @@ interface BigInt64Array { predicate: ( value: bigint, index: number, - array: BigInt64Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -801,7 +801,7 @@ interface BigInt64Array { predicate: ( value: bigint, index: number, - array: BigInt64Array, + array: this, ) => unknown, thisArg?: any, ): bigint | undefined; @@ -819,7 +819,7 @@ interface BigInt64Array { predicate: ( value: bigint, index: number, - array: BigInt64Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -827,7 +827,7 @@ interface BigInt64Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): BigInt64Array; + toReversed(): BigInt64Array; /** * Copies and sorts the array. @@ -835,11 +835,11 @@ interface BigInt64Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = BigInt64Array.from([11n, 2n, -22n, 1n]); - * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n] + * const myNums = BigInt64Array.from([11n, 2n, -22n, 1n]); + * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n] * ``` */ - toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array; + toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array; /** * Copies the array and inserts the given bigint at the provided index. @@ -848,10 +848,10 @@ interface BigInt64Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: bigint): BigInt64Array; + with(index: number, value: bigint): BigInt64Array; } -interface BigUint64Array { +interface BigUint64Array { /** * Returns the value of the last element in the array where predicate is true, and undefined * otherwise. @@ -865,7 +865,7 @@ interface BigUint64Array { predicate: ( value: bigint, index: number, - array: BigUint64Array, + array: this, ) => value is S, thisArg?: any, ): S | undefined; @@ -873,7 +873,7 @@ interface BigUint64Array { predicate: ( value: bigint, index: number, - array: BigUint64Array, + array: this, ) => unknown, thisArg?: any, ): bigint | undefined; @@ -891,7 +891,7 @@ interface BigUint64Array { predicate: ( value: bigint, index: number, - array: BigUint64Array, + array: this, ) => unknown, thisArg?: any, ): number; @@ -899,7 +899,7 @@ interface BigUint64Array { /** * Copies the array and returns the copy with the elements in reverse order. */ - toReversed(): BigUint64Array; + toReversed(): BigUint64Array; /** * Copies and sorts the array. @@ -907,11 +907,11 @@ interface BigUint64Array { * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive * value otherwise. If omitted, the elements are sorted in ascending order. * ```ts - * const myNums = BigUint64Array.from([11n, 2n, 22n, 1n]); - * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n] + * const myNums = BigUint64Array.from([11n, 2n, 22n, 1n]); + * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n] * ``` */ - toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array; + toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array; /** * Copies the array and inserts the given bigint at the provided index. @@ -920,5 +920,5 @@ interface BigUint64Array { * @param value The value to insert into the copied array. * @returns A copy of the original array with the inserted value. */ - with(index: number, value: bigint): BigUint64Array; + with(index: number, value: bigint): BigUint64Array; } diff --git a/cli/tsc/dts/lib.es2024.arraybuffer.d.ts b/cli/tsc/dts/lib.es2024.arraybuffer.d.ts new file mode 100644 index 0000000000..2a5623d90c --- /dev/null +++ b/cli/tsc/dts/lib.es2024.arraybuffer.d.ts @@ -0,0 +1,65 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +interface ArrayBuffer { + /** + * If this ArrayBuffer is resizable, returns the maximum byte length given during construction; returns the byte length if not. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/maxByteLength) + */ + get maxByteLength(): number; + + /** + * Returns true if this ArrayBuffer can be resized. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/resizable) + */ + get resizable(): boolean; + + /** + * Resizes the ArrayBuffer to the specified size (in bytes). + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/resize) + */ + resize(newByteLength?: number): void; + + /** + * Returns a boolean indicating whether or not this buffer has been detached (transferred). + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/detached) + */ + get detached(): boolean; + + /** + * Creates a new ArrayBuffer with the same byte content as this buffer, then detaches this buffer. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer) + */ + transfer(newByteLength?: number): ArrayBuffer; + + /** + * Creates a new non-resizable ArrayBuffer with the same byte content as this buffer, then detaches this buffer. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transferToFixedLength) + */ + transferToFixedLength(newByteLength?: number): ArrayBuffer; +} + +interface ArrayBufferConstructor { + new (byteLength: number, options?: { maxByteLength?: number; }): ArrayBuffer; +} diff --git a/cli/tsc/dts/lib.es2024.collection.d.ts b/cli/tsc/dts/lib.es2024.collection.d.ts new file mode 100644 index 0000000000..a48fd93d5f --- /dev/null +++ b/cli/tsc/dts/lib.es2024.collection.d.ts @@ -0,0 +1,29 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +interface MapConstructor { + /** + * Groups members of an iterable according to the return value of the passed callback. + * @param items An iterable. + * @param keySelector A callback which will be invoked for each item in items. + */ + groupBy( + items: Iterable, + keySelector: (item: T, index: number) => K, + ): Map; +} diff --git a/cli/tsc/dts/lib.es2024.d.ts b/cli/tsc/dts/lib.es2024.d.ts new file mode 100644 index 0000000000..44311afb00 --- /dev/null +++ b/cli/tsc/dts/lib.es2024.d.ts @@ -0,0 +1,26 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +/// +/// +/// +/// +/// +/// +/// +/// diff --git a/cli/tsc/dts/lib.es2024.full.d.ts b/cli/tsc/dts/lib.es2024.full.d.ts new file mode 100644 index 0000000000..b8c6e74867 --- /dev/null +++ b/cli/tsc/dts/lib.es2024.full.d.ts @@ -0,0 +1,24 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/// + +/// +/// +/// +/// +/// +/// diff --git a/cli/tsc/dts/lib.esnext.object.d.ts b/cli/tsc/dts/lib.es2024.object.d.ts similarity index 100% rename from cli/tsc/dts/lib.esnext.object.d.ts rename to cli/tsc/dts/lib.es2024.object.d.ts diff --git a/cli/tsc/dts/lib.esnext.promise.d.ts b/cli/tsc/dts/lib.es2024.promise.d.ts similarity index 100% rename from cli/tsc/dts/lib.esnext.promise.d.ts rename to cli/tsc/dts/lib.es2024.promise.d.ts diff --git a/cli/tsc/dts/lib.esnext.regexp.d.ts b/cli/tsc/dts/lib.es2024.regexp.d.ts similarity index 100% rename from cli/tsc/dts/lib.esnext.regexp.d.ts rename to cli/tsc/dts/lib.es2024.regexp.d.ts diff --git a/cli/tsc/dts/lib.es2022.sharedmemory.d.ts b/cli/tsc/dts/lib.es2024.sharedmemory.d.ts similarity index 67% rename from cli/tsc/dts/lib.es2022.sharedmemory.d.ts rename to cli/tsc/dts/lib.es2024.sharedmemory.d.ts index ea67b0081b..2c3cf94aca 100644 --- a/cli/tsc/dts/lib.es2022.sharedmemory.d.ts +++ b/cli/tsc/dts/lib.es2024.sharedmemory.d.ts @@ -16,6 +16,8 @@ and limitations under the License. /// +/// + interface Atomics { /** * A non-blocking, asynchronous version of wait which is usable on the main thread. @@ -37,3 +39,30 @@ interface Atomics { */ waitAsync(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): { async: false; value: "not-equal" | "timed-out"; } | { async: true; value: Promise<"ok" | "timed-out">; }; } + +interface SharedArrayBuffer { + /** + * Returns true if this SharedArrayBuffer can be grown. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/growable) + */ + get growable(): boolean; + + /** + * If this SharedArrayBuffer is growable, returns the maximum byte length given during construction; returns the byte length if not. + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/maxByteLength) + */ + get maxByteLength(): number; + + /** + * Grows the SharedArrayBuffer to the specified size (in bytes). + * + * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/grow) + */ + grow(newByteLength?: number): void; +} + +interface SharedArrayBufferConstructor { + new (byteLength: number, options?: { maxByteLength?: number; }): SharedArrayBuffer; +} diff --git a/cli/tsc/dts/lib.esnext.string.d.ts b/cli/tsc/dts/lib.es2024.string.d.ts similarity index 100% rename from cli/tsc/dts/lib.esnext.string.d.ts rename to cli/tsc/dts/lib.es2024.string.d.ts diff --git a/cli/tsc/dts/lib.es5.d.ts b/cli/tsc/dts/lib.es5.d.ts index cf9adfe1e0..3e46297889 100644 --- a/cli/tsc/dts/lib.es5.d.ts +++ b/cli/tsc/dts/lib.es5.d.ts @@ -1701,7 +1701,7 @@ interface ArrayBuffer { /** * Returns a section of an ArrayBuffer. */ - slice(begin: number, end?: number): ArrayBuffer; + slice(begin?: number, end?: number): ArrayBuffer; } /** @@ -1719,25 +1719,25 @@ interface ArrayBufferConstructor { } declare var ArrayBuffer: ArrayBufferConstructor; -interface ArrayBufferView { +interface ArrayBufferView { /** * The ArrayBuffer instance referenced by the array. */ - buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. */ - byteLength: number; + readonly byteLength: number; /** * The offset in bytes of the array. */ - byteOffset: number; + readonly byteOffset: number; } -interface DataView { - readonly buffer: ArrayBuffer; +interface DataView { + readonly buffer: TArrayBuffer; readonly byteLength: number; readonly byteOffset: number; /** @@ -1863,10 +1863,9 @@ interface DataView { */ setUint32(byteOffset: number, value: number, littleEndian?: boolean): void; } - interface DataViewConstructor { - readonly prototype: DataView; - new (buffer: ArrayBufferLike & { BYTES_PER_ELEMENT?: never; }, byteOffset?: number, byteLength?: number): DataView; + readonly prototype: DataView; + new (buffer: TArrayBuffer, byteOffset?: number, byteLength?: number): DataView; } declare var DataView: DataViewConstructor; @@ -1874,7 +1873,7 @@ declare var DataView: DataViewConstructor; * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested * number of bytes could not be allocated an exception is raised. */ -interface Int8Array { +interface Int8Array { /** * The size in bytes of each element in the array. */ @@ -1883,7 +1882,7 @@ interface Int8Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -1914,7 +1913,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -1933,7 +1932,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int8Array) => any, thisArg?: any): Int8Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Int8Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -1944,7 +1943,7 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -1955,7 +1954,7 @@ interface Int8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int8Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -1964,7 +1963,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int8Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -2002,7 +2001,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int8Array) => number, thisArg?: any): Int8Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Int8Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2014,8 +2013,8 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2027,7 +2026,7 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2039,8 +2038,8 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2052,12 +2051,12 @@ interface Int8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Int8Array; + reverse(): this; /** * Sets a value or an array of values. @@ -2071,7 +2070,7 @@ interface Int8Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Int8Array; + slice(start?: number, end?: number): Int8Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -2081,7 +2080,7 @@ interface Int8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int8Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2100,7 +2099,7 @@ interface Int8Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Int8Array; + subarray(begin?: number, end?: number): Int8Array; /** * Converts a number to a string by using the current locale. @@ -2113,15 +2112,16 @@ interface Int8Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Int8Array; + valueOf(): this; [index: number]: number; } interface Int8ArrayConstructor { - readonly prototype: Int8Array; - new (length: number): Int8Array; - new (array: ArrayLike | ArrayBufferLike): Int8Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int8Array; + readonly prototype: Int8Array; + new (length: number): Int8Array; + new (array: ArrayLike): Int8Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Int8Array; + new (array: ArrayLike | ArrayBuffer): Int8Array; /** * The size in bytes of each element in the array. @@ -2132,13 +2132,13 @@ interface Int8ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Int8Array; + of(...items: number[]): Int8Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Int8Array; + from(arrayLike: ArrayLike): Int8Array; /** * Creates an array from an array-like or iterable object. @@ -2146,7 +2146,7 @@ interface Int8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int8Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int8Array; } declare var Int8Array: Int8ArrayConstructor; @@ -2154,7 +2154,7 @@ declare var Int8Array: Int8ArrayConstructor; * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ -interface Uint8Array { +interface Uint8Array { /** * The size in bytes of each element in the array. */ @@ -2163,7 +2163,7 @@ interface Uint8Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -2194,7 +2194,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2213,7 +2213,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint8Array) => any, thisArg?: any): Uint8Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Uint8Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2224,7 +2224,7 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2235,7 +2235,7 @@ interface Uint8Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint8Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2244,7 +2244,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint8Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -2282,7 +2282,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Uint8Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Uint8Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2294,8 +2294,8 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2307,7 +2307,7 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2319,8 +2319,8 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2332,12 +2332,12 @@ interface Uint8Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Uint8Array; + reverse(): this; /** * Sets a value or an array of values. @@ -2351,7 +2351,7 @@ interface Uint8Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Uint8Array; + slice(start?: number, end?: number): Uint8Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -2361,7 +2361,7 @@ interface Uint8Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2380,7 +2380,7 @@ interface Uint8Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Uint8Array; + subarray(begin?: number, end?: number): Uint8Array; /** * Converts a number to a string by using the current locale. @@ -2393,16 +2393,16 @@ interface Uint8Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Uint8Array; + valueOf(): this; [index: number]: number; } - interface Uint8ArrayConstructor { - readonly prototype: Uint8Array; - new (length: number): Uint8Array; - new (array: ArrayLike | ArrayBufferLike): Uint8Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8Array; + readonly prototype: Uint8Array; + new (length: number): Uint8Array; + new (array: ArrayLike): Uint8Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Uint8Array; + new (array: ArrayLike | ArrayBuffer): Uint8Array; /** * The size in bytes of each element in the array. @@ -2413,13 +2413,13 @@ interface Uint8ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Uint8Array; + of(...items: number[]): Uint8Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Uint8Array; + from(arrayLike: ArrayLike): Uint8Array; /** * Creates an array from an array-like or iterable object. @@ -2427,7 +2427,7 @@ interface Uint8ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8Array; } declare var Uint8Array: Uint8ArrayConstructor; @@ -2435,7 +2435,7 @@ declare var Uint8Array: Uint8ArrayConstructor; * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. * If the requested number of bytes could not be allocated an exception is raised. */ -interface Uint8ClampedArray { +interface Uint8ClampedArray { /** * The size in bytes of each element in the array. */ @@ -2444,7 +2444,7 @@ interface Uint8ClampedArray { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -2475,7 +2475,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2494,7 +2494,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint8ClampedArray) => any, thisArg?: any): Uint8ClampedArray; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Uint8ClampedArray; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2505,7 +2505,7 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2516,7 +2516,7 @@ interface Uint8ClampedArray { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint8ClampedArray) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2525,7 +2525,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -2563,7 +2563,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => number, thisArg?: any): Uint8ClampedArray; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Uint8ClampedArray; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2575,8 +2575,8 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2588,7 +2588,7 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2600,8 +2600,8 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2613,12 +2613,12 @@ interface Uint8ClampedArray { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Uint8ClampedArray; + reverse(): this; /** * Sets a value or an array of values. @@ -2632,7 +2632,7 @@ interface Uint8ClampedArray { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Uint8ClampedArray; + slice(start?: number, end?: number): Uint8ClampedArray; /** * Determines whether the specified callback function returns true for any element of an array. @@ -2642,7 +2642,7 @@ interface Uint8ClampedArray { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint8ClampedArray) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2661,7 +2661,7 @@ interface Uint8ClampedArray { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Uint8ClampedArray; + subarray(begin?: number, end?: number): Uint8ClampedArray; /** * Converts a number to a string by using the current locale. @@ -2674,16 +2674,16 @@ interface Uint8ClampedArray { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Uint8ClampedArray; + valueOf(): this; [index: number]: number; } - interface Uint8ClampedArrayConstructor { - readonly prototype: Uint8ClampedArray; - new (length: number): Uint8ClampedArray; - new (array: ArrayLike | ArrayBufferLike): Uint8ClampedArray; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint8ClampedArray; + readonly prototype: Uint8ClampedArray; + new (length: number): Uint8ClampedArray; + new (array: ArrayLike): Uint8ClampedArray; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Uint8ClampedArray; + new (array: ArrayLike | ArrayBuffer): Uint8ClampedArray; /** * The size in bytes of each element in the array. @@ -2694,13 +2694,13 @@ interface Uint8ClampedArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Uint8ClampedArray; + of(...items: number[]): Uint8ClampedArray; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Uint8ClampedArray; + from(arrayLike: ArrayLike): Uint8ClampedArray; /** * Creates an array from an array-like or iterable object. @@ -2708,7 +2708,7 @@ interface Uint8ClampedArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray; } declare var Uint8ClampedArray: Uint8ClampedArrayConstructor; @@ -2716,7 +2716,7 @@ declare var Uint8ClampedArray: Uint8ClampedArrayConstructor; * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ -interface Int16Array { +interface Int16Array { /** * The size in bytes of each element in the array. */ @@ -2725,7 +2725,7 @@ interface Int16Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -2756,7 +2756,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -2775,7 +2775,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Int16Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -2786,7 +2786,7 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -2797,7 +2797,7 @@ interface Int16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int16Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -2806,7 +2806,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int16Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. @@ -2843,7 +2843,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int16Array) => number, thisArg?: any): Int16Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Int16Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2855,8 +2855,8 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -2868,7 +2868,7 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2880,8 +2880,8 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -2893,12 +2893,12 @@ interface Int16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Int16Array; + reverse(): this; /** * Sets a value or an array of values. @@ -2912,7 +2912,7 @@ interface Int16Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Int16Array; + slice(start?: number, end?: number): Int16Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -2922,7 +2922,7 @@ interface Int16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int16Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -2941,7 +2941,7 @@ interface Int16Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Int16Array; + subarray(begin?: number, end?: number): Int16Array; /** * Converts a number to a string by using the current locale. @@ -2954,16 +2954,16 @@ interface Int16Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Int16Array; + valueOf(): this; [index: number]: number; } - interface Int16ArrayConstructor { - readonly prototype: Int16Array; - new (length: number): Int16Array; - new (array: ArrayLike | ArrayBufferLike): Int16Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int16Array; + readonly prototype: Int16Array; + new (length: number): Int16Array; + new (array: ArrayLike): Int16Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Int16Array; + new (array: ArrayLike | ArrayBuffer): Int16Array; /** * The size in bytes of each element in the array. @@ -2974,13 +2974,13 @@ interface Int16ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Int16Array; + of(...items: number[]): Int16Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Int16Array; + from(arrayLike: ArrayLike): Int16Array; /** * Creates an array from an array-like or iterable object. @@ -2988,7 +2988,7 @@ interface Int16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int16Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int16Array; } declare var Int16Array: Int16ArrayConstructor; @@ -2996,7 +2996,7 @@ declare var Int16Array: Int16ArrayConstructor; * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ -interface Uint16Array { +interface Uint16Array { /** * The size in bytes of each element in the array. */ @@ -3005,7 +3005,7 @@ interface Uint16Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -3036,7 +3036,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3055,7 +3055,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint16Array) => any, thisArg?: any): Uint16Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Uint16Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3066,7 +3066,7 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3077,7 +3077,7 @@ interface Uint16Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint16Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3086,7 +3086,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint16Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3124,7 +3124,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint16Array) => number, thisArg?: any): Uint16Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Uint16Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3136,8 +3136,8 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3149,7 +3149,7 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3161,8 +3161,8 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3174,12 +3174,12 @@ interface Uint16Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Uint16Array; + reverse(): this; /** * Sets a value or an array of values. @@ -3193,7 +3193,7 @@ interface Uint16Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Uint16Array; + slice(start?: number, end?: number): Uint16Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -3203,7 +3203,7 @@ interface Uint16Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint16Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3222,7 +3222,7 @@ interface Uint16Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Uint16Array; + subarray(begin?: number, end?: number): Uint16Array; /** * Converts a number to a string by using the current locale. @@ -3235,16 +3235,16 @@ interface Uint16Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Uint16Array; + valueOf(): this; [index: number]: number; } - interface Uint16ArrayConstructor { - readonly prototype: Uint16Array; - new (length: number): Uint16Array; - new (array: ArrayLike | ArrayBufferLike): Uint16Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint16Array; + readonly prototype: Uint16Array; + new (length: number): Uint16Array; + new (array: ArrayLike): Uint16Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Uint16Array; + new (array: ArrayLike | ArrayBuffer): Uint16Array; /** * The size in bytes of each element in the array. @@ -3255,13 +3255,13 @@ interface Uint16ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Uint16Array; + of(...items: number[]): Uint16Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Uint16Array; + from(arrayLike: ArrayLike): Uint16Array; /** * Creates an array from an array-like or iterable object. @@ -3269,14 +3269,14 @@ interface Uint16ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint16Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint16Array; } declare var Uint16Array: Uint16ArrayConstructor; /** * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ -interface Int32Array { +interface Int32Array { /** * The size in bytes of each element in the array. */ @@ -3285,7 +3285,7 @@ interface Int32Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -3316,7 +3316,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3335,7 +3335,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Int32Array) => any, thisArg?: any): Int32Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Int32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3346,7 +3346,7 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3357,7 +3357,7 @@ interface Int32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Int32Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3366,7 +3366,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Int32Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3404,7 +3404,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Int32Array) => number, thisArg?: any): Int32Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Int32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3416,8 +3416,8 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3429,7 +3429,7 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3441,8 +3441,8 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3454,12 +3454,12 @@ interface Int32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Int32Array; + reverse(): this; /** * Sets a value or an array of values. @@ -3473,7 +3473,7 @@ interface Int32Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Int32Array; + slice(start?: number, end?: number): Int32Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -3483,7 +3483,7 @@ interface Int32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Int32Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3502,7 +3502,7 @@ interface Int32Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Int32Array; + subarray(begin?: number, end?: number): Int32Array; /** * Converts a number to a string by using the current locale. @@ -3515,16 +3515,16 @@ interface Int32Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Int32Array; + valueOf(): this; [index: number]: number; } - interface Int32ArrayConstructor { - readonly prototype: Int32Array; - new (length: number): Int32Array; - new (array: ArrayLike | ArrayBufferLike): Int32Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Int32Array; + readonly prototype: Int32Array; + new (length: number): Int32Array; + new (array: ArrayLike): Int32Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Int32Array; + new (array: ArrayLike | ArrayBuffer): Int32Array; /** * The size in bytes of each element in the array. @@ -3535,13 +3535,13 @@ interface Int32ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Int32Array; + of(...items: number[]): Int32Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Int32Array; + from(arrayLike: ArrayLike): Int32Array; /** * Creates an array from an array-like or iterable object. @@ -3549,7 +3549,7 @@ interface Int32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int32Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Int32Array; } declare var Int32Array: Int32ArrayConstructor; @@ -3557,7 +3557,7 @@ declare var Int32Array: Int32ArrayConstructor; * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the * requested number of bytes could not be allocated an exception is raised. */ -interface Uint32Array { +interface Uint32Array { /** * The size in bytes of each element in the array. */ @@ -3566,7 +3566,7 @@ interface Uint32Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -3597,7 +3597,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3616,7 +3616,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Uint32Array) => any, thisArg?: any): Uint32Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Uint32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3627,7 +3627,7 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3638,7 +3638,7 @@ interface Uint32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Uint32Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3647,7 +3647,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Uint32Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. * @param searchElement The value to locate in the array. @@ -3684,7 +3684,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Uint32Array) => number, thisArg?: any): Uint32Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Uint32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3696,8 +3696,8 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3709,7 +3709,7 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3721,8 +3721,8 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -3734,12 +3734,12 @@ interface Uint32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Uint32Array; + reverse(): this; /** * Sets a value or an array of values. @@ -3753,7 +3753,7 @@ interface Uint32Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Uint32Array; + slice(start?: number, end?: number): Uint32Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -3763,7 +3763,7 @@ interface Uint32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Uint32Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -3782,7 +3782,7 @@ interface Uint32Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Uint32Array; + subarray(begin?: number, end?: number): Uint32Array; /** * Converts a number to a string by using the current locale. @@ -3795,16 +3795,16 @@ interface Uint32Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Uint32Array; + valueOf(): this; [index: number]: number; } - interface Uint32ArrayConstructor { - readonly prototype: Uint32Array; - new (length: number): Uint32Array; - new (array: ArrayLike | ArrayBufferLike): Uint32Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Uint32Array; + readonly prototype: Uint32Array; + new (length: number): Uint32Array; + new (array: ArrayLike): Uint32Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Uint32Array; + new (array: ArrayLike | ArrayBuffer): Uint32Array; /** * The size in bytes of each element in the array. @@ -3815,13 +3815,13 @@ interface Uint32ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Uint32Array; + of(...items: number[]): Uint32Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Uint32Array; + from(arrayLike: ArrayLike): Uint32Array; /** * Creates an array from an array-like or iterable object. @@ -3829,7 +3829,7 @@ interface Uint32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint32Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Uint32Array; } declare var Uint32Array: Uint32ArrayConstructor; @@ -3837,7 +3837,7 @@ declare var Uint32Array: Uint32ArrayConstructor; * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number * of bytes could not be allocated an exception is raised. */ -interface Float32Array { +interface Float32Array { /** * The size in bytes of each element in the array. */ @@ -3846,7 +3846,7 @@ interface Float32Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -3877,7 +3877,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -3896,7 +3896,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Float32Array) => any, thisArg?: any): Float32Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Float32Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -3907,7 +3907,7 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -3918,7 +3918,7 @@ interface Float32Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Float32Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -3927,7 +3927,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Float32Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -3965,7 +3965,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Float32Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3977,8 +3977,8 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -3990,7 +3990,7 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4002,8 +4002,8 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4015,12 +4015,12 @@ interface Float32Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Float32Array; + reverse(): this; /** * Sets a value or an array of values. @@ -4034,7 +4034,7 @@ interface Float32Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Float32Array; + slice(start?: number, end?: number): Float32Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -4044,7 +4044,7 @@ interface Float32Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Float32Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -4063,7 +4063,7 @@ interface Float32Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Float32Array; + subarray(begin?: number, end?: number): Float32Array; /** * Converts a number to a string by using the current locale. @@ -4076,16 +4076,16 @@ interface Float32Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Float32Array; + valueOf(): this; [index: number]: number; } - interface Float32ArrayConstructor { - readonly prototype: Float32Array; - new (length: number): Float32Array; - new (array: ArrayLike | ArrayBufferLike): Float32Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float32Array; + readonly prototype: Float32Array; + new (length: number): Float32Array; + new (array: ArrayLike): Float32Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Float32Array; + new (array: ArrayLike | ArrayBuffer): Float32Array; /** * The size in bytes of each element in the array. @@ -4096,13 +4096,13 @@ interface Float32ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Float32Array; + of(...items: number[]): Float32Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Float32Array; + from(arrayLike: ArrayLike): Float32Array; /** * Creates an array from an array-like or iterable object. @@ -4110,7 +4110,7 @@ interface Float32ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float32Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float32Array; } declare var Float32Array: Float32ArrayConstructor; @@ -4118,7 +4118,7 @@ declare var Float32Array: Float32ArrayConstructor; * A typed array of 64-bit float values. The contents are initialized to 0. If the requested * number of bytes could not be allocated an exception is raised. */ -interface Float64Array { +interface Float64Array { /** * The size in bytes of each element in the array. */ @@ -4127,7 +4127,7 @@ interface Float64Array { /** * The ArrayBuffer instance referenced by the array. */ - readonly buffer: ArrayBufferLike; + readonly buffer: TArrayBuffer; /** * The length in bytes of the array. @@ -4158,7 +4158,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - every(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; + every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array @@ -4177,7 +4177,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - filter(predicate: (value: number, index: number, array: Float64Array) => any, thisArg?: any): Float64Array; + filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Float64Array; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -4188,7 +4188,7 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - find(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number | undefined; + find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined; /** * Returns the index of the first element in the array where predicate is true, and -1 @@ -4199,7 +4199,7 @@ interface Float64Array { * @param thisArg If provided, it will be used as the this value for each invocation of * predicate. If it is not provided, undefined is used instead. */ - findIndex(predicate: (value: number, index: number, obj: Float64Array) => boolean, thisArg?: any): number; + findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number; /** * Performs the specified action for each element in an array. @@ -4208,7 +4208,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - forEach(callbackfn: (value: number, index: number, array: Float64Array) => void, thisArg?: any): void; + forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void; /** * Returns the index of the first occurrence of a value in an array. @@ -4246,7 +4246,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the callbackfn function. * If thisArg is omitted, undefined is used as the this value. */ - map(callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array; + map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Float64Array; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -4258,8 +4258,8 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; - reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array. The return value of @@ -4271,7 +4271,7 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; + reduce(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4283,8 +4283,8 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an * argument instead of an array value. */ - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number; - reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number): number; + reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue: number): number; /** * Calls the specified callback function for all the elements in an array, in descending order. @@ -4296,12 +4296,12 @@ interface Float64Array { * the accumulation. The first call to the callbackfn function provides this value as an argument * instead of an array value. */ - reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U; + reduceRight(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U; /** * Reverses the elements in an Array. */ - reverse(): Float64Array; + reverse(): this; /** * Sets a value or an array of values. @@ -4315,7 +4315,7 @@ interface Float64Array { * @param start The beginning of the specified portion of the array. * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'. */ - slice(start?: number, end?: number): Float64Array; + slice(start?: number, end?: number): Float64Array; /** * Determines whether the specified callback function returns true for any element of an array. @@ -4325,7 +4325,7 @@ interface Float64Array { * @param thisArg An object to which the this keyword can refer in the predicate function. * If thisArg is omitted, undefined is used as the this value. */ - some(predicate: (value: number, index: number, array: Float64Array) => unknown, thisArg?: any): boolean; + some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean; /** * Sorts an array. @@ -4344,7 +4344,7 @@ interface Float64Array { * @param begin The index of the beginning of the array. * @param end The index of the end of the array. */ - subarray(begin?: number, end?: number): Float64Array; + subarray(begin?: number, end?: number): Float64Array; /** * Converts a number to a string by using the current locale. @@ -4357,16 +4357,16 @@ interface Float64Array { toString(): string; /** Returns the primitive value of the specified object. */ - valueOf(): Float64Array; + valueOf(): this; [index: number]: number; } - interface Float64ArrayConstructor { - readonly prototype: Float64Array; - new (length: number): Float64Array; - new (array: ArrayLike | ArrayBufferLike): Float64Array; - new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): Float64Array; + readonly prototype: Float64Array; + new (length: number): Float64Array; + new (array: ArrayLike): Float64Array; + new (buffer: TArrayBuffer, byteOffset?: number, length?: number): Float64Array; + new (array: ArrayLike | ArrayBuffer): Float64Array; /** * The size in bytes of each element in the array. @@ -4377,13 +4377,13 @@ interface Float64ArrayConstructor { * Returns a new array from a set of elements. * @param items A set of elements to include in the new array object. */ - of(...items: number[]): Float64Array; + of(...items: number[]): Float64Array; /** * Creates an array from an array-like or iterable object. * @param arrayLike An array-like or iterable object to convert to an array. */ - from(arrayLike: ArrayLike): Float64Array; + from(arrayLike: ArrayLike): Float64Array; /** * Creates an array from an array-like or iterable object. @@ -4391,7 +4391,7 @@ interface Float64ArrayConstructor { * @param mapfn A mapping function to call on every element of the array. * @param thisArg Value of 'this' used to invoke the mapfn. */ - from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float64Array; + from(arrayLike: ArrayLike, mapfn: (v: T, k: number) => number, thisArg?: any): Float64Array; } declare var Float64Array: Float64ArrayConstructor; diff --git a/cli/tsc/dts/lib.esnext.array.d.ts b/cli/tsc/dts/lib.esnext.array.d.ts index 39efbba0dd..44df229536 100644 --- a/cli/tsc/dts/lib.esnext.array.d.ts +++ b/cli/tsc/dts/lib.esnext.array.d.ts @@ -31,5 +31,5 @@ interface ArrayConstructor { * Each return value is awaited before being added to result array. * @param thisArg Value of 'this' used when executing mapfn. */ - fromAsync(iterableOrArrayLike: AsyncIterable | Iterable | ArrayLike, mapFn: (value: Awaited) => U, thisArg?: any): Promise[]>; + fromAsync(iterableOrArrayLike: AsyncIterable | Iterable | ArrayLike, mapFn: (value: Awaited, index: number) => U, thisArg?: any): Promise[]>; } diff --git a/cli/tsc/dts/lib.esnext.collection.d.ts b/cli/tsc/dts/lib.esnext.collection.d.ts index 1278a38f67..46b0b08951 100644 --- a/cli/tsc/dts/lib.esnext.collection.d.ts +++ b/cli/tsc/dts/lib.esnext.collection.d.ts @@ -16,17 +16,7 @@ and limitations under the License. /// -interface MapConstructor { - /** - * Groups members of an iterable according to the return value of the passed callback. - * @param items An iterable. - * @param keySelector A callback which will be invoked for each item in items. - */ - groupBy( - items: Iterable, - keySelector: (item: T, index: number) => K, - ): Map; -} +/// interface ReadonlySetLike { /** diff --git a/cli/tsc/dts/lib.esnext.d.ts b/cli/tsc/dts/lib.esnext.d.ts index e0217b6c60..37b5ea5ed6 100644 --- a/cli/tsc/dts/lib.esnext.d.ts +++ b/cli/tsc/dts/lib.esnext.d.ts @@ -16,14 +16,10 @@ and limitations under the License. /// -/// +/// /// /// /// -/// -/// /// /// -/// -/// /// diff --git a/cli/tsc/dts/lib.webworker.d.ts b/cli/tsc/dts/lib.webworker.d.ts index f0c5b32000..c7ee571c64 100644 --- a/cli/tsc/dts/lib.webworker.d.ts +++ b/cli/tsc/dts/lib.webworker.d.ts @@ -65,6 +65,59 @@ interface AudioConfiguration { spatialRendering?: boolean; } +interface AudioDataCopyToOptions { + format?: AudioSampleFormat; + frameCount?: number; + frameOffset?: number; + planeIndex: number; +} + +interface AudioDataInit { + data: BufferSource; + format: AudioSampleFormat; + numberOfChannels: number; + numberOfFrames: number; + sampleRate: number; + timestamp: number; + transfer?: ArrayBuffer[]; +} + +interface AudioDecoderConfig { + codec: string; + description?: BufferSource; + numberOfChannels: number; + sampleRate: number; +} + +interface AudioDecoderInit { + error: WebCodecsErrorCallback; + output: AudioDataOutputCallback; +} + +interface AudioDecoderSupport { + config?: AudioDecoderConfig; + supported?: boolean; +} + +interface AudioEncoderConfig { + bitrate?: number; + bitrateMode?: BitrateMode; + codec: string; + numberOfChannels: number; + opus?: OpusEncoderConfig; + sampleRate: number; +} + +interface AudioEncoderInit { + error: WebCodecsErrorCallback; + output: EncodedAudioChunkOutputCallback; +} + +interface AudioEncoderSupport { + config?: AudioEncoderConfig; + supported?: boolean; +} + interface AvcEncoderConfig { format?: AvcBitstreamFormat; } @@ -181,6 +234,18 @@ interface EcdsaParams extends Algorithm { hash: HashAlgorithmIdentifier; } +interface EncodedAudioChunkInit { + data: AllowSharedBufferSource; + duration?: number; + timestamp: number; + transfer?: ArrayBuffer[]; + type: EncodedAudioChunkType; +} + +interface EncodedAudioChunkMetadata { + decoderConfig?: AudioDecoderConfig; +} + interface EncodedVideoChunkInit { data: AllowSharedBufferSource; duration?: number; @@ -448,6 +513,15 @@ interface NotificationOptions { tag?: string; } +interface OpusEncoderConfig { + complexity?: number; + format?: OpusBitstreamFormat; + frameDuration?: number; + packetlossperc?: number; + usedtx?: boolean; + useinbandfec?: boolean; +} + interface Pbkdf2Params extends Algorithm { hash: HashAlgorithmIdentifier; iterations: number; @@ -768,6 +842,7 @@ interface VideoConfiguration { colorGamut?: ColorGamut; contentType: string; framerate: number; + hasAlphaChannel?: boolean; hdrMetadataType?: HdrMetadataType; height: number; scalabilityMode?: string; @@ -803,6 +878,7 @@ interface VideoEncoderConfig { bitrate?: number; bitrateMode?: VideoEncoderBitrateMode; codec: string; + contentHint?: string; displayHeight?: number; displayWidth?: number; framerate?: number; @@ -814,9 +890,14 @@ interface VideoEncoderConfig { } interface VideoEncoderEncodeOptions { + avc?: VideoEncoderEncodeOptionsForAvc; keyFrame?: boolean; } +interface VideoEncoderEncodeOptionsForAvc { + quantizer?: number | null; +} + interface VideoEncoderInit { error: WebCodecsErrorCallback; output: EncodedVideoChunkOutputCallback; @@ -841,6 +922,8 @@ interface VideoFrameBufferInit { } interface VideoFrameCopyToOptions { + colorSpace?: PredefinedColorSpace; + format?: VideoPixelFormat; layout?: PlaneLayout[]; rect?: DOMRectInit; } @@ -1008,6 +1091,113 @@ interface AnimationFrameProvider { requestAnimationFrame(callback: FrameRequestCallback): number; } +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData) */ +interface AudioData { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/duration) */ + readonly duration: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/format) */ + readonly format: AudioSampleFormat | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfChannels) */ + readonly numberOfChannels: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/numberOfFrames) */ + readonly numberOfFrames: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/sampleRate) */ + readonly sampleRate: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/timestamp) */ + readonly timestamp: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/allocationSize) */ + allocationSize(options: AudioDataCopyToOptions): number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/clone) */ + clone(): AudioData; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioData/copyTo) */ + copyTo(destination: AllowSharedBufferSource, options: AudioDataCopyToOptions): void; +} + +declare var AudioData: { + prototype: AudioData; + new(init: AudioDataInit): AudioData; +}; + +interface AudioDecoderEventMap { + "dequeue": Event; +} + +/** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder) + */ +interface AudioDecoder extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decodeQueueSize) */ + readonly decodeQueueSize: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/dequeue_event) */ + ondequeue: ((this: AudioDecoder, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/state) */ + readonly state: CodecState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/configure) */ + configure(config: AudioDecoderConfig): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/decode) */ + decode(chunk: EncodedAudioChunk): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/flush) */ + flush(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/reset) */ + reset(): void; + addEventListener(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioDecoder, ev: AudioDecoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioDecoder: { + prototype: AudioDecoder; + new(init: AudioDecoderInit): AudioDecoder; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioDecoder/isConfigSupported_static) */ + isConfigSupported(config: AudioDecoderConfig): Promise; +}; + +interface AudioEncoderEventMap { + "dequeue": Event; +} + +/** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder) + */ +interface AudioEncoder extends EventTarget { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encodeQueueSize) */ + readonly encodeQueueSize: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/dequeue_event) */ + ondequeue: ((this: AudioEncoder, ev: Event) => any) | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/state) */ + readonly state: CodecState; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/close) */ + close(): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/configure) */ + configure(config: AudioEncoderConfig): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/encode) */ + encode(data: AudioData): void; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/flush) */ + flush(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/reset) */ + reset(): void; + addEventListener(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void; + addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void; + removeEventListener(type: K, listener: (this: AudioEncoder, ev: AudioEncoderEventMap[K]) => any, options?: boolean | EventListenerOptions): void; + removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void; +} + +declare var AudioEncoder: { + prototype: AudioEncoder; + new(init: AudioEncoderInit): AudioEncoder; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AudioEncoder/isConfigSupported_static) */ + isConfigSupported(config: AudioEncoderConfig): Promise; +}; + /** * A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. * @@ -1809,6 +1999,8 @@ declare var CloseEvent: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream) */ interface CompressionStream extends GenericTransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; } declare var CompressionStream: { @@ -1978,27 +2170,49 @@ declare var DOMException: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix) */ interface DOMMatrix extends DOMMatrixReadOnly { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ a: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ b: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ c: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ d: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ e: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ f: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m11: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m12: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m13: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m14: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m21: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m22: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m23: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m24: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m31: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m32: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m33: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m34: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m41: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m42: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m43: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrix#instance_properties) */ m44: number; invertSelf(): DOMMatrix; multiplySelf(other?: DOMMatrixInit): DOMMatrix; @@ -2023,29 +2237,51 @@ declare var DOMMatrix: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly) */ interface DOMMatrixReadOnly { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly a: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly b: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly c: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly d: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly e: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly f: number; readonly is2D: boolean; readonly isIdentity: boolean; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m11: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m12: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m13: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m14: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m21: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m22: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m23: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m24: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m31: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m32: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m33: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m34: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m41: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m42: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m43: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly#instance_properties) */ readonly m44: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMMatrixReadOnly/flipX) */ flipX(): DOMMatrix; @@ -2213,6 +2449,8 @@ declare var DOMStringList: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DecompressionStream) */ interface DecompressionStream extends GenericTransformStream { + readonly readable: ReadableStream; + readonly writable: WritableStream; } declare var DecompressionStream: { @@ -2223,7 +2461,7 @@ declare var DecompressionStream: { interface DedicatedWorkerGlobalScopeEventMap extends WorkerGlobalScopeEventMap { "message": MessageEvent; "messageerror": MessageEvent; - "rtctransform": Event; + "rtctransform": RTCTransformEvent; } /** @@ -2243,7 +2481,7 @@ interface DedicatedWorkerGlobalScope extends WorkerGlobalScope, AnimationFramePr /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */ onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/rtctransform_event) */ - onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null; + onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: RTCTransformEvent) => any) | null; /** * Aborts dedicatedWorkerGlobal. * @@ -2348,6 +2586,25 @@ interface EXT_texture_norm16 { readonly RGBA16_SNORM_EXT: 0x8F9B; } +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk) */ +interface EncodedAudioChunk { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/byteLength) */ + readonly byteLength: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/duration) */ + readonly duration: number | null; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/timestamp) */ + readonly timestamp: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/type) */ + readonly type: EncodedAudioChunkType; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedAudioChunk/copyTo) */ + copyTo(destination: AllowSharedBufferSource): void; +} + +declare var EncodedAudioChunk: { + prototype: EncodedAudioChunk; + new(init: EncodedAudioChunkInit): EncodedAudioChunk; +}; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk) */ interface EncodedVideoChunk { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EncodedVideoChunk/byteLength) */ @@ -2948,23 +3205,23 @@ interface FontFace { declare var FontFace: { prototype: FontFace; - new(family: string, source: string | BinaryData, descriptors?: FontFaceDescriptors): FontFace; + new(family: string, source: string | BufferSource, descriptors?: FontFaceDescriptors): FontFace; }; interface FontFaceSetEventMap { - "loading": Event; - "loadingdone": Event; - "loadingerror": Event; + "loading": FontFaceSetLoadEvent; + "loadingdone": FontFaceSetLoadEvent; + "loadingerror": FontFaceSetLoadEvent; } /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet) */ interface FontFaceSet extends EventTarget { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loading_event) */ - onloading: ((this: FontFaceSet, ev: Event) => any) | null; + onloading: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingdone_event) */ - onloadingdone: ((this: FontFaceSet, ev: Event) => any) | null; + onloadingdone: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/loadingerror_event) */ - onloadingerror: ((this: FontFaceSet, ev: Event) => any) | null; + onloadingerror: ((this: FontFaceSet, ev: FontFaceSetLoadEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/ready) */ readonly ready: Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSet/status) */ @@ -2982,7 +3239,7 @@ interface FontFaceSet extends EventTarget { declare var FontFaceSet: { prototype: FontFaceSet; - new(initialFaces: FontFace[]): FontFaceSet; + new(): FontFaceSet; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FontFaceSetLoadEvent) */ @@ -3693,7 +3950,7 @@ interface IDBTransaction extends EventTarget { /** * Returns a list of the names of object stores in the transaction's scope. For an upgrade transaction this is all object stores in the database. * - * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/ObjectStoreNames) + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/objectStoreNames) */ readonly objectStoreNames: DOMStringList; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/IDBTransaction/abort_event) */ @@ -4258,7 +4515,7 @@ interface OES_vertex_array_object { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/bindVertexArrayOES) */ bindVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/createVertexArrayOES) */ - createVertexArrayOES(): WebGLVertexArrayObjectOES | null; + createVertexArrayOES(): WebGLVertexArrayObjectOES; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/deleteVertexArrayOES) */ deleteVertexArrayOES(arrayObject: WebGLVertexArrayObjectOES | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OES_vertex_array_object/isVertexArrayOES) */ @@ -4344,6 +4601,7 @@ declare var OffscreenCanvas: { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/OffscreenCanvasRenderingContext2D) */ interface OffscreenCanvasRenderingContext2D extends CanvasCompositing, CanvasDrawImage, CanvasDrawPath, CanvasFillStrokeStyles, CanvasFilters, CanvasImageData, CanvasImageSmoothing, CanvasPath, CanvasPathDrawingStyles, CanvasRect, CanvasShadowStyles, CanvasState, CanvasText, CanvasTextDrawingStyles, CanvasTransform { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/canvas) */ readonly canvas: OffscreenCanvas; } @@ -4537,6 +4795,8 @@ interface PerformanceResourceTiming extends PerformanceEntry { readonly responseEnd: DOMHighResTimeStamp; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStart) */ readonly responseStart: DOMHighResTimeStamp; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/responseStatus) */ + readonly responseStatus: number; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/secureConnectionStart) */ readonly secureConnectionStart: DOMHighResTimeStamp; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PerformanceResourceTiming/serverTiming) */ @@ -4687,6 +4947,8 @@ interface PushMessageData { arrayBuffer(): ArrayBuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/blob) */ blob(): Blob; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/bytes) */ + bytes(): Uint8Array; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/json) */ json(): any; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PushMessageData/text) */ @@ -4849,6 +5111,7 @@ declare var ReadableStream: { new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream; new(underlyingSource: UnderlyingDefaultSource, strategy?: QueuingStrategy): ReadableStream; new(underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; + from(asyncIterable: AsyncIterable | Iterable>): ReadableStream; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */ @@ -4861,7 +5124,7 @@ interface ReadableStreamBYOBReader extends ReadableStreamGenericReader { declare var ReadableStreamBYOBReader: { prototype: ReadableStreamBYOBReader; - new(stream: ReadableStream): ReadableStreamBYOBReader; + new(stream: ReadableStream): ReadableStreamBYOBReader; }; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */ @@ -5363,7 +5626,7 @@ declare var StylePropertyMapReadOnly: { }; /** - * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via globalThis.crypto). + * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). * Available only in secure contexts. * * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto) @@ -5372,7 +5635,7 @@ interface SubtleCrypto { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt) */ decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey, data: BufferSource): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits) */ - deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length: number): Promise; + deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, length?: number | null): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */ deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: KeyUsage[]): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest) */ @@ -6641,13 +6904,13 @@ interface WebGL2RenderingContextBase { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/copyTexSubImage3D) */ copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createQuery) */ - createQuery(): WebGLQuery | null; + createQuery(): WebGLQuery; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createSampler) */ - createSampler(): WebGLSampler | null; + createSampler(): WebGLSampler; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createTransformFeedback) */ - createTransformFeedback(): WebGLTransformFeedback | null; + createTransformFeedback(): WebGLTransformFeedback; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/createVertexArray) */ - createVertexArray(): WebGLVertexArrayObject | null; + createVertexArray(): WebGLVertexArrayObject; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteQuery) */ deleteQuery(query: WebGLQuery | null): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGL2RenderingContext/deleteSampler) */ @@ -7560,17 +7823,17 @@ interface WebGLRenderingContextBase { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/copyTexSubImage2D) */ copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createBuffer) */ - createBuffer(): WebGLBuffer | null; + createBuffer(): WebGLBuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createFramebuffer) */ - createFramebuffer(): WebGLFramebuffer | null; + createFramebuffer(): WebGLFramebuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createProgram) */ - createProgram(): WebGLProgram | null; + createProgram(): WebGLProgram; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createRenderbuffer) */ - createRenderbuffer(): WebGLRenderbuffer | null; + createRenderbuffer(): WebGLRenderbuffer; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createShader) */ createShader(type: GLenum): WebGLShader | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/createTexture) */ - createTexture(): WebGLTexture | null; + createTexture(): WebGLTexture; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/cullFace) */ cullFace(mode: GLenum): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebGLRenderingContext/deleteBuffer) */ @@ -8458,7 +8721,7 @@ interface WindowOrWorkerGlobalScope { /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */ createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise; createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */ fetch(input: RequestInfo | URL, init?: RequestInit): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */ queueMicrotask(callback: VoidFunction): void; @@ -8882,7 +9145,7 @@ interface Console { clear(): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */ count(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countreset_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */ countReset(label?: string): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */ debug(...data: any[]): void; @@ -8894,9 +9157,9 @@ interface Console { error(...data: any[]): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */ group(...data: any[]): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupcollapsed_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */ groupCollapsed(...data: any[]): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupend_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */ groupEnd(): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */ info(...data: any[]): void; @@ -8906,9 +9169,9 @@ interface Console { table(tabularData?: any, properties?: string[]): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */ time(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeend_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */ timeEnd(label?: string): void; - /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timelog_static) */ + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */ timeLog(label?: string, ...data: any[]): void; timeStamp(label?: string): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */ @@ -9078,6 +9341,14 @@ declare namespace WebAssembly { function validate(bytes: BufferSource): boolean; } +interface AudioDataOutputCallback { + (output: AudioData): void; +} + +interface EncodedAudioChunkOutputCallback { + (output: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void; +} + interface EncodedVideoChunkOutputCallback { (chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void; } @@ -9169,7 +9440,7 @@ declare var onmessage: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/messageerror_event) */ declare var onmessageerror: ((this: DedicatedWorkerGlobalScope, ev: MessageEvent) => any) | null; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/rtctransform_event) */ -declare var onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: Event) => any) | null; +declare var onrtctransform: ((this: DedicatedWorkerGlobalScope, ev: RTCTransformEvent) => any) | null; /** * Aborts dedicatedWorkerGlobal. * @@ -9262,7 +9533,7 @@ declare function clearTimeout(id: number | undefined): void; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/createImageBitmap) */ declare function createImageBitmap(image: ImageBitmapSource, options?: ImageBitmapOptions): Promise; declare function createImageBitmap(image: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options?: ImageBitmapOptions): Promise; -/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */ +/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */ declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise; /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */ declare function queueMicrotask(callback: VoidFunction): void; @@ -9285,7 +9556,6 @@ declare function removeEventListener(type: string, listener: EventListenerOrEven type AlgorithmIdentifier = Algorithm | string; type AllowSharedBufferSource = ArrayBuffer | ArrayBufferView; type BigInteger = Uint8Array; -type BinaryData = ArrayBuffer | ArrayBufferView; type BlobPart = BufferSource | Blob | string; type BodyInit = ReadableStream | XMLHttpRequestBodyInit; type BufferSource = ArrayBufferView | ArrayBuffer; @@ -9330,12 +9600,14 @@ type ReportList = Report[]; type RequestInfo = Request | string; type TexImageSource = ImageBitmap | ImageData | OffscreenCanvas | VideoFrame; type TimerHandler = string | Function; -type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | MediaSourceHandle | ReadableStream | WritableStream | TransformStream | VideoFrame | ArrayBuffer; +type Transferable = OffscreenCanvas | ImageBitmap | MessagePort | MediaSourceHandle | ReadableStream | WritableStream | TransformStream | AudioData | VideoFrame | ArrayBuffer; type Uint32List = Uint32Array | GLuint[]; type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string; type AlphaOption = "discard" | "keep"; +type AudioSampleFormat = "f32" | "f32-planar" | "s16" | "s16-planar" | "s32" | "s32-planar" | "u8" | "u8-planar"; type AvcBitstreamFormat = "annexb" | "avc"; type BinaryType = "arraybuffer" | "blob"; +type BitrateMode = "constant" | "variable"; type CSSMathOperator = "clamp" | "invert" | "max" | "min" | "negate" | "product" | "sum"; type CSSNumericBaseType = "angle" | "flex" | "frequency" | "length" | "percent" | "resolution" | "time"; type CanvasDirection = "inherit" | "ltr" | "rtl"; @@ -9354,6 +9626,7 @@ type ColorGamut = "p3" | "rec2020" | "srgb"; type ColorSpaceConversion = "default" | "none"; type CompressionFormat = "deflate" | "deflate-raw" | "gzip"; type DocumentVisibilityState = "hidden" | "visible"; +type EncodedAudioChunkType = "delta" | "key"; type EncodedVideoChunkType = "delta" | "key"; type EndingType = "native" | "transparent"; type FileSystemHandleKind = "directory" | "file"; @@ -9380,7 +9653,8 @@ type MediaEncodingType = "record" | "webrtc"; type NotificationDirection = "auto" | "ltr" | "rtl"; type NotificationPermission = "default" | "denied" | "granted"; type OffscreenRenderingContextId = "2d" | "bitmaprenderer" | "webgl" | "webgl2" | "webgpu"; -type PermissionName = "geolocation" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "xr-spatial-tracking"; +type OpusBitstreamFormat = "ogg" | "opus"; +type PermissionName = "geolocation" | "midi" | "notifications" | "persistent-storage" | "push" | "screen-wake-lock" | "storage-access"; type PermissionState = "denied" | "granted" | "prompt"; type PredefinedColorSpace = "display-p3" | "srgb"; type PremultiplyAlpha = "default" | "none" | "premultiply"; diff --git a/cli/tsc/dts/typescript.d.ts b/cli/tsc/dts/typescript.d.ts index 5326c98dd0..f1c59cdd6c 100644 --- a/cli/tsc/dts/typescript.d.ts +++ b/cli/tsc/dts/typescript.d.ts @@ -14,2551 +14,39 @@ and limitations under the License. ***************************************************************************** */ declare namespace ts { + namespace deno { + function setIsNodeSourceFileCallback(callback: IsNodeSourceFileCallback): void; + function setNodeOnlyGlobalNames(names: Set): void; + function setTypesNodeIgnorableNames(names: Set): void; + function createDenoForkContext({ mergeSymbol, globals, nodeGlobals }: { + mergeSymbol(target: ts.Symbol, source: ts.Symbol, unidirectional?: boolean): ts.Symbol; + globals: ts.SymbolTable; + nodeGlobals: ts.SymbolTable; + }): DenoForkContext; + function tryParseNpmPackageReference(text: string): NpmPackageReference | undefined; + function parseNpmPackageReference(text: string): NpmPackageReference; + type IsNodeSourceFileCallback = (sourceFile: ts.SourceFile) => boolean; + interface DenoForkContext { + hasNodeSourceFile: (node: ts.Node | undefined) => boolean; + getGlobalsForName: (id: ts.__String) => ts.SymbolTable; + mergeGlobalSymbolTable: (node: ts.Node, source: ts.SymbolTable, unidirectional?: boolean) => void; + combinedGlobals: ts.SymbolTable; + } + interface NpmPackageReference { + name: string; + versionReq: string | undefined; + subPath: string | undefined; + } + } + namespace JsTyping { + interface TypingResolutionHost { + directoryExists(path: string): boolean; + fileExists(fileName: string): boolean; + readFile(path: string, encoding?: string): string | undefined; + readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[] | undefined, depth?: number): string[]; + } + } namespace server { - namespace protocol { - export import ApplicableRefactorInfo = ts.ApplicableRefactorInfo; - export import ClassificationType = ts.ClassificationType; - export import CompletionsTriggerCharacter = ts.CompletionsTriggerCharacter; - export import CompletionTriggerKind = ts.CompletionTriggerKind; - export import InlayHintKind = ts.InlayHintKind; - export import OrganizeImportsMode = ts.OrganizeImportsMode; - export import RefactorActionInfo = ts.RefactorActionInfo; - export import RefactorTriggerReason = ts.RefactorTriggerReason; - export import RenameInfoFailure = ts.RenameInfoFailure; - export import SemicolonPreference = ts.SemicolonPreference; - export import SignatureHelpCharacterTypedReason = ts.SignatureHelpCharacterTypedReason; - export import SignatureHelpInvokedReason = ts.SignatureHelpInvokedReason; - export import SignatureHelpParameter = ts.SignatureHelpParameter; - export import SignatureHelpRetriggerCharacter = ts.SignatureHelpRetriggerCharacter; - export import SignatureHelpRetriggeredReason = ts.SignatureHelpRetriggeredReason; - export import SignatureHelpTriggerCharacter = ts.SignatureHelpTriggerCharacter; - export import SignatureHelpTriggerReason = ts.SignatureHelpTriggerReason; - export import SymbolDisplayPart = ts.SymbolDisplayPart; - export import UserPreferences = ts.UserPreferences; - type ChangePropertyTypes< - T, - Substitutions extends { - [K in keyof T]?: any; - }, - > = { - [K in keyof T]: K extends keyof Substitutions ? Substitutions[K] : T[K]; - }; - type ChangeStringIndexSignature = { - [K in keyof T]: string extends K ? NewStringIndexSignatureType : T[K]; - }; - export enum CommandTypes { - JsxClosingTag = "jsxClosingTag", - LinkedEditingRange = "linkedEditingRange", - Brace = "brace", - BraceCompletion = "braceCompletion", - GetSpanOfEnclosingComment = "getSpanOfEnclosingComment", - Change = "change", - Close = "close", - /** @deprecated Prefer CompletionInfo -- see comment on CompletionsResponse */ - Completions = "completions", - CompletionInfo = "completionInfo", - CompletionDetails = "completionEntryDetails", - CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList", - CompileOnSaveEmitFile = "compileOnSaveEmitFile", - Configure = "configure", - Definition = "definition", - DefinitionAndBoundSpan = "definitionAndBoundSpan", - Implementation = "implementation", - Exit = "exit", - FileReferences = "fileReferences", - Format = "format", - Formatonkey = "formatonkey", - Geterr = "geterr", - GeterrForProject = "geterrForProject", - SemanticDiagnosticsSync = "semanticDiagnosticsSync", - SyntacticDiagnosticsSync = "syntacticDiagnosticsSync", - SuggestionDiagnosticsSync = "suggestionDiagnosticsSync", - NavBar = "navbar", - Navto = "navto", - NavTree = "navtree", - NavTreeFull = "navtree-full", - DocumentHighlights = "documentHighlights", - Open = "open", - Quickinfo = "quickinfo", - References = "references", - Reload = "reload", - Rename = "rename", - Saveto = "saveto", - SignatureHelp = "signatureHelp", - FindSourceDefinition = "findSourceDefinition", - Status = "status", - TypeDefinition = "typeDefinition", - ProjectInfo = "projectInfo", - ReloadProjects = "reloadProjects", - Unknown = "unknown", - OpenExternalProject = "openExternalProject", - OpenExternalProjects = "openExternalProjects", - CloseExternalProject = "closeExternalProject", - UpdateOpen = "updateOpen", - GetOutliningSpans = "getOutliningSpans", - TodoComments = "todoComments", - Indentation = "indentation", - DocCommentTemplate = "docCommentTemplate", - CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects", - GetCodeFixes = "getCodeFixes", - GetCombinedCodeFix = "getCombinedCodeFix", - ApplyCodeActionCommand = "applyCodeActionCommand", - GetSupportedCodeFixes = "getSupportedCodeFixes", - GetApplicableRefactors = "getApplicableRefactors", - GetEditsForRefactor = "getEditsForRefactor", - GetMoveToRefactoringFileSuggestions = "getMoveToRefactoringFileSuggestions", - GetPasteEdits = "getPasteEdits", - OrganizeImports = "organizeImports", - GetEditsForFileRename = "getEditsForFileRename", - ConfigurePlugin = "configurePlugin", - SelectionRange = "selectionRange", - ToggleLineComment = "toggleLineComment", - ToggleMultilineComment = "toggleMultilineComment", - CommentSelection = "commentSelection", - UncommentSelection = "uncommentSelection", - PrepareCallHierarchy = "prepareCallHierarchy", - ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls", - ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls", - ProvideInlayHints = "provideInlayHints", - WatchChange = "watchChange", - MapCode = "mapCode", - } - /** - * A TypeScript Server message - */ - export interface Message { - /** - * Sequence number of the message - */ - seq: number; - /** - * One of "request", "response", or "event" - */ - type: "request" | "response" | "event"; - } - /** - * Client-initiated request message - */ - export interface Request extends Message { - type: "request"; - /** - * The command to execute - */ - command: string; - /** - * Object containing arguments for the command - */ - arguments?: any; - } - /** - * Request to reload the project structure for all the opened files - */ - export interface ReloadProjectsRequest extends Request { - command: CommandTypes.ReloadProjects; - } - /** - * Server-initiated event message - */ - export interface Event extends Message { - type: "event"; - /** - * Name of event - */ - event: string; - /** - * Event-specific information - */ - body?: any; - } - /** - * Response by server to client request message. - */ - export interface Response extends Message { - type: "response"; - /** - * Sequence number of the request message. - */ - request_seq: number; - /** - * Outcome of the request. - */ - success: boolean; - /** - * The command requested. - */ - command: string; - /** - * If success === false, this should always be provided. - * Otherwise, may (or may not) contain a success message. - */ - message?: string; - /** - * Contains message body if success === true. - */ - body?: any; - /** - * Contains extra information that plugin can include to be passed on - */ - metadata?: unknown; - /** - * Exposes information about the performance of this request-response pair. - */ - performanceData?: PerformanceData; - } - export interface PerformanceData { - /** - * Time spent updating the program graph, in milliseconds. - */ - updateGraphDurationMs?: number; - /** - * The time spent creating or updating the auto-import program, in milliseconds. - */ - createAutoImportProviderProgramDurationMs?: number; - /** - * The time spent computing diagnostics, in milliseconds. - */ - diagnosticsDuration?: FileDiagnosticPerformanceData[]; - } - /** - * Time spent computing each kind of diagnostics, in milliseconds. - */ - export type DiagnosticPerformanceData = { - [Kind in DiagnosticEventKind]?: number; - }; - export interface FileDiagnosticPerformanceData extends DiagnosticPerformanceData { - /** - * The file for which the performance data is reported. - */ - file: string; - } - /** - * Arguments for FileRequest messages. - */ - export interface FileRequestArgs { - /** - * The file for the request (absolute pathname required). - */ - file: string; - projectFileName?: string; - } - export interface StatusRequest extends Request { - command: CommandTypes.Status; - } - export interface StatusResponseBody { - /** - * The TypeScript version (`ts.version`). - */ - version: string; - } - /** - * Response to StatusRequest - */ - export interface StatusResponse extends Response { - body: StatusResponseBody; - } - /** - * Requests a JS Doc comment template for a given position - */ - export interface DocCommentTemplateRequest extends FileLocationRequest { - command: CommandTypes.DocCommentTemplate; - } - /** - * Response to DocCommentTemplateRequest - */ - export interface DocCommandTemplateResponse extends Response { - body?: TextInsertion; - } - /** - * A request to get TODO comments from the file - */ - export interface TodoCommentRequest extends FileRequest { - command: CommandTypes.TodoComments; - arguments: TodoCommentRequestArgs; - } - /** - * Arguments for TodoCommentRequest request. - */ - export interface TodoCommentRequestArgs extends FileRequestArgs { - /** - * Array of target TodoCommentDescriptors that describes TODO comments to be found - */ - descriptors: TodoCommentDescriptor[]; - } - /** - * Response for TodoCommentRequest request. - */ - export interface TodoCommentsResponse extends Response { - body?: TodoComment[]; - } - /** - * A request to determine if the caret is inside a comment. - */ - export interface SpanOfEnclosingCommentRequest extends FileLocationRequest { - command: CommandTypes.GetSpanOfEnclosingComment; - arguments: SpanOfEnclosingCommentRequestArgs; - } - export interface SpanOfEnclosingCommentRequestArgs extends FileLocationRequestArgs { - /** - * Requires that the enclosing span be a multi-line comment, or else the request returns undefined. - */ - onlyMultiLine: boolean; - } - /** - * Request to obtain outlining spans in file. - */ - export interface OutliningSpansRequest extends FileRequest { - command: CommandTypes.GetOutliningSpans; - } - export type OutliningSpan = ChangePropertyTypes; - /** - * Response to OutliningSpansRequest request. - */ - export interface OutliningSpansResponse extends Response { - body?: OutliningSpan[]; - } - /** - * A request to get indentation for a location in file - */ - export interface IndentationRequest extends FileLocationRequest { - command: CommandTypes.Indentation; - arguments: IndentationRequestArgs; - } - /** - * Response for IndentationRequest request. - */ - export interface IndentationResponse extends Response { - body?: IndentationResult; - } - /** - * Indentation result representing where indentation should be placed - */ - export interface IndentationResult { - /** - * The base position in the document that the indent should be relative to - */ - position: number; - /** - * The number of columns the indent should be at relative to the position's column. - */ - indentation: number; - } - /** - * Arguments for IndentationRequest request. - */ - export interface IndentationRequestArgs extends FileLocationRequestArgs { - /** - * An optional set of settings to be used when computing indentation. - * If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings. - */ - options?: EditorSettings; - } - /** - * Arguments for ProjectInfoRequest request. - */ - export interface ProjectInfoRequestArgs extends FileRequestArgs { - /** - * Indicate if the file name list of the project is needed - */ - needFileNameList: boolean; - } - /** - * A request to get the project information of the current file. - */ - export interface ProjectInfoRequest extends Request { - command: CommandTypes.ProjectInfo; - arguments: ProjectInfoRequestArgs; - } - /** - * A request to retrieve compiler options diagnostics for a project - */ - export interface CompilerOptionsDiagnosticsRequest extends Request { - arguments: CompilerOptionsDiagnosticsRequestArgs; - } - /** - * Arguments for CompilerOptionsDiagnosticsRequest request. - */ - export interface CompilerOptionsDiagnosticsRequestArgs { - /** - * Name of the project to retrieve compiler options diagnostics. - */ - projectFileName: string; - } - /** - * Response message body for "projectInfo" request - */ - export interface ProjectInfo { - /** - * For configured project, this is the normalized path of the 'tsconfig.json' file - * For inferred project, this is undefined - */ - configFileName: string; - /** - * The list of normalized file name in the project, including 'lib.d.ts' - */ - fileNames?: string[]; - /** - * Indicates if the project has a active language service instance - */ - languageServiceDisabled?: boolean; - } - /** - * Represents diagnostic info that includes location of diagnostic in two forms - * - start position and length of the error span - * - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span. - */ - export interface DiagnosticWithLinePosition { - message: string; - start: number; - length: number; - startLocation: Location; - endLocation: Location; - category: string; - code: number; - /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */ - reportsUnnecessary?: {}; - reportsDeprecated?: {}; - relatedInformation?: DiagnosticRelatedInformation[]; - } - /** - * Response message for "projectInfo" request - */ - export interface ProjectInfoResponse extends Response { - body?: ProjectInfo; - } - /** - * Request whose sole parameter is a file name. - */ - export interface FileRequest extends Request { - arguments: FileRequestArgs; - } - /** - * Instances of this interface specify a location in a source file: - * (file, line, character offset), where line and character offset are 1-based. - */ - export interface FileLocationRequestArgs extends FileRequestArgs { - /** - * The line number for the request (1-based). - */ - line: number; - /** - * The character offset (on the line) for the request (1-based). - */ - offset: number; - } - export type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs; - /** - * Request refactorings at a given position or selection area. - */ - export interface GetApplicableRefactorsRequest extends Request { - command: CommandTypes.GetApplicableRefactors; - arguments: GetApplicableRefactorsRequestArgs; - } - export type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs & { - triggerReason?: RefactorTriggerReason; - kind?: string; - /** - * Include refactor actions that require additional arguments to be passed when - * calling 'GetEditsForRefactor'. When true, clients should inspect the - * `isInteractive` property of each returned `RefactorActionInfo` - * and ensure they are able to collect the appropriate arguments for any - * interactive refactor before offering it. - */ - includeInteractiveActions?: boolean; - }; - /** - * Response is a list of available refactorings. - * Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring - */ - export interface GetApplicableRefactorsResponse extends Response { - body?: ApplicableRefactorInfo[]; - } - /** - * Request refactorings at a given position or selection area to move to an existing file. - */ - export interface GetMoveToRefactoringFileSuggestionsRequest extends Request { - command: CommandTypes.GetMoveToRefactoringFileSuggestions; - arguments: GetMoveToRefactoringFileSuggestionsRequestArgs; - } - export type GetMoveToRefactoringFileSuggestionsRequestArgs = FileLocationOrRangeRequestArgs & { - kind?: string; - }; - /** - * Response is a list of available files. - * Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring - */ - export interface GetMoveToRefactoringFileSuggestions extends Response { - body: { - newFileName: string; - files: string[]; - }; - } - /** - * Request refactorings at a given position post pasting text from some other location. - */ - export interface GetPasteEditsRequest extends Request { - command: CommandTypes.GetPasteEdits; - arguments: GetPasteEditsRequestArgs; - } - export interface GetPasteEditsRequestArgs extends FileRequestArgs { - /** The text that gets pasted in a file. */ - pastedText: string[]; - /** Locations of where the `pastedText` gets added in a file. If the length of the `pastedText` and `pastedLocations` are not the same, - * then the `pastedText` is combined into one and added at all the `pastedLocations`. - */ - pasteLocations: TextSpan[]; - /** The source location of each `pastedText`. If present, the length of `spans` must be equal to the length of `pastedText`. */ - copiedFrom?: { - file: string; - spans: TextSpan[]; - }; - } - export interface GetPasteEditsResponse extends Response { - body: PasteEditsAction; - } - export interface PasteEditsAction { - edits: FileCodeEdits[]; - fixId?: {}; - } - export interface GetEditsForRefactorRequest extends Request { - command: CommandTypes.GetEditsForRefactor; - arguments: GetEditsForRefactorRequestArgs; - } - /** - * Request the edits that a particular refactoring action produces. - * Callers must specify the name of the refactor and the name of the action. - */ - export type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & { - refactor: string; - action: string; - interactiveRefactorArguments?: InteractiveRefactorArguments; - }; - export interface GetEditsForRefactorResponse extends Response { - body?: RefactorEditInfo; - } - export interface RefactorEditInfo { - edits: FileCodeEdits[]; - /** - * An optional location where the editor should start a rename operation once - * the refactoring edits have been applied - */ - renameLocation?: Location; - renameFilename?: string; - notApplicableReason?: string; - } - /** - * Organize imports by: - * 1) Removing unused imports - * 2) Coalescing imports from the same module - * 3) Sorting imports - */ - export interface OrganizeImportsRequest extends Request { - command: CommandTypes.OrganizeImports; - arguments: OrganizeImportsRequestArgs; - } - export type OrganizeImportsScope = GetCombinedCodeFixScope; - export interface OrganizeImportsRequestArgs { - scope: OrganizeImportsScope; - /** @deprecated Use `mode` instead */ - skipDestructiveCodeActions?: boolean; - mode?: OrganizeImportsMode; - } - export interface OrganizeImportsResponse extends Response { - body: readonly FileCodeEdits[]; - } - export interface GetEditsForFileRenameRequest extends Request { - command: CommandTypes.GetEditsForFileRename; - arguments: GetEditsForFileRenameRequestArgs; - } - /** Note: Paths may also be directories. */ - export interface GetEditsForFileRenameRequestArgs { - readonly oldFilePath: string; - readonly newFilePath: string; - } - export interface GetEditsForFileRenameResponse extends Response { - body: readonly FileCodeEdits[]; - } - /** - * Request for the available codefixes at a specific position. - */ - export interface CodeFixRequest extends Request { - command: CommandTypes.GetCodeFixes; - arguments: CodeFixRequestArgs; - } - export interface GetCombinedCodeFixRequest extends Request { - command: CommandTypes.GetCombinedCodeFix; - arguments: GetCombinedCodeFixRequestArgs; - } - export interface GetCombinedCodeFixResponse extends Response { - body: CombinedCodeActions; - } - export interface ApplyCodeActionCommandRequest extends Request { - command: CommandTypes.ApplyCodeActionCommand; - arguments: ApplyCodeActionCommandRequestArgs; - } - export interface ApplyCodeActionCommandResponse extends Response { - } - export interface FileRangeRequestArgs extends FileRequestArgs, FileRange { - } - /** - * Instances of this interface specify errorcodes on a specific location in a sourcefile. - */ - export interface CodeFixRequestArgs extends FileRangeRequestArgs { - /** - * Errorcodes we want to get the fixes for. - */ - errorCodes: readonly number[]; - } - export interface GetCombinedCodeFixRequestArgs { - scope: GetCombinedCodeFixScope; - fixId: {}; - } - export interface GetCombinedCodeFixScope { - type: "file"; - args: FileRequestArgs; - } - export interface ApplyCodeActionCommandRequestArgs { - /** May also be an array of commands. */ - command: {}; - } - /** - * Response for GetCodeFixes request. - */ - export interface GetCodeFixesResponse extends Response { - body?: CodeAction[]; - } - /** - * A request whose arguments specify a file location (file, line, col). - */ - export interface FileLocationRequest extends FileRequest { - arguments: FileLocationRequestArgs; - } - /** - * A request to get codes of supported code fixes. - */ - export interface GetSupportedCodeFixesRequest extends Request { - command: CommandTypes.GetSupportedCodeFixes; - arguments?: Partial; - } - /** - * A response for GetSupportedCodeFixesRequest request. - */ - export interface GetSupportedCodeFixesResponse extends Response { - /** - * List of error codes supported by the server. - */ - body?: string[]; - } - /** - * A request to get encoded semantic classifications for a span in the file - */ - export interface EncodedSemanticClassificationsRequest extends FileRequest { - arguments: EncodedSemanticClassificationsRequestArgs; - } - /** - * Arguments for EncodedSemanticClassificationsRequest request. - */ - export interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs { - /** - * Start position of the span. - */ - start: number; - /** - * Length of the span. - */ - length: number; - /** - * Optional parameter for the semantic highlighting response, if absent it - * defaults to "original". - */ - format?: "original" | "2020"; - } - /** The response for a EncodedSemanticClassificationsRequest */ - export interface EncodedSemanticClassificationsResponse extends Response { - body?: EncodedSemanticClassificationsResponseBody; - } - /** - * Implementation response message. Gives series of text spans depending on the format ar. - */ - export interface EncodedSemanticClassificationsResponseBody { - endOfLineState: EndOfLineState; - spans: number[]; - } - /** - * Arguments in document highlight request; include: filesToSearch, file, - * line, offset. - */ - export interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs { - /** - * List of files to search for document highlights. - */ - filesToSearch: string[]; - } - /** - * Go to definition request; value of command field is - * "definition". Return response giving the file locations that - * define the symbol found in file at location line, col. - */ - export interface DefinitionRequest extends FileLocationRequest { - command: CommandTypes.Definition; - } - export interface DefinitionAndBoundSpanRequest extends FileLocationRequest { - readonly command: CommandTypes.DefinitionAndBoundSpan; - } - export interface FindSourceDefinitionRequest extends FileLocationRequest { - readonly command: CommandTypes.FindSourceDefinition; - } - export interface DefinitionAndBoundSpanResponse extends Response { - readonly body: DefinitionInfoAndBoundSpan; - } - /** - * Go to type request; value of command field is - * "typeDefinition". Return response giving the file locations that - * define the type for the symbol found in file at location line, col. - */ - export interface TypeDefinitionRequest extends FileLocationRequest { - command: CommandTypes.TypeDefinition; - } - /** - * Go to implementation request; value of command field is - * "implementation". Return response giving the file locations that - * implement the symbol found in file at location line, col. - */ - export interface ImplementationRequest extends FileLocationRequest { - command: CommandTypes.Implementation; - } - /** - * Location in source code expressed as (one-based) line and (one-based) column offset. - */ - export interface Location { - line: number; - offset: number; - } - /** - * Object found in response messages defining a span of text in source code. - */ - export interface TextSpan { - /** - * First character of the definition. - */ - start: Location; - /** - * One character past last character of the definition. - */ - end: Location; - } - /** - * Object found in response messages defining a span of text in a specific source file. - */ - export interface FileSpan extends TextSpan { - /** - * File containing text span. - */ - file: string; - } - export interface JSDocTagInfo { - /** Name of the JSDoc tag */ - name: string; - /** - * Comment text after the JSDoc tag -- the text after the tag name until the next tag or end of comment - * Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise. - */ - text?: string | SymbolDisplayPart[]; - } - export interface TextSpanWithContext extends TextSpan { - contextStart?: Location; - contextEnd?: Location; - } - export interface FileSpanWithContext extends FileSpan, TextSpanWithContext { - } - export interface DefinitionInfo extends FileSpanWithContext { - /** - * When true, the file may or may not exist. - */ - unverified?: boolean; - } - export interface DefinitionInfoAndBoundSpan { - definitions: readonly DefinitionInfo[]; - textSpan: TextSpan; - } - /** - * Definition response message. Gives text range for definition. - */ - export interface DefinitionResponse extends Response { - body?: DefinitionInfo[]; - } - export interface DefinitionInfoAndBoundSpanResponse extends Response { - body?: DefinitionInfoAndBoundSpan; - } - /** @deprecated Use `DefinitionInfoAndBoundSpanResponse` instead. */ - export type DefinitionInfoAndBoundSpanReponse = DefinitionInfoAndBoundSpanResponse; - /** - * Definition response message. Gives text range for definition. - */ - export interface TypeDefinitionResponse extends Response { - body?: FileSpanWithContext[]; - } - /** - * Implementation response message. Gives text range for implementations. - */ - export interface ImplementationResponse extends Response { - body?: FileSpanWithContext[]; - } - /** - * Request to get brace completion for a location in the file. - */ - export interface BraceCompletionRequest extends FileLocationRequest { - command: CommandTypes.BraceCompletion; - arguments: BraceCompletionRequestArgs; - } - /** - * Argument for BraceCompletionRequest request. - */ - export interface BraceCompletionRequestArgs extends FileLocationRequestArgs { - /** - * Kind of opening brace - */ - openingBrace: string; - } - export interface JsxClosingTagRequest extends FileLocationRequest { - readonly command: CommandTypes.JsxClosingTag; - readonly arguments: JsxClosingTagRequestArgs; - } - export interface JsxClosingTagRequestArgs extends FileLocationRequestArgs { - } - export interface JsxClosingTagResponse extends Response { - readonly body: TextInsertion; - } - export interface LinkedEditingRangeRequest extends FileLocationRequest { - readonly command: CommandTypes.LinkedEditingRange; - } - export interface LinkedEditingRangesBody { - ranges: TextSpan[]; - wordPattern?: string; - } - export interface LinkedEditingRangeResponse extends Response { - readonly body: LinkedEditingRangesBody; - } - /** - * Get document highlights request; value of command field is - * "documentHighlights". Return response giving spans that are relevant - * in the file at a given line and column. - */ - export interface DocumentHighlightsRequest extends FileLocationRequest { - command: CommandTypes.DocumentHighlights; - arguments: DocumentHighlightsRequestArgs; - } - /** - * Span augmented with extra information that denotes the kind of the highlighting to be used for span. - */ - export interface HighlightSpan extends TextSpanWithContext { - kind: HighlightSpanKind; - } - /** - * Represents a set of highligh spans for a give name - */ - export interface DocumentHighlightsItem { - /** - * File containing highlight spans. - */ - file: string; - /** - * Spans to highlight in file. - */ - highlightSpans: HighlightSpan[]; - } - /** - * Response for a DocumentHighlightsRequest request. - */ - export interface DocumentHighlightsResponse extends Response { - body?: DocumentHighlightsItem[]; - } - /** - * Find references request; value of command field is - * "references". Return response giving the file locations that - * reference the symbol found in file at location line, col. - */ - export interface ReferencesRequest extends FileLocationRequest { - command: CommandTypes.References; - } - export interface ReferencesResponseItem extends FileSpanWithContext { - /** - * Text of line containing the reference. Including this - * with the response avoids latency of editor loading files - * to show text of reference line (the server already has loaded the referencing files). - * - * If {@link UserPreferences.disableLineTextInReferences} is enabled, the property won't be filled - */ - lineText?: string; - /** - * True if reference is a write location, false otherwise. - */ - isWriteAccess: boolean; - /** - * Present only if the search was triggered from a declaration. - * True indicates that the references refers to the same symbol - * (i.e. has the same meaning) as the declaration that began the - * search. - */ - isDefinition?: boolean; - } - /** - * The body of a "references" response message. - */ - export interface ReferencesResponseBody { - /** - * The file locations referencing the symbol. - */ - refs: readonly ReferencesResponseItem[]; - /** - * The name of the symbol. - */ - symbolName: string; - /** - * The start character offset of the symbol (on the line provided by the references request). - */ - symbolStartOffset: number; - /** - * The full display name of the symbol. - */ - symbolDisplayString: string; - } - /** - * Response to "references" request. - */ - export interface ReferencesResponse extends Response { - body?: ReferencesResponseBody; - } - export interface FileReferencesRequest extends FileRequest { - command: CommandTypes.FileReferences; - } - export interface FileReferencesResponseBody { - /** - * The file locations referencing the symbol. - */ - refs: readonly ReferencesResponseItem[]; - /** - * The name of the symbol. - */ - symbolName: string; - } - export interface FileReferencesResponse extends Response { - body?: FileReferencesResponseBody; - } - /** - * Argument for RenameRequest request. - */ - export interface RenameRequestArgs extends FileLocationRequestArgs { - /** - * Should text at specified location be found/changed in comments? - */ - findInComments?: boolean; - /** - * Should text at specified location be found/changed in strings? - */ - findInStrings?: boolean; - } - /** - * Rename request; value of command field is "rename". Return - * response giving the file locations that reference the symbol - * found in file at location line, col. Also return full display - * name of the symbol so that client can print it unambiguously. - */ - export interface RenameRequest extends FileLocationRequest { - command: CommandTypes.Rename; - arguments: RenameRequestArgs; - } - /** - * Information about the item to be renamed. - */ - export type RenameInfo = RenameInfoSuccess | RenameInfoFailure; - export type RenameInfoSuccess = ChangePropertyTypes; - /** - * A group of text spans, all in 'file'. - */ - export interface SpanGroup { - /** The file to which the spans apply */ - file: string; - /** The text spans in this group */ - locs: RenameTextSpan[]; - } - export interface RenameTextSpan extends TextSpanWithContext { - readonly prefixText?: string; - readonly suffixText?: string; - } - export interface RenameResponseBody { - /** - * Information about the item to be renamed. - */ - info: RenameInfo; - /** - * An array of span groups (one per file) that refer to the item to be renamed. - */ - locs: readonly SpanGroup[]; - } - /** - * Rename response message. - */ - export interface RenameResponse extends Response { - body?: RenameResponseBody; - } - /** - * Represents a file in external project. - * External project is project whose set of files, compilation options and open\close state - * is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio). - * External project will exist even if all files in it are closed and should be closed explicitly. - * If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will - * create configured project for every config file but will maintain a link that these projects were created - * as a result of opening external project so they should be removed once external project is closed. - */ - export interface ExternalFile { - /** - * Name of file file - */ - fileName: string; - /** - * Script kind of the file - */ - scriptKind?: ScriptKindName | ScriptKind; - /** - * Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript) - */ - hasMixedContent?: boolean; - /** - * Content of the file - */ - content?: string; - } - /** - * Represent an external project - */ - export interface ExternalProject { - /** - * Project name - */ - projectFileName: string; - /** - * List of root files in project - */ - rootFiles: ExternalFile[]; - /** - * Compiler options for the project - */ - options: ExternalProjectCompilerOptions; - /** - * Explicitly specified type acquisition for the project - */ - typeAcquisition?: TypeAcquisition; - } - export interface CompileOnSaveMixin { - /** - * If compile on save is enabled for the project - */ - compileOnSave?: boolean; - } - /** - * For external projects, some of the project settings are sent together with - * compiler settings. - */ - export type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin & WatchOptions; - export interface FileWithProjectReferenceRedirectInfo { - /** - * Name of file - */ - fileName: string; - /** - * True if the file is primarily included in a referenced project - */ - isSourceOfProjectReferenceRedirect: boolean; - } - /** - * Represents a set of changes that happen in project - */ - export interface ProjectChanges { - /** - * List of added files - */ - added: string[] | FileWithProjectReferenceRedirectInfo[]; - /** - * List of removed files - */ - removed: string[] | FileWithProjectReferenceRedirectInfo[]; - /** - * List of updated files - */ - updated: string[] | FileWithProjectReferenceRedirectInfo[]; - /** - * List of files that have had their project reference redirect status updated - * Only provided when the synchronizeProjectList request has includeProjectReferenceRedirectInfo set to true - */ - updatedRedirects?: FileWithProjectReferenceRedirectInfo[]; - } - /** - * Information found in a configure request. - */ - export interface ConfigureRequestArguments { - /** - * Information about the host, for example 'Emacs 24.4' or - * 'Sublime Text version 3075' - */ - hostInfo?: string; - /** - * If present, tab settings apply only to this file. - */ - file?: string; - /** - * The format options to use during formatting and other code editing features. - */ - formatOptions?: FormatCodeSettings; - preferences?: UserPreferences; - /** - * The host's additional supported .js file extensions - */ - extraFileExtensions?: FileExtensionInfo[]; - watchOptions?: WatchOptions; - } - export enum WatchFileKind { - FixedPollingInterval = "FixedPollingInterval", - PriorityPollingInterval = "PriorityPollingInterval", - DynamicPriorityPolling = "DynamicPriorityPolling", - FixedChunkSizePolling = "FixedChunkSizePolling", - UseFsEvents = "UseFsEvents", - UseFsEventsOnParentDirectory = "UseFsEventsOnParentDirectory", - } - export enum WatchDirectoryKind { - UseFsEvents = "UseFsEvents", - FixedPollingInterval = "FixedPollingInterval", - DynamicPriorityPolling = "DynamicPriorityPolling", - FixedChunkSizePolling = "FixedChunkSizePolling", - } - export enum PollingWatchKind { - FixedInterval = "FixedInterval", - PriorityInterval = "PriorityInterval", - DynamicPriority = "DynamicPriority", - FixedChunkSize = "FixedChunkSize", - } - export interface WatchOptions { - watchFile?: WatchFileKind | ts.WatchFileKind; - watchDirectory?: WatchDirectoryKind | ts.WatchDirectoryKind; - fallbackPolling?: PollingWatchKind | ts.PollingWatchKind; - synchronousWatchDirectory?: boolean; - excludeDirectories?: string[]; - excludeFiles?: string[]; - [option: string]: CompilerOptionsValue | undefined; - } - /** - * Configure request; value of command field is "configure". Specifies - * host information, such as host type, tab size, and indent size. - */ - export interface ConfigureRequest extends Request { - command: CommandTypes.Configure; - arguments: ConfigureRequestArguments; - } - /** - * Response to "configure" request. This is just an acknowledgement, so - * no body field is required. - */ - export interface ConfigureResponse extends Response { - } - export interface ConfigurePluginRequestArguments { - pluginName: string; - configuration: any; - } - export interface ConfigurePluginRequest extends Request { - command: CommandTypes.ConfigurePlugin; - arguments: ConfigurePluginRequestArguments; - } - export interface ConfigurePluginResponse extends Response { - } - export interface SelectionRangeRequest extends FileRequest { - command: CommandTypes.SelectionRange; - arguments: SelectionRangeRequestArgs; - } - export interface SelectionRangeRequestArgs extends FileRequestArgs { - locations: Location[]; - } - export interface SelectionRangeResponse extends Response { - body?: SelectionRange[]; - } - export interface SelectionRange { - textSpan: TextSpan; - parent?: SelectionRange; - } - export interface ToggleLineCommentRequest extends FileRequest { - command: CommandTypes.ToggleLineComment; - arguments: FileRangeRequestArgs; - } - export interface ToggleMultilineCommentRequest extends FileRequest { - command: CommandTypes.ToggleMultilineComment; - arguments: FileRangeRequestArgs; - } - export interface CommentSelectionRequest extends FileRequest { - command: CommandTypes.CommentSelection; - arguments: FileRangeRequestArgs; - } - export interface UncommentSelectionRequest extends FileRequest { - command: CommandTypes.UncommentSelection; - arguments: FileRangeRequestArgs; - } - /** - * Information found in an "open" request. - */ - export interface OpenRequestArgs extends FileRequestArgs { - /** - * Used when a version of the file content is known to be more up to date than the one on disk. - * Then the known content will be used upon opening instead of the disk copy - */ - fileContent?: string; - /** - * Used to specify the script kind of the file explicitly. It could be one of the following: - * "TS", "JS", "TSX", "JSX" - */ - scriptKindName?: ScriptKindName; - /** - * Used to limit the searching for project config file. If given the searching will stop at this - * root path; otherwise it will go all the way up to the dist root path. - */ - projectRootPath?: string; - } - export type ScriptKindName = "TS" | "JS" | "TSX" | "JSX"; - /** - * Open request; value of command field is "open". Notify the - * server that the client has file open. The server will not - * monitor the filesystem for changes in this file and will assume - * that the client is updating the server (using the change and/or - * reload messages) when the file changes. Server does not currently - * send a response to an open request. - */ - export interface OpenRequest extends Request { - command: CommandTypes.Open; - arguments: OpenRequestArgs; - } - /** - * Request to open or update external project - */ - export interface OpenExternalProjectRequest extends Request { - command: CommandTypes.OpenExternalProject; - arguments: OpenExternalProjectArgs; - } - /** - * Arguments to OpenExternalProjectRequest request - */ - export type OpenExternalProjectArgs = ExternalProject; - /** - * Request to open multiple external projects - */ - export interface OpenExternalProjectsRequest extends Request { - command: CommandTypes.OpenExternalProjects; - arguments: OpenExternalProjectsArgs; - } - /** - * Arguments to OpenExternalProjectsRequest - */ - export interface OpenExternalProjectsArgs { - /** - * List of external projects to open or update - */ - projects: ExternalProject[]; - } - /** - * Response to OpenExternalProjectRequest request. This is just an acknowledgement, so - * no body field is required. - */ - export interface OpenExternalProjectResponse extends Response { - } - /** - * Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so - * no body field is required. - */ - export interface OpenExternalProjectsResponse extends Response { - } - /** - * Request to close external project. - */ - export interface CloseExternalProjectRequest extends Request { - command: CommandTypes.CloseExternalProject; - arguments: CloseExternalProjectRequestArgs; - } - /** - * Arguments to CloseExternalProjectRequest request - */ - export interface CloseExternalProjectRequestArgs { - /** - * Name of the project to close - */ - projectFileName: string; - } - /** - * Response to CloseExternalProjectRequest request. This is just an acknowledgement, so - * no body field is required. - */ - export interface CloseExternalProjectResponse extends Response { - } - /** - * Request to synchronize list of open files with the client - */ - export interface UpdateOpenRequest extends Request { - command: CommandTypes.UpdateOpen; - arguments: UpdateOpenRequestArgs; - } - /** - * Arguments to UpdateOpenRequest - */ - export interface UpdateOpenRequestArgs { - /** - * List of newly open files - */ - openFiles?: OpenRequestArgs[]; - /** - * List of open files files that were changes - */ - changedFiles?: FileCodeEdits[]; - /** - * List of files that were closed - */ - closedFiles?: string[]; - } - /** - * External projects have a typeAcquisition option so they need to be added separately to compiler options for inferred projects. - */ - export type InferredProjectCompilerOptions = ExternalProjectCompilerOptions & TypeAcquisition; - /** - * Request to set compiler options for inferred projects. - * External projects are opened / closed explicitly. - * Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders. - * This configuration file will be used to obtain a list of files and configuration settings for the project. - * Inferred projects are created when user opens a loose file that is not the part of external project - * or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false, - * or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true. - */ - export interface SetCompilerOptionsForInferredProjectsRequest extends Request { - command: CommandTypes.CompilerOptionsForInferredProjects; - arguments: SetCompilerOptionsForInferredProjectsArgs; - } - /** - * Argument for SetCompilerOptionsForInferredProjectsRequest request. - */ - export interface SetCompilerOptionsForInferredProjectsArgs { - /** - * Compiler options to be used with inferred projects. - */ - options: InferredProjectCompilerOptions; - /** - * Specifies the project root path used to scope compiler options. - * It is an error to provide this property if the server has not been started with - * `useInferredProjectPerProjectRoot` enabled. - */ - projectRootPath?: string; - } - /** - * Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so - * no body field is required. - */ - export interface SetCompilerOptionsForInferredProjectsResponse extends Response { - } - /** - * Exit request; value of command field is "exit". Ask the server process - * to exit. - */ - export interface ExitRequest extends Request { - command: CommandTypes.Exit; - } - /** - * Close request; value of command field is "close". Notify the - * server that the client has closed a previously open file. If - * file is still referenced by open files, the server will resume - * monitoring the filesystem for changes to file. Server does not - * currently send a response to a close request. - */ - export interface CloseRequest extends FileRequest { - command: CommandTypes.Close; - } - export interface WatchChangeRequest extends Request { - command: CommandTypes.WatchChange; - arguments: WatchChangeRequestArgs | readonly WatchChangeRequestArgs[]; - } - export interface WatchChangeRequestArgs { - id: number; - created?: string[]; - deleted?: string[]; - updated?: string[]; - } - /** - * Request to obtain the list of files that should be regenerated if target file is recompiled. - * NOTE: this us query-only operation and does not generate any output on disk. - */ - export interface CompileOnSaveAffectedFileListRequest extends FileRequest { - command: CommandTypes.CompileOnSaveAffectedFileList; - } - /** - * Contains a list of files that should be regenerated in a project - */ - export interface CompileOnSaveAffectedFileListSingleProject { - /** - * Project name - */ - projectFileName: string; - /** - * List of files names that should be recompiled - */ - fileNames: string[]; - /** - * true if project uses outFile or out compiler option - */ - projectUsesOutFile: boolean; - } - /** - * Response for CompileOnSaveAffectedFileListRequest request; - */ - export interface CompileOnSaveAffectedFileListResponse extends Response { - body: CompileOnSaveAffectedFileListSingleProject[]; - } - /** - * Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk. - */ - export interface CompileOnSaveEmitFileRequest extends FileRequest { - command: CommandTypes.CompileOnSaveEmitFile; - arguments: CompileOnSaveEmitFileRequestArgs; - } - /** - * Arguments for CompileOnSaveEmitFileRequest - */ - export interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs { - /** - * if true - then file should be recompiled even if it does not have any changes. - */ - forced?: boolean; - includeLinePosition?: boolean; - /** if true - return response as object with emitSkipped and diagnostics */ - richResponse?: boolean; - } - export interface CompileOnSaveEmitFileResponse extends Response { - body: boolean | EmitResult; - } - export interface EmitResult { - emitSkipped: boolean; - diagnostics: Diagnostic[] | DiagnosticWithLinePosition[]; - } - /** - * Quickinfo request; value of command field is - * "quickinfo". Return response giving a quick type and - * documentation string for the symbol found in file at location - * line, col. - */ - export interface QuickInfoRequest extends FileLocationRequest { - command: CommandTypes.Quickinfo; - arguments: FileLocationRequestArgs; - } - /** - * Body of QuickInfoResponse. - */ - export interface QuickInfoResponseBody { - /** - * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). - */ - kind: ScriptElementKind; - /** - * Optional modifiers for the kind (such as 'public'). - */ - kindModifiers: string; - /** - * Starting file location of symbol. - */ - start: Location; - /** - * One past last character of symbol. - */ - end: Location; - /** - * Type and kind of symbol. - */ - displayString: string; - /** - * Documentation associated with symbol. - * Display parts when UserPreferences.displayPartsForJSDoc is true, flattened to string otherwise. - */ - documentation: string | SymbolDisplayPart[]; - /** - * JSDoc tags associated with symbol. - */ - tags: JSDocTagInfo[]; - } - /** - * Quickinfo response message. - */ - export interface QuickInfoResponse extends Response { - body?: QuickInfoResponseBody; - } - /** - * Arguments for format messages. - */ - export interface FormatRequestArgs extends FileLocationRequestArgs { - /** - * Last line of range for which to format text in file. - */ - endLine: number; - /** - * Character offset on last line of range for which to format text in file. - */ - endOffset: number; - /** - * Format options to be used. - */ - options?: FormatCodeSettings; - } - /** - * Format request; value of command field is "format". Return - * response giving zero or more edit instructions. The edit - * instructions will be sorted in file order. Applying the edit - * instructions in reverse to file will result in correctly - * reformatted text. - */ - export interface FormatRequest extends FileLocationRequest { - command: CommandTypes.Format; - arguments: FormatRequestArgs; - } - /** - * Object found in response messages defining an editing - * instruction for a span of text in source code. The effect of - * this instruction is to replace the text starting at start and - * ending one character before end with newText. For an insertion, - * the text span is empty. For a deletion, newText is empty. - */ - export interface CodeEdit { - /** - * First character of the text span to edit. - */ - start: Location; - /** - * One character past last character of the text span to edit. - */ - end: Location; - /** - * Replace the span defined above with this string (may be - * the empty string). - */ - newText: string; - } - export interface FileCodeEdits { - fileName: string; - textChanges: CodeEdit[]; - } - export interface CodeFixResponse extends Response { - /** The code actions that are available */ - body?: CodeFixAction[]; - } - export interface CodeAction { - /** Description of the code action to display in the UI of the editor */ - description: string; - /** Text changes to apply to each file as part of the code action */ - changes: FileCodeEdits[]; - /** A command is an opaque object that should be passed to `ApplyCodeActionCommandRequestArgs` without modification. */ - commands?: {}[]; - } - export interface CombinedCodeActions { - changes: readonly FileCodeEdits[]; - commands?: readonly {}[]; - } - export interface CodeFixAction extends CodeAction { - /** Short name to identify the fix, for use by telemetry. */ - fixName: string; - /** - * If present, one may call 'getCombinedCodeFix' with this fixId. - * This may be omitted to indicate that the code fix can't be applied in a group. - */ - fixId?: {}; - /** Should be present if and only if 'fixId' is. */ - fixAllDescription?: string; - } - /** - * Format and format on key response message. - */ - export interface FormatResponse extends Response { - body?: CodeEdit[]; - } - /** - * Arguments for format on key messages. - */ - export interface FormatOnKeyRequestArgs extends FileLocationRequestArgs { - /** - * Key pressed (';', '\n', or '}'). - */ - key: string; - options?: FormatCodeSettings; - } - /** - * Format on key request; value of command field is - * "formatonkey". Given file location and key typed (as string), - * return response giving zero or more edit instructions. The - * edit instructions will be sorted in file order. Applying the - * edit instructions in reverse to file will result in correctly - * reformatted text. - */ - export interface FormatOnKeyRequest extends FileLocationRequest { - command: CommandTypes.Formatonkey; - arguments: FormatOnKeyRequestArgs; - } - /** - * Arguments for completions messages. - */ - export interface CompletionsRequestArgs extends FileLocationRequestArgs { - /** - * Optional prefix to apply to possible completions. - */ - prefix?: string; - /** - * Character that was responsible for triggering completion. - * Should be `undefined` if a user manually requested completion. - */ - triggerCharacter?: CompletionsTriggerCharacter; - triggerKind?: CompletionTriggerKind; - /** - * @deprecated Use UserPreferences.includeCompletionsForModuleExports - */ - includeExternalModuleExports?: boolean; - /** - * @deprecated Use UserPreferences.includeCompletionsWithInsertText - */ - includeInsertTextCompletions?: boolean; - } - /** - * Completions request; value of command field is "completions". - * Given a file location (file, line, col) and a prefix (which may - * be the empty string), return the possible completions that - * begin with prefix. - */ - export interface CompletionsRequest extends FileLocationRequest { - command: CommandTypes.Completions | CommandTypes.CompletionInfo; - arguments: CompletionsRequestArgs; - } - /** - * Arguments for completion details request. - */ - export interface CompletionDetailsRequestArgs extends FileLocationRequestArgs { - /** - * Names of one or more entries for which to obtain details. - */ - entryNames: (string | CompletionEntryIdentifier)[]; - } - export interface CompletionEntryIdentifier { - name: string; - source?: string; - data?: unknown; - } - /** - * Completion entry details request; value of command field is - * "completionEntryDetails". Given a file location (file, line, - * col) and an array of completion entry names return more - * detailed information for each completion entry. - */ - export interface CompletionDetailsRequest extends FileLocationRequest { - command: CommandTypes.CompletionDetails; - arguments: CompletionDetailsRequestArgs; - } - /** A part of a symbol description that links from a jsdoc @link tag to a declaration */ - export interface JSDocLinkDisplayPart extends SymbolDisplayPart { - /** The location of the declaration that the @link tag links to. */ - target: FileSpan; - } - export type CompletionEntry = ChangePropertyTypes, { - replacementSpan: TextSpan; - data: unknown; - }>; - /** - * Additional completion entry details, available on demand - */ - export type CompletionEntryDetails = ChangePropertyTypes; - /** @deprecated Prefer CompletionInfoResponse, which supports several top-level fields in addition to the array of entries. */ - export interface CompletionsResponse extends Response { - body?: CompletionEntry[]; - } - export interface CompletionInfoResponse extends Response { - body?: CompletionInfo; - } - export type CompletionInfo = ChangePropertyTypes; - export interface CompletionDetailsResponse extends Response { - body?: CompletionEntryDetails[]; - } - /** - * Represents a single signature to show in signature help. - */ - export type SignatureHelpItem = ChangePropertyTypes; - /** - * Signature help items found in the response of a signature help request. - */ - export interface SignatureHelpItems { - /** - * The signature help items. - */ - items: SignatureHelpItem[]; - /** - * The span for which signature help should appear on a signature - */ - applicableSpan: TextSpan; - /** - * The item selected in the set of available help items. - */ - selectedItemIndex: number; - /** - * The argument selected in the set of parameters. - */ - argumentIndex: number; - /** - * The argument count - */ - argumentCount: number; - } - /** - * Arguments of a signature help request. - */ - export interface SignatureHelpRequestArgs extends FileLocationRequestArgs { - /** - * Reason why signature help was invoked. - * See each individual possible - */ - triggerReason?: SignatureHelpTriggerReason; - } - /** - * Signature help request; value of command field is "signatureHelp". - * Given a file location (file, line, col), return the signature - * help. - */ - export interface SignatureHelpRequest extends FileLocationRequest { - command: CommandTypes.SignatureHelp; - arguments: SignatureHelpRequestArgs; - } - /** - * Response object for a SignatureHelpRequest. - */ - export interface SignatureHelpResponse extends Response { - body?: SignatureHelpItems; - } - export interface InlayHintsRequestArgs extends FileRequestArgs { - /** - * Start position of the span. - */ - start: number; - /** - * Length of the span. - */ - length: number; - } - export interface InlayHintsRequest extends Request { - command: CommandTypes.ProvideInlayHints; - arguments: InlayHintsRequestArgs; - } - export type InlayHintItem = ChangePropertyTypes; - export interface InlayHintItemDisplayPart { - text: string; - span?: FileSpan; - } - export interface InlayHintsResponse extends Response { - body?: InlayHintItem[]; - } - export interface MapCodeRequestArgs extends FileRequestArgs { - /** - * The files and changes to try and apply/map. - */ - mapping: MapCodeRequestDocumentMapping; - } - export interface MapCodeRequestDocumentMapping { - /** - * The specific code to map/insert/replace in the file. - */ - contents: string[]; - /** - * Areas of "focus" to inform the code mapper with. For example, cursor - * location, current selection, viewport, etc. Nested arrays denote - * priority: toplevel arrays are more important than inner arrays, and - * inner array priorities are based on items within that array. Items - * earlier in the arrays have higher priority. - */ - focusLocations?: TextSpan[][]; - } - export interface MapCodeRequest extends FileRequest { - command: CommandTypes.MapCode; - arguments: MapCodeRequestArgs; - } - export interface MapCodeResponse extends Response { - body: readonly FileCodeEdits[]; - } - /** - * Synchronous request for semantic diagnostics of one file. - */ - export interface SemanticDiagnosticsSyncRequest extends FileRequest { - command: CommandTypes.SemanticDiagnosticsSync; - arguments: SemanticDiagnosticsSyncRequestArgs; - } - export interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs { - includeLinePosition?: boolean; - } - /** - * Response object for synchronous sematic diagnostics request. - */ - export interface SemanticDiagnosticsSyncResponse extends Response { - body?: Diagnostic[] | DiagnosticWithLinePosition[]; - } - export interface SuggestionDiagnosticsSyncRequest extends FileRequest { - command: CommandTypes.SuggestionDiagnosticsSync; - arguments: SuggestionDiagnosticsSyncRequestArgs; - } - export type SuggestionDiagnosticsSyncRequestArgs = SemanticDiagnosticsSyncRequestArgs; - export type SuggestionDiagnosticsSyncResponse = SemanticDiagnosticsSyncResponse; - /** - * Synchronous request for syntactic diagnostics of one file. - */ - export interface SyntacticDiagnosticsSyncRequest extends FileRequest { - command: CommandTypes.SyntacticDiagnosticsSync; - arguments: SyntacticDiagnosticsSyncRequestArgs; - } - export interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs { - includeLinePosition?: boolean; - } - /** - * Response object for synchronous syntactic diagnostics request. - */ - export interface SyntacticDiagnosticsSyncResponse extends Response { - body?: Diagnostic[] | DiagnosticWithLinePosition[]; - } - /** - * Arguments for GeterrForProject request. - */ - export interface GeterrForProjectRequestArgs { - /** - * the file requesting project error list - */ - file: string; - /** - * Delay in milliseconds to wait before starting to compute - * errors for the files in the file list - */ - delay: number; - } - /** - * GeterrForProjectRequest request; value of command field is - * "geterrForProject". It works similarly with 'Geterr', only - * it request for every file in this project. - */ - export interface GeterrForProjectRequest extends Request { - command: CommandTypes.GeterrForProject; - arguments: GeterrForProjectRequestArgs; - } - /** - * Arguments for geterr messages. - */ - export interface GeterrRequestArgs { - /** - * List of file names for which to compute compiler errors. - * The files will be checked in list order. - */ - files: (string | FileRangesRequestArgs)[]; - /** - * Delay in milliseconds to wait before starting to compute - * errors for the files in the file list - */ - delay: number; - } - /** - * Geterr request; value of command field is "geterr". Wait for - * delay milliseconds and then, if during the wait no change or - * reload messages have arrived for the first file in the files - * list, get the syntactic errors for the file, field requests, - * and then get the semantic errors for the file. Repeat with a - * smaller delay for each subsequent file on the files list. Best - * practice for an editor is to send a file list containing each - * file that is currently visible, in most-recently-used order. - */ - export interface GeterrRequest extends Request { - command: CommandTypes.Geterr; - arguments: GeterrRequestArgs; - } - export interface FileRange { - /** - * The line number for the request (1-based). - */ - startLine: number; - /** - * The character offset (on the line) for the request (1-based). - */ - startOffset: number; - /** - * The line number for the request (1-based). - */ - endLine: number; - /** - * The character offset (on the line) for the request (1-based). - */ - endOffset: number; - } - export interface FileRangesRequestArgs extends Pick { - ranges: FileRange[]; - } - export type RequestCompletedEventName = "requestCompleted"; - /** - * Event that is sent when server have finished processing request with specified id. - */ - export interface RequestCompletedEvent extends Event { - event: RequestCompletedEventName; - body: RequestCompletedEventBody; - } - export interface RequestCompletedEventBody { - request_seq: number; - performanceData?: PerformanceData; - } - /** - * Item of diagnostic information found in a DiagnosticEvent message. - */ - export interface Diagnostic { - /** - * Starting file location at which text applies. - */ - start: Location; - /** - * The last file location at which the text applies. - */ - end: Location; - /** - * Text of diagnostic message. - */ - text: string; - /** - * The category of the diagnostic message, e.g. "error", "warning", or "suggestion". - */ - category: string; - reportsUnnecessary?: {}; - reportsDeprecated?: {}; - /** - * Any related spans the diagnostic may have, such as other locations relevant to an error, such as declarartion sites - */ - relatedInformation?: DiagnosticRelatedInformation[]; - /** - * The error code of the diagnostic message. - */ - code?: number; - /** - * The name of the plugin reporting the message. - */ - source?: string; - } - export interface DiagnosticWithFileName extends Diagnostic { - /** - * Name of the file the diagnostic is in - */ - fileName: string; - } - /** - * Represents additional spans returned with a diagnostic which are relevant to it - */ - export interface DiagnosticRelatedInformation { - /** - * The category of the related information message, e.g. "error", "warning", or "suggestion". - */ - category: string; - /** - * The code used ot identify the related information - */ - code: number; - /** - * Text of related or additional information. - */ - message: string; - /** - * Associated location - */ - span?: FileSpan; - } - export interface DiagnosticEventBody { - /** - * The file for which diagnostic information is reported. - */ - file: string; - /** - * An array of diagnostic information items. - */ - diagnostics: Diagnostic[]; - /** - * Spans where the region diagnostic was requested, if this is a region semantic diagnostic event. - */ - spans?: TextSpan[]; - } - export type DiagnosticEventKind = "semanticDiag" | "syntaxDiag" | "suggestionDiag" | "regionSemanticDiag"; - /** - * Event message for DiagnosticEventKind event types. - * These events provide syntactic and semantic errors for a file. - */ - export interface DiagnosticEvent extends Event { - body?: DiagnosticEventBody; - event: DiagnosticEventKind; - } - export interface ConfigFileDiagnosticEventBody { - /** - * The file which trigged the searching and error-checking of the config file - */ - triggerFile: string; - /** - * The name of the found config file. - */ - configFile: string; - /** - * An arry of diagnostic information items for the found config file. - */ - diagnostics: DiagnosticWithFileName[]; - } - /** - * Event message for "configFileDiag" event type. - * This event provides errors for a found config file. - */ - export interface ConfigFileDiagnosticEvent extends Event { - body?: ConfigFileDiagnosticEventBody; - event: "configFileDiag"; - } - export type ProjectLanguageServiceStateEventName = "projectLanguageServiceState"; - export interface ProjectLanguageServiceStateEvent extends Event { - event: ProjectLanguageServiceStateEventName; - body?: ProjectLanguageServiceStateEventBody; - } - export interface ProjectLanguageServiceStateEventBody { - /** - * Project name that has changes in the state of language service. - * For configured projects this will be the config file path. - * For external projects this will be the name of the projects specified when project was open. - * For inferred projects this event is not raised. - */ - projectName: string; - /** - * True if language service state switched from disabled to enabled - * and false otherwise. - */ - languageServiceEnabled: boolean; - } - export type ProjectsUpdatedInBackgroundEventName = "projectsUpdatedInBackground"; - export interface ProjectsUpdatedInBackgroundEvent extends Event { - event: ProjectsUpdatedInBackgroundEventName; - body: ProjectsUpdatedInBackgroundEventBody; - } - export interface ProjectsUpdatedInBackgroundEventBody { - /** - * Current set of open files - */ - openFiles: string[]; - } - export type ProjectLoadingStartEventName = "projectLoadingStart"; - export interface ProjectLoadingStartEvent extends Event { - event: ProjectLoadingStartEventName; - body: ProjectLoadingStartEventBody; - } - export interface ProjectLoadingStartEventBody { - /** name of the project */ - projectName: string; - /** reason for loading */ - reason: string; - } - export type ProjectLoadingFinishEventName = "projectLoadingFinish"; - export interface ProjectLoadingFinishEvent extends Event { - event: ProjectLoadingFinishEventName; - body: ProjectLoadingFinishEventBody; - } - export interface ProjectLoadingFinishEventBody { - /** name of the project */ - projectName: string; - } - export type SurveyReadyEventName = "surveyReady"; - export interface SurveyReadyEvent extends Event { - event: SurveyReadyEventName; - body: SurveyReadyEventBody; - } - export interface SurveyReadyEventBody { - /** Name of the survey. This is an internal machine- and programmer-friendly name */ - surveyId: string; - } - export type LargeFileReferencedEventName = "largeFileReferenced"; - export interface LargeFileReferencedEvent extends Event { - event: LargeFileReferencedEventName; - body: LargeFileReferencedEventBody; - } - export interface LargeFileReferencedEventBody { - /** - * name of the large file being loaded - */ - file: string; - /** - * size of the file - */ - fileSize: number; - /** - * max file size allowed on the server - */ - maxFileSize: number; - } - export type CreateFileWatcherEventName = "createFileWatcher"; - export interface CreateFileWatcherEvent extends Event { - readonly event: CreateFileWatcherEventName; - readonly body: CreateFileWatcherEventBody; - } - export interface CreateFileWatcherEventBody { - readonly id: number; - readonly path: string; - } - export type CreateDirectoryWatcherEventName = "createDirectoryWatcher"; - export interface CreateDirectoryWatcherEvent extends Event { - readonly event: CreateDirectoryWatcherEventName; - readonly body: CreateDirectoryWatcherEventBody; - } - export interface CreateDirectoryWatcherEventBody { - readonly id: number; - readonly path: string; - readonly recursive: boolean; - readonly ignoreUpdate?: boolean; - } - export type CloseFileWatcherEventName = "closeFileWatcher"; - export interface CloseFileWatcherEvent extends Event { - readonly event: CloseFileWatcherEventName; - readonly body: CloseFileWatcherEventBody; - } - export interface CloseFileWatcherEventBody { - readonly id: number; - } - /** - * Arguments for reload request. - */ - export interface ReloadRequestArgs extends FileRequestArgs { - /** - * Name of temporary file from which to reload file - * contents. May be same as file. - */ - tmpfile: string; - } - /** - * Reload request message; value of command field is "reload". - * Reload contents of file with name given by the 'file' argument - * from temporary file with name given by the 'tmpfile' argument. - * The two names can be identical. - */ - export interface ReloadRequest extends FileRequest { - command: CommandTypes.Reload; - arguments: ReloadRequestArgs; - } - /** - * Response to "reload" request. This is just an acknowledgement, so - * no body field is required. - */ - export interface ReloadResponse extends Response { - } - /** - * Arguments for saveto request. - */ - export interface SavetoRequestArgs extends FileRequestArgs { - /** - * Name of temporary file into which to save server's view of - * file contents. - */ - tmpfile: string; - } - /** - * Saveto request message; value of command field is "saveto". - * For debugging purposes, save to a temporaryfile (named by - * argument 'tmpfile') the contents of file named by argument - * 'file'. The server does not currently send a response to a - * "saveto" request. - */ - export interface SavetoRequest extends FileRequest { - command: CommandTypes.Saveto; - arguments: SavetoRequestArgs; - } - /** - * Arguments for navto request message. - */ - export interface NavtoRequestArgs { - /** - * Search term to navigate to from current location; term can - * be '.*' or an identifier prefix. - */ - searchValue: string; - /** - * Optional limit on the number of items to return. - */ - maxResultCount?: number; - /** - * The file for the request (absolute pathname required). - */ - file?: string; - /** - * Optional flag to indicate we want results for just the current file - * or the entire project. - */ - currentFileOnly?: boolean; - projectFileName?: string; - } - /** - * Navto request message; value of command field is "navto". - * Return list of objects giving file locations and symbols that - * match the search term given in argument 'searchTerm'. The - * context for the search is given by the named file. - */ - export interface NavtoRequest extends Request { - command: CommandTypes.Navto; - arguments: NavtoRequestArgs; - } - /** - * An item found in a navto response. - */ - export interface NavtoItem extends FileSpan { - /** - * The symbol's name. - */ - name: string; - /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ - kind: ScriptElementKind; - /** - * exact, substring, or prefix. - */ - matchKind: string; - /** - * If this was a case sensitive or insensitive match. - */ - isCaseSensitive: boolean; - /** - * Optional modifiers for the kind (such as 'public'). - */ - kindModifiers?: string; - /** - * Name of symbol's container symbol (if any); for example, - * the class name if symbol is a class member. - */ - containerName?: string; - /** - * Kind of symbol's container symbol (if any). - */ - containerKind?: ScriptElementKind; - } - /** - * Navto response message. Body is an array of navto items. Each - * item gives a symbol that matched the search term. - */ - export interface NavtoResponse extends Response { - body?: NavtoItem[]; - } - /** - * Arguments for change request message. - */ - export interface ChangeRequestArgs extends FormatRequestArgs { - /** - * Optional string to insert at location (file, line, offset). - */ - insertString?: string; - } - /** - * Change request message; value of command field is "change". - * Update the server's view of the file named by argument 'file'. - * Server does not currently send a response to a change request. - */ - export interface ChangeRequest extends FileLocationRequest { - command: CommandTypes.Change; - arguments: ChangeRequestArgs; - } - /** - * Response to "brace" request. - */ - export interface BraceResponse extends Response { - body?: TextSpan[]; - } - /** - * Brace matching request; value of command field is "brace". - * Return response giving the file locations of matching braces - * found in file at location line, offset. - */ - export interface BraceRequest extends FileLocationRequest { - command: CommandTypes.Brace; - } - /** - * NavBar items request; value of command field is "navbar". - * Return response giving the list of navigation bar entries - * extracted from the requested file. - */ - export interface NavBarRequest extends FileRequest { - command: CommandTypes.NavBar; - } - /** - * NavTree request; value of command field is "navtree". - * Return response giving the navigation tree of the requested file. - */ - export interface NavTreeRequest extends FileRequest { - command: CommandTypes.NavTree; - } - export interface NavigationBarItem { - /** - * The item's display text. - */ - text: string; - /** - * The symbol's kind (such as 'className' or 'parameterName'). - */ - kind: ScriptElementKind; - /** - * Optional modifiers for the kind (such as 'public'). - */ - kindModifiers?: string; - /** - * The definition locations of the item. - */ - spans: TextSpan[]; - /** - * Optional children. - */ - childItems?: NavigationBarItem[]; - /** - * Number of levels deep this item should appear. - */ - indent: number; - } - /** protocol.NavigationTree is identical to ts.NavigationTree, except using protocol.TextSpan instead of ts.TextSpan */ - export interface NavigationTree { - text: string; - kind: ScriptElementKind; - kindModifiers: string; - spans: TextSpan[]; - nameSpan: TextSpan | undefined; - childItems?: NavigationTree[]; - } - export type TelemetryEventName = "telemetry"; - export interface TelemetryEvent extends Event { - event: TelemetryEventName; - body: TelemetryEventBody; - } - export interface TelemetryEventBody { - telemetryEventName: string; - payload: any; - } - export type TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed"; - export interface TypesInstallerInitializationFailedEvent extends Event { - event: TypesInstallerInitializationFailedEventName; - body: TypesInstallerInitializationFailedEventBody; - } - export interface TypesInstallerInitializationFailedEventBody { - message: string; - } - export type TypingsInstalledTelemetryEventName = "typingsInstalled"; - export interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody { - telemetryEventName: TypingsInstalledTelemetryEventName; - payload: TypingsInstalledTelemetryEventPayload; - } - export interface TypingsInstalledTelemetryEventPayload { - /** - * Comma separated list of installed typing packages - */ - installedPackages: string; - /** - * true if install request succeeded, otherwise - false - */ - installSuccess: boolean; - /** - * version of typings installer - */ - typingsInstallerVersion: string; - } - export type BeginInstallTypesEventName = "beginInstallTypes"; - export type EndInstallTypesEventName = "endInstallTypes"; - export interface BeginInstallTypesEvent extends Event { - event: BeginInstallTypesEventName; - body: BeginInstallTypesEventBody; - } - export interface EndInstallTypesEvent extends Event { - event: EndInstallTypesEventName; - body: EndInstallTypesEventBody; - } - export interface InstallTypesEventBody { - /** - * correlation id to match begin and end events - */ - eventId: number; - /** - * list of packages to install - */ - packages: readonly string[]; - } - export interface BeginInstallTypesEventBody extends InstallTypesEventBody { - } - export interface EndInstallTypesEventBody extends InstallTypesEventBody { - /** - * true if installation succeeded, otherwise false - */ - success: boolean; - } - export interface NavBarResponse extends Response { - body?: NavigationBarItem[]; - } - export interface NavTreeResponse extends Response { - body?: NavigationTree; - } - export type CallHierarchyItem = ChangePropertyTypes; - export interface CallHierarchyIncomingCall { - from: CallHierarchyItem; - fromSpans: TextSpan[]; - } - export interface CallHierarchyOutgoingCall { - to: CallHierarchyItem; - fromSpans: TextSpan[]; - } - export interface PrepareCallHierarchyRequest extends FileLocationRequest { - command: CommandTypes.PrepareCallHierarchy; - } - export interface PrepareCallHierarchyResponse extends Response { - readonly body: CallHierarchyItem | CallHierarchyItem[]; - } - export interface ProvideCallHierarchyIncomingCallsRequest extends FileLocationRequest { - command: CommandTypes.ProvideCallHierarchyIncomingCalls; - } - export interface ProvideCallHierarchyIncomingCallsResponse extends Response { - readonly body: CallHierarchyIncomingCall[]; - } - export interface ProvideCallHierarchyOutgoingCallsRequest extends FileLocationRequest { - command: CommandTypes.ProvideCallHierarchyOutgoingCalls; - } - export interface ProvideCallHierarchyOutgoingCallsResponse extends Response { - readonly body: CallHierarchyOutgoingCall[]; - } - export enum IndentStyle { - None = "None", - Block = "Block", - Smart = "Smart", - } - export type EditorSettings = ChangePropertyTypes; - export type FormatCodeSettings = ChangePropertyTypes; - export type CompilerOptions = ChangePropertyTypes, { - jsx: JsxEmit | ts.JsxEmit; - module: ModuleKind | ts.ModuleKind; - moduleResolution: ModuleResolutionKind | ts.ModuleResolutionKind; - newLine: NewLineKind | ts.NewLineKind; - target: ScriptTarget | ts.ScriptTarget; - }>; - export enum JsxEmit { - None = "none", - Preserve = "preserve", - ReactNative = "react-native", - React = "react", - ReactJSX = "react-jsx", - ReactJSXDev = "react-jsxdev", - } - export enum ModuleKind { - None = "none", - CommonJS = "commonjs", - AMD = "amd", - UMD = "umd", - System = "system", - ES6 = "es6", - ES2015 = "es2015", - ES2020 = "es2020", - ES2022 = "es2022", - ESNext = "esnext", - Node16 = "node16", - NodeNext = "nodenext", - Preserve = "preserve", - } - export enum ModuleResolutionKind { - Classic = "classic", - /** @deprecated Renamed to `Node10` */ - Node = "node", - /** @deprecated Renamed to `Node10` */ - NodeJs = "node", - Node10 = "node10", - Node16 = "node16", - NodeNext = "nodenext", - Bundler = "bundler", - } - export enum NewLineKind { - Crlf = "Crlf", - Lf = "Lf", - } - export enum ScriptTarget { - /** @deprecated */ - ES3 = "es3", - ES5 = "es5", - ES6 = "es6", - ES2015 = "es2015", - ES2016 = "es2016", - ES2017 = "es2017", - ES2018 = "es2018", - ES2019 = "es2019", - ES2020 = "es2020", - ES2021 = "es2021", - ES2022 = "es2022", - ES2023 = "es2023", - ESNext = "esnext", - JSON = "json", - Latest = "esnext", - } - } - namespace typingsInstaller { - interface Log { - isEnabled(): boolean; - writeLine(text: string): void; - } - type RequestCompletedAction = (success: boolean) => void; - interface PendingRequest { - requestId: number; - packageNames: string[]; - cwd: string; - onRequestCompleted: RequestCompletedAction; - } - abstract class TypingsInstaller { - protected readonly installTypingHost: InstallTypingHost; - private readonly globalCachePath; - private readonly safeListPath; - private readonly typesMapLocation; - private readonly throttleLimit; - protected readonly log: Log; - private readonly packageNameToTypingLocation; - private readonly missingTypingsSet; - private readonly knownCachesSet; - private readonly projectWatchers; - private safeList; - private pendingRunRequests; - private installRunCount; - private inFlightRequestCount; - abstract readonly typesRegistry: Map>; - constructor(installTypingHost: InstallTypingHost, globalCachePath: string, safeListPath: Path, typesMapLocation: Path, throttleLimit: number, log?: Log); - closeProject(req: CloseProject): void; - private closeWatchers; - install(req: DiscoverTypings): void; - private initializeSafeList; - private processCacheLocation; - private filterTypings; - protected ensurePackageDirectoryExists(directory: string): void; - private installTypings; - private ensureDirectoryExists; - private watchFiles; - private createSetTypings; - private installTypingsAsync; - private executeWithThrottling; - protected abstract installWorker(requestId: number, packageNames: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void; - protected abstract sendResponse(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | WatchTypingLocations): void; - protected readonly latestDistTag = "latest"; - } - } type ActionSet = "action::set"; type ActionInvalidate = "action::invalidate"; type ActionPackageInstalled = "action::packageInstalled"; @@ -2643,990 +131,8 @@ declare namespace ts { readonly files: readonly string[] | undefined; readonly kind: ActionWatchTypingLocations; } - interface CompressedData { - length: number; - compressionKind: string; - data: any; - } - type ModuleImportResult = { - module: {}; - error: undefined; - } | { - module: undefined; - error: { - stack?: string; - message?: string; - }; - }; - /** @deprecated Use {@link ModuleImportResult} instead. */ - type RequireResult = ModuleImportResult; - interface ServerHost extends System { - watchFile(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher; - watchDirectory(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher; - preferNonRecursiveWatch?: boolean; - setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any; - clearTimeout(timeoutId: any): void; - setImmediate(callback: (...args: any[]) => void, ...args: any[]): any; - clearImmediate(timeoutId: any): void; - gc?(): void; - trace?(s: string): void; - require?(initialPath: string, moduleName: string): ModuleImportResult; - } - interface InstallPackageOptionsWithProject extends InstallPackageOptions { - projectName: string; - projectRootPath: Path; - } - interface ITypingsInstaller { - isKnownTypesPackageName(name: string): boolean; - installPackage(options: InstallPackageOptionsWithProject): Promise; - enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray | undefined): void; - attach(projectService: ProjectService): void; - onProjectClosed(p: Project): void; - readonly globalTypingsCacheLocation: string | undefined; - } - function createInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray, cachePath?: string): DiscoverTypings; - function toNormalizedPath(fileName: string): NormalizedPath; - function normalizedPathToPath(normalizedPath: NormalizedPath, currentDirectory: string, getCanonicalFileName: (f: string) => string): Path; - function asNormalizedPath(fileName: string): NormalizedPath; - function createNormalizedPathMap(): NormalizedPathMap; - function isInferredProjectName(name: string): boolean; - function makeInferredProjectName(counter: number): string; - function createSortedArray(): SortedArray; - enum LogLevel { - terse = 0, - normal = 1, - requestTime = 2, - verbose = 3, - } - const emptyArray: SortedReadonlyArray; - interface Logger { - close(): void; - hasLevel(level: LogLevel): boolean; - loggingEnabled(): boolean; - perftrc(s: string): void; - info(s: string): void; - startGroup(): void; - endGroup(): void; - msg(s: string, type?: Msg): void; - getLogFileName(): string | undefined; - } - enum Msg { - Err = "Err", - Info = "Info", - Perf = "Perf", - } - namespace Errors { - function ThrowNoProject(): never; - function ThrowProjectLanguageServiceDisabled(): never; - function ThrowProjectDoesNotContainDocument(fileName: string, project: Project): never; - } - type NormalizedPath = string & { - __normalizedPathTag: any; - }; - interface NormalizedPathMap { - get(path: NormalizedPath): T | undefined; - set(path: NormalizedPath, value: T): void; - contains(path: NormalizedPath): boolean; - remove(path: NormalizedPath): void; - } - function isDynamicFileName(fileName: NormalizedPath): boolean; - class ScriptInfo { - private readonly host; - readonly fileName: NormalizedPath; - readonly scriptKind: ScriptKind; - readonly hasMixedContent: boolean; - readonly path: Path; - /** - * All projects that include this file - */ - readonly containingProjects: Project[]; - private formatSettings; - private preferences; - private realpath; - constructor(host: ServerHost, fileName: NormalizedPath, scriptKind: ScriptKind, hasMixedContent: boolean, path: Path, initialVersion?: number); - isScriptOpen(): boolean; - open(newText: string | undefined): void; - close(fileExists?: boolean): void; - getSnapshot(): IScriptSnapshot; - private ensureRealPath; - getFormatCodeSettings(): FormatCodeSettings | undefined; - getPreferences(): protocol.UserPreferences | undefined; - attachToProject(project: Project): boolean; - isAttached(project: Project): boolean; - detachFromProject(project: Project): void; - detachAllProjects(): void; - getDefaultProject(): Project; - registerFileUpdate(): void; - setOptions(formatSettings: FormatCodeSettings, preferences: protocol.UserPreferences | undefined): void; - getLatestVersion(): string; - saveTo(fileName: string): void; - reloadFromFile(tempFileName?: NormalizedPath): boolean; - editContent(start: number, end: number, newText: string): void; - markContainingProjectsAsDirty(): void; - isOrphan(): boolean; - /** - * @param line 1 based index - */ - lineToTextSpan(line: number): TextSpan; - /** - * @param line 1 based index - * @param offset 1 based index - */ - lineOffsetToPosition(line: number, offset: number): number; - positionToLineOffset(position: number): protocol.Location; - isJavaScript(): boolean; - } - function allRootFilesAreJsOrDts(project: Project): boolean; - function allFilesAreJsOrDts(project: Project): boolean; - enum ProjectKind { - Inferred = 0, - Configured = 1, - External = 2, - AutoImportProvider = 3, - Auxiliary = 4, - } - interface PluginCreateInfo { - project: Project; - languageService: LanguageService; - languageServiceHost: LanguageServiceHost; - serverHost: ServerHost; - session?: Session; - config: any; - } - interface PluginModule { - create(createInfo: PluginCreateInfo): LanguageService; - getExternalFiles?(proj: Project, updateLevel: ProgramUpdateLevel): string[]; - onConfigurationChanged?(config: any): void; - } - interface PluginModuleWithName { - name: string; - module: PluginModule; - } - type PluginModuleFactory = (mod: { - typescript: typeof ts; - }) => PluginModule; - abstract class Project implements LanguageServiceHost, ModuleResolutionHost { - readonly projectKind: ProjectKind; - readonly projectService: ProjectService; - private documentRegistry; - private compilerOptions; - compileOnSaveEnabled: boolean; - protected watchOptions: WatchOptions | undefined; - private rootFilesMap; - private program; - private externalFiles; - private missingFilesMap; - private generatedFilesMap; - private hasAddedorRemovedFiles; - private hasAddedOrRemovedSymlinks; - protected languageService: LanguageService; - languageServiceEnabled: boolean; - readonly trace?: (s: string) => void; - readonly realpath?: (path: string) => string; - private builderState; - private updatedFileNames; - private lastReportedFileNames; - private lastReportedVersion; - protected projectErrors: Diagnostic[] | undefined; - protected isInitialLoadPending: () => boolean; - private typingsCache; - private typingWatchers; - private readonly cancellationToken; - isNonTsProject(): boolean; - isJsOnlyProject(): boolean; - static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void): {} | undefined; - private exportMapCache; - private changedFilesForExportMapCache; - private moduleSpecifierCache; - private symlinks; - readonly jsDocParsingMode: JSDocParsingMode | undefined; - isKnownTypesPackageName(name: string): boolean; - installPackage(options: InstallPackageOptions): Promise; - getCompilationSettings(): ts.CompilerOptions; - getCompilerOptions(): ts.CompilerOptions; - getNewLine(): string; - getProjectVersion(): string; - getProjectReferences(): readonly ProjectReference[] | undefined; - getScriptFileNames(): string[]; - private getOrCreateScriptInfoAndAttachToProject; - getScriptKind(fileName: string): ts.ScriptKind; - getScriptVersion(filename: string): string; - getScriptSnapshot(filename: string): IScriptSnapshot | undefined; - getCancellationToken(): HostCancellationToken; - getCurrentDirectory(): string; - getDefaultLibFileName(): string; - useCaseSensitiveFileNames(): boolean; - readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[]; - readFile(fileName: string): string | undefined; - writeFile(fileName: string, content: string): void; - fileExists(file: string): boolean; - directoryExists(path: string): boolean; - getDirectories(path: string): string[]; - log(s: string): void; - error(s: string): void; - private setInternalCompilerOptionsForEmittingJsFiles; - /** - * Get the errors that dont have any file name associated - */ - getGlobalProjectErrors(): readonly Diagnostic[]; - /** - * Get all the project errors - */ - getAllProjectErrors(): readonly Diagnostic[]; - setProjectErrors(projectErrors: Diagnostic[] | undefined): void; - getLanguageService(ensureSynchronized?: boolean): LanguageService; - getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[]; - /** - * Returns true if emit was conducted - */ - emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): EmitResult; - enableLanguageService(): void; - disableLanguageService(lastFileExceededProgramSize?: string): void; - getProjectName(): string; - protected removeLocalTypingsFromTypeAcquisition(newTypeAcquisition: TypeAcquisition): TypeAcquisition; - getExternalFiles(updateLevel?: ProgramUpdateLevel): SortedReadonlyArray; - getSourceFile(path: Path): ts.SourceFile | undefined; - close(): void; - private detachScriptInfoIfNotRoot; - isClosed(): boolean; - hasRoots(): boolean; - getRootFiles(): NormalizedPath[]; - getRootScriptInfos(): ts.server.ScriptInfo[]; - getScriptInfos(): ScriptInfo[]; - getExcludedFiles(): readonly NormalizedPath[]; - getFileNames(excludeFilesFromExternalLibraries?: boolean, excludeConfigFiles?: boolean): ts.server.NormalizedPath[]; - hasConfigFile(configFilePath: NormalizedPath): boolean; - containsScriptInfo(info: ScriptInfo): boolean; - containsFile(filename: NormalizedPath, requireOpen?: boolean): boolean; - isRoot(info: ScriptInfo): boolean; - addRoot(info: ScriptInfo, fileName?: NormalizedPath): void; - addMissingFileRoot(fileName: NormalizedPath): void; - removeFile(info: ScriptInfo, fileExists: boolean, detachFromProject: boolean): void; - registerFileUpdate(fileName: string): void; - /** - * Updates set of files that contribute to this project - * @returns: true if set of files in the project stays the same and false - otherwise. - */ - updateGraph(): boolean; - private closeWatchingTypingLocations; - private onTypingInstallerWatchInvoke; - protected removeExistingTypings(include: string[]): string[]; - private updateGraphWorker; - private detachScriptInfoFromProject; - private addMissingFileWatcher; - private isWatchedMissingFile; - private createGeneratedFileWatcher; - private isValidGeneratedFileWatcher; - private clearGeneratedFileWatch; - getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo | undefined; - getScriptInfo(uncheckedFileName: string): ts.server.ScriptInfo | undefined; - filesToString(writeProjectFileNames: boolean): string; - private filesToStringWorker; - setCompilerOptions(compilerOptions: CompilerOptions): void; - setTypeAcquisition(newTypeAcquisition: TypeAcquisition | undefined): void; - getTypeAcquisition(): ts.TypeAcquisition; - protected removeRoot(info: ScriptInfo): void; - protected enableGlobalPlugins(options: CompilerOptions): void; - protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[]): void; - /** Starts a new check for diagnostics. Call this if some file has updated that would cause diagnostics to be changed. */ - refreshDiagnostics(): void; - private isDefaultProjectForOpenFiles; - private getCompilerOptionsForNoDtsResolutionProject; - } - /** - * If a file is opened and no tsconfig (or jsconfig) is found, - * the file and its imports/references are put into an InferredProject. - */ - class InferredProject extends Project { - private _isJsInferredProject; - toggleJsInferredProject(isJsInferredProject: boolean): void; - setCompilerOptions(options?: CompilerOptions): void; - /** this is canonical project root path */ - readonly projectRootPath: string | undefined; - addRoot(info: ScriptInfo): void; - removeRoot(info: ScriptInfo): void; - isProjectWithSingleRoot(): boolean; - close(): void; - getTypeAcquisition(): TypeAcquisition; - } - class AutoImportProviderProject extends Project { - private hostProject; - private static readonly maxDependencies; - private rootFileNames; - updateGraph(): boolean; - hasRoots(): boolean; - getScriptFileNames(): string[]; - getLanguageService(): never; - getHostForAutoImportProvider(): never; - getProjectReferences(): readonly ts.ProjectReference[] | undefined; - } - /** - * If a file is opened, the server will look for a tsconfig (or jsconfig) - * and if successful create a ConfiguredProject for it. - * Otherwise it will create an InferredProject. - */ - class ConfiguredProject extends Project { - readonly canonicalConfigFilePath: NormalizedPath; - private projectReferences; - private compilerHost?; - private releaseParsedConfig; - /** - * If the project has reload from disk pending, it reloads (and then updates graph as part of that) instead of just updating the graph - * @returns: true if set of files in the project stays the same and false - otherwise. - */ - updateGraph(): boolean; - getConfigFilePath(): ts.server.NormalizedPath; - getProjectReferences(): readonly ProjectReference[] | undefined; - updateReferences(refs: readonly ProjectReference[] | undefined): void; - /** - * Get the errors that dont have any file name associated - */ - getGlobalProjectErrors(): readonly Diagnostic[]; - /** - * Get all the project errors - */ - getAllProjectErrors(): readonly Diagnostic[]; - setProjectErrors(projectErrors: Diagnostic[]): void; - close(): void; - getEffectiveTypeRoots(): string[]; - } - /** - * Project whose configuration is handled externally, such as in a '.csproj'. - * These are created only if a host explicitly calls `openExternalProject`. - */ - class ExternalProject extends Project { - externalProjectName: string; - compileOnSaveEnabled: boolean; - excludedFiles: readonly NormalizedPath[]; - updateGraph(): boolean; - getExcludedFiles(): readonly ts.server.NormalizedPath[]; - } - function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings; - function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin; - function convertWatchOptions(protocolOptions: protocol.ExternalProjectCompilerOptions, currentDirectory?: string): WatchOptionsAndErrors | undefined; - function convertTypeAcquisition(protocolOptions: protocol.InferredProjectCompilerOptions): TypeAcquisition | undefined; - function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind; - function convertScriptKindName(scriptKindName: protocol.ScriptKindName): ScriptKind.Unknown | ScriptKind.JS | ScriptKind.JSX | ScriptKind.TS | ScriptKind.TSX; - const maxProgramSizeForNonTsFiles: number; - const ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground"; - interface ProjectsUpdatedInBackgroundEvent { - eventName: typeof ProjectsUpdatedInBackgroundEvent; - data: { - openFiles: string[]; - }; - } - const ProjectLoadingStartEvent = "projectLoadingStart"; - interface ProjectLoadingStartEvent { - eventName: typeof ProjectLoadingStartEvent; - data: { - project: Project; - reason: string; - }; - } - const ProjectLoadingFinishEvent = "projectLoadingFinish"; - interface ProjectLoadingFinishEvent { - eventName: typeof ProjectLoadingFinishEvent; - data: { - project: Project; - }; - } - const LargeFileReferencedEvent = "largeFileReferenced"; - interface LargeFileReferencedEvent { - eventName: typeof LargeFileReferencedEvent; - data: { - file: string; - fileSize: number; - maxFileSize: number; - }; - } - const ConfigFileDiagEvent = "configFileDiag"; - interface ConfigFileDiagEvent { - eventName: typeof ConfigFileDiagEvent; - data: { - triggerFile: string; - configFileName: string; - diagnostics: readonly Diagnostic[]; - }; - } - const ProjectLanguageServiceStateEvent = "projectLanguageServiceState"; - interface ProjectLanguageServiceStateEvent { - eventName: typeof ProjectLanguageServiceStateEvent; - data: { - project: Project; - languageServiceEnabled: boolean; - }; - } - const ProjectInfoTelemetryEvent = "projectInfo"; - /** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */ - interface ProjectInfoTelemetryEvent { - readonly eventName: typeof ProjectInfoTelemetryEvent; - readonly data: ProjectInfoTelemetryEventData; - } - const OpenFileInfoTelemetryEvent = "openFileInfo"; - /** - * Info that we may send about a file that was just opened. - * Info about a file will only be sent once per session, even if the file changes in ways that might affect the info. - * Currently this is only sent for '.js' files. - */ - interface OpenFileInfoTelemetryEvent { - readonly eventName: typeof OpenFileInfoTelemetryEvent; - readonly data: OpenFileInfoTelemetryEventData; - } - const CreateFileWatcherEvent: protocol.CreateFileWatcherEventName; - interface CreateFileWatcherEvent { - readonly eventName: protocol.CreateFileWatcherEventName; - readonly data: protocol.CreateFileWatcherEventBody; - } - const CreateDirectoryWatcherEvent: protocol.CreateDirectoryWatcherEventName; - interface CreateDirectoryWatcherEvent { - readonly eventName: protocol.CreateDirectoryWatcherEventName; - readonly data: protocol.CreateDirectoryWatcherEventBody; - } - const CloseFileWatcherEvent: protocol.CloseFileWatcherEventName; - interface CloseFileWatcherEvent { - readonly eventName: protocol.CloseFileWatcherEventName; - readonly data: protocol.CloseFileWatcherEventBody; - } - interface ProjectInfoTelemetryEventData { - /** Cryptographically secure hash of project file location. */ - readonly projectId: string; - /** Count of file extensions seen in the project. */ - readonly fileStats: FileStats; - /** - * Any compiler options that might contain paths will be taken out. - * Enum compiler options will be converted to strings. - */ - readonly compilerOptions: CompilerOptions; - readonly extends: boolean | undefined; - readonly files: boolean | undefined; - readonly include: boolean | undefined; - readonly exclude: boolean | undefined; - readonly compileOnSave: boolean; - readonly typeAcquisition: ProjectInfoTypeAcquisitionData; - readonly configFileName: "tsconfig.json" | "jsconfig.json" | "other"; - readonly projectType: "external" | "configured"; - readonly languageServiceEnabled: boolean; - /** TypeScript version used by the server. */ - readonly version: string; - } - interface OpenFileInfoTelemetryEventData { - readonly info: OpenFileInfo; - } - interface ProjectInfoTypeAcquisitionData { - readonly enable: boolean | undefined; - readonly include: boolean; - readonly exclude: boolean; - } - interface FileStats { - readonly js: number; - readonly jsSize?: number; - readonly jsx: number; - readonly jsxSize?: number; - readonly ts: number; - readonly tsSize?: number; - readonly tsx: number; - readonly tsxSize?: number; - readonly dts: number; - readonly dtsSize?: number; - readonly deferred: number; - readonly deferredSize?: number; - } - interface OpenFileInfo { - readonly checkJs: boolean; - } - type ProjectServiceEvent = LargeFileReferencedEvent | ProjectsUpdatedInBackgroundEvent | ProjectLoadingStartEvent | ProjectLoadingFinishEvent | ConfigFileDiagEvent | ProjectLanguageServiceStateEvent | ProjectInfoTelemetryEvent | OpenFileInfoTelemetryEvent | CreateFileWatcherEvent | CreateDirectoryWatcherEvent | CloseFileWatcherEvent; - type ProjectServiceEventHandler = (event: ProjectServiceEvent) => void; - interface SafeList { - [name: string]: { - match: RegExp; - exclude?: (string | number)[][]; - types?: string[]; - }; - } - interface TypesMapFile { - typesMap: SafeList; - simpleMap: { - [libName: string]: string; - }; - } - interface HostConfiguration { - formatCodeOptions: FormatCodeSettings; - preferences: protocol.UserPreferences; - hostInfo: string; - extraFileExtensions?: FileExtensionInfo[]; - watchOptions?: WatchOptions; - } - interface OpenConfiguredProjectResult { - configFileName?: NormalizedPath; - configFileErrors?: readonly Diagnostic[]; - } - const nullTypingsInstaller: ITypingsInstaller; - interface ProjectServiceOptions { - host: ServerHost; - logger: Logger; - cancellationToken: HostCancellationToken; - useSingleInferredProject: boolean; - useInferredProjectPerProjectRoot: boolean; - typingsInstaller?: ITypingsInstaller; - eventHandler?: ProjectServiceEventHandler; - canUseWatchEvents?: boolean; - suppressDiagnosticEvents?: boolean; - throttleWaitMilliseconds?: number; - globalPlugins?: readonly string[]; - pluginProbeLocations?: readonly string[]; - allowLocalPluginLoads?: boolean; - typesMapLocation?: string; - serverMode?: LanguageServiceMode; - session: Session | undefined; - jsDocParsingMode?: JSDocParsingMode; - } - interface WatchOptionsAndErrors { - watchOptions: WatchOptions; - errors: Diagnostic[] | undefined; - } - class ProjectService { - private readonly nodeModulesWatchers; - private readonly filenameToScriptInfoVersion; - private readonly allJsFilesForOpenFileTelemetry; - private readonly externalProjectToConfiguredProjectMap; - /** - * external projects (configuration and list of root files is not controlled by tsserver) - */ - readonly externalProjects: ExternalProject[]; - /** - * projects built from openFileRoots - */ - readonly inferredProjects: InferredProject[]; - /** - * projects specified by a tsconfig.json file - */ - readonly configuredProjects: Map; - /** - * Open files: with value being project root path, and key being Path of the file that is open - */ - readonly openFiles: Map; - private readonly configFileForOpenFiles; - private rootOfInferredProjects; - private readonly openFilesWithNonRootedDiskPath; - private compilerOptionsForInferredProjects; - private compilerOptionsForInferredProjectsPerProjectRoot; - private watchOptionsForInferredProjects; - private watchOptionsForInferredProjectsPerProjectRoot; - private typeAcquisitionForInferredProjects; - private typeAcquisitionForInferredProjectsPerProjectRoot; - private readonly projectToSizeMap; - private readonly hostConfiguration; - private safelist; - private readonly legacySafelist; - private pendingProjectUpdates; - private pendingOpenFileProjectUpdates?; - readonly currentDirectory: NormalizedPath; - readonly toCanonicalFileName: (f: string) => string; - readonly host: ServerHost; - readonly logger: Logger; - readonly cancellationToken: HostCancellationToken; - readonly useSingleInferredProject: boolean; - readonly useInferredProjectPerProjectRoot: boolean; - readonly typingsInstaller: ITypingsInstaller; - private readonly globalCacheLocationDirectoryPath; - readonly throttleWaitMilliseconds?: number; - private readonly suppressDiagnosticEvents?; - readonly globalPlugins: readonly string[]; - readonly pluginProbeLocations: readonly string[]; - readonly allowLocalPluginLoads: boolean; - readonly typesMapLocation: string | undefined; - readonly serverMode: LanguageServiceMode; - private readonly seenProjects; - private readonly sharedExtendedConfigFileWatchers; - private readonly extendedConfigCache; - private packageJsonFilesMap; - private incompleteCompletionsCache; - private performanceEventHandler?; - private pendingPluginEnablements?; - private currentPluginEnablementPromise?; - readonly jsDocParsingMode: JSDocParsingMode | undefined; - constructor(opts: ProjectServiceOptions); - toPath(fileName: string): Path; - private loadTypesMap; - updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse): void; - private delayUpdateProjectGraph; - private delayUpdateProjectGraphs; - setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.InferredProjectCompilerOptions, projectRootPath?: string): void; - findProject(projectName: string): Project | undefined; - getDefaultProjectForFile(fileName: NormalizedPath, ensureProject: boolean): Project | undefined; - private tryGetDefaultProjectForEnsuringConfiguredProjectForFile; - private doEnsureDefaultProjectForFile; - getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName: string): ScriptInfo | undefined; - private ensureProjectStructuresUptoDate; - getFormatCodeOptions(file: NormalizedPath): FormatCodeSettings; - getPreferences(file: NormalizedPath): protocol.UserPreferences; - getHostFormatCodeOptions(): FormatCodeSettings; - getHostPreferences(): protocol.UserPreferences; - private onSourceFileChanged; - private handleSourceMapProjects; - private delayUpdateSourceInfoProjects; - private delayUpdateProjectsOfScriptInfoPath; - private handleDeletedFile; - private watchWildcardDirectory; - private onWildCardDirectoryWatcherInvoke; - private delayUpdateProjectsFromParsedConfigOnConfigFileChange; - private onConfigFileChanged; - private removeProject; - private assignOrphanScriptInfosToInferredProject; - private closeOpenFile; - private deleteScriptInfo; - private configFileExists; - private createConfigFileWatcherForParsedConfig; - private forEachConfigFileLocation; - private getConfigFileNameForFileFromCache; - private setConfigFileNameForFileInCache; - private printProjects; - private getConfiguredProjectByCanonicalConfigFilePath; - private findExternalProjectByProjectName; - private getFilenameForExceededTotalSizeLimitForNonTsFiles; - private createExternalProject; - private addFilesToNonInferredProject; - private loadConfiguredProject; - private updateNonInferredProjectFiles; - private updateRootAndOptionsOfNonInferredProject; - private reloadFileNamesOfParsedConfig; - private clearSemanticCache; - private getOrCreateInferredProjectForProjectRootPathIfEnabled; - private getOrCreateSingleInferredProjectIfEnabled; - private getOrCreateSingleInferredWithoutProjectRoot; - private createInferredProject; - getScriptInfo(uncheckedFileName: string): ScriptInfo | undefined; - private watchClosedScriptInfo; - private createNodeModulesWatcher; - private watchClosedScriptInfoInNodeModules; - private getModifiedTime; - private refreshScriptInfo; - private refreshScriptInfosInDirectory; - private stopWatchingScriptInfo; - private getOrCreateScriptInfoNotOpenedByClientForNormalizedPath; - getOrCreateScriptInfoForNormalizedPath(fileName: NormalizedPath, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, hostToQueryFileExistsOn?: { - fileExists(path: string): boolean; - }): ScriptInfo | undefined; - private getOrCreateScriptInfoWorker; - /** - * This gets the script info for the normalized path. If the path is not rooted disk path then the open script info with project root context is preferred - */ - getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo | undefined; - getScriptInfoForPath(fileName: Path): ScriptInfo | undefined; - private addSourceInfoToSourceMap; - private addMissingSourceMapFile; - setHostConfiguration(args: protocol.ConfigureRequestArguments): void; - private getWatchOptionsFromProjectWatchOptions; - closeLog(): void; - private sendSourceFileChange; - /** - * This function rebuilds the project for every file opened by the client - * This does not reload contents of open files from disk. But we could do that if needed - */ - reloadProjects(): void; - private removeRootOfInferredProjectIfNowPartOfOtherProject; - private ensureProjectForOpenFiles; - /** - * Open file whose contents is managed by the client - * @param filename is absolute pathname - * @param fileContent is a known version of the file content that is more up to date than the one on disk - */ - openClientFile(fileName: string, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: string): OpenConfiguredProjectResult; - private findExternalProjectContainingOpenScriptInfo; - private getOrCreateOpenScriptInfo; - private assignProjectToOpenedScriptInfo; - private tryFindDefaultConfiguredProjectForOpenScriptInfo; - private tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo; - private ensureProjectChildren; - private cleanupConfiguredProjects; - private cleanupProjectsAndScriptInfos; - private tryInvokeWildCardDirectories; - openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult; - private removeOrphanScriptInfos; - private telemetryOnOpenFile; - /** - * Close file whose contents is managed by the client - * @param filename is absolute pathname - */ - closeClientFile(uncheckedFileName: string): void; - private collectChanges; - closeExternalProject(uncheckedFileName: string): void; - openExternalProjects(projects: protocol.ExternalProject[]): void; - private static readonly filenameEscapeRegexp; - private static escapeFilenameForRegex; - resetSafeList(): void; - applySafeList(proj: protocol.ExternalProject): NormalizedPath[]; - private applySafeListWorker; - openExternalProject(proj: protocol.ExternalProject): void; - hasDeferredExtension(): boolean; - private endEnablePlugin; - private enableRequestedPluginsAsync; - private enableRequestedPluginsWorker; - configurePlugin(args: protocol.ConfigurePluginRequestArguments): void; - private watchPackageJsonFile; - private onPackageJsonChange; - } - function formatMessage(msg: T, logger: Logger, byteLength: (s: string, encoding: BufferEncoding) => number, newLine: string): string; - interface ServerCancellationToken extends HostCancellationToken { - setRequest(requestId: number): void; - resetRequest(requestId: number): void; - } - const nullCancellationToken: ServerCancellationToken; - /** @deprecated use ts.server.protocol.CommandTypes */ - type CommandNames = protocol.CommandTypes; - /** @deprecated use ts.server.protocol.CommandTypes */ - const CommandNames: any; - type Event = (body: T, eventName: string) => void; - interface EventSender { - event: Event; - } - interface SessionOptions { - host: ServerHost; - cancellationToken: ServerCancellationToken; - useSingleInferredProject: boolean; - useInferredProjectPerProjectRoot: boolean; - typingsInstaller?: ITypingsInstaller; - byteLength: (buf: string, encoding?: BufferEncoding) => number; - hrtime: (start?: [ - number, - number, - ]) => [ - number, - number, - ]; - logger: Logger; - /** - * If falsy, all events are suppressed. - */ - canUseEvents: boolean; - canUseWatchEvents?: boolean; - eventHandler?: ProjectServiceEventHandler; - /** Has no effect if eventHandler is also specified. */ - suppressDiagnosticEvents?: boolean; - serverMode?: LanguageServiceMode; - throttleWaitMilliseconds?: number; - noGetErrOnBackgroundUpdate?: boolean; - globalPlugins?: readonly string[]; - pluginProbeLocations?: readonly string[]; - allowLocalPluginLoads?: boolean; - typesMapLocation?: string; - } - class Session implements EventSender { - private readonly gcTimer; - protected projectService: ProjectService; - private changeSeq; - private performanceData; - private currentRequestId; - private errorCheck; - protected host: ServerHost; - private readonly cancellationToken; - protected readonly typingsInstaller: ITypingsInstaller; - protected byteLength: (buf: string, encoding?: BufferEncoding) => number; - private hrtime; - protected logger: Logger; - protected canUseEvents: boolean; - private suppressDiagnosticEvents?; - private eventHandler; - private readonly noGetErrOnBackgroundUpdate?; - constructor(opts: SessionOptions); - private sendRequestCompletedEvent; - private addPerformanceData; - private addDiagnosticsPerformanceData; - private performanceEventHandler; - private defaultEventHandler; - private projectsUpdatedInBackgroundEvent; - logError(err: Error, cmd: string): void; - private logErrorWorker; - send(msg: protocol.Message): void; - protected writeMessage(msg: protocol.Message): void; - event(body: T, eventName: string): void; - private semanticCheck; - private syntacticCheck; - private suggestionCheck; - private regionSemanticCheck; - private sendDiagnosticsEvent; - private updateErrorCheck; - private cleanProjects; - private cleanup; - private getEncodedSyntacticClassifications; - private getEncodedSemanticClassifications; - private getProject; - private getConfigFileAndProject; - private getConfigFileDiagnostics; - private convertToDiagnosticsWithLinePositionFromDiagnosticFile; - private getCompilerOptionsDiagnostics; - private convertToDiagnosticsWithLinePosition; - private getDiagnosticsWorker; - private getDefinition; - private mapDefinitionInfoLocations; - private getDefinitionAndBoundSpan; - private findSourceDefinition; - private getEmitOutput; - private mapJSDocTagInfo; - private mapDisplayParts; - private mapSignatureHelpItems; - private mapDefinitionInfo; - private static mapToOriginalLocation; - private toFileSpan; - private toFileSpanWithContext; - private getTypeDefinition; - private mapImplementationLocations; - private getImplementation; - private getSyntacticDiagnosticsSync; - private getSemanticDiagnosticsSync; - private getSuggestionDiagnosticsSync; - private getJsxClosingTag; - private getLinkedEditingRange; - private getDocumentHighlights; - private provideInlayHints; - private mapCode; - private setCompilerOptionsForInferredProjects; - private getProjectInfo; - private getProjectInfoWorker; - private getRenameInfo; - private getProjects; - private getDefaultProject; - private getRenameLocations; - private mapRenameInfo; - private toSpanGroups; - private getReferences; - private getFileReferences; - private openClientFile; - private getPosition; - private getPositionInFile; - private getFileAndProject; - private getFileAndLanguageServiceForSyntacticOperation; - private getFileAndProjectWorker; - private getOutliningSpans; - private getTodoComments; - private getDocCommentTemplate; - private getSpanOfEnclosingComment; - private getIndentation; - private getBreakpointStatement; - private getNameOrDottedNameSpan; - private isValidBraceCompletion; - private getQuickInfoWorker; - private getFormattingEditsForRange; - private getFormattingEditsForRangeFull; - private getFormattingEditsForDocumentFull; - private getFormattingEditsAfterKeystrokeFull; - private getFormattingEditsAfterKeystroke; - private getCompletions; - private getCompletionEntryDetails; - private getCompileOnSaveAffectedFileList; - private emitFile; - private getSignatureHelpItems; - private toPendingErrorCheck; - private getDiagnostics; - private change; - private reload; - private saveToTmp; - private closeClientFile; - private mapLocationNavigationBarItems; - private getNavigationBarItems; - private toLocationNavigationTree; - private getNavigationTree; - private getNavigateToItems; - private getFullNavigateToItems; - private getSupportedCodeFixes; - private isLocation; - private extractPositionOrRange; - private getRange; - private getApplicableRefactors; - private getEditsForRefactor; - private getMoveToRefactoringFileSuggestions; - private getPasteEdits; - private organizeImports; - private getEditsForFileRename; - private getCodeFixes; - private getCombinedCodeFix; - private applyCodeActionCommand; - private getStartAndEndPosition; - private mapCodeAction; - private mapCodeFixAction; - private mapPasteEditsAction; - private mapTextChangesToCodeEdits; - private mapTextChangeToCodeEdit; - private convertTextChangeToCodeEdit; - private getBraceMatching; - private getDiagnosticsForProject; - private configurePlugin; - private getSmartSelectionRange; - private toggleLineComment; - private toggleMultilineComment; - private commentSelection; - private uncommentSelection; - private mapSelectionRange; - private getScriptInfoFromProjectService; - private toProtocolCallHierarchyItem; - private toProtocolCallHierarchyIncomingCall; - private toProtocolCallHierarchyOutgoingCall; - private prepareCallHierarchy; - private provideCallHierarchyIncomingCalls; - private provideCallHierarchyOutgoingCalls; - getCanonicalFileName(fileName: string): string; - exit(): void; - private notRequired; - private requiredResponse; - private handlers; - addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse): void; - private setCurrentRequest; - private resetCurrentRequest; - executeWithRequestId(requestId: number, f: () => T): T; - executeCommand(request: protocol.Request): HandlerResponse; - onMessage(message: TMessage): void; - protected parseMessage(message: TMessage): protocol.Request; - protected toStringMessage(message: TMessage): string; - private getFormatOptions; - private getPreferences; - private getHostFormatOptions; - private getHostPreferences; - } - interface HandlerResponse { - response?: {}; - responseRequired?: boolean; - } } - namespace deno { - function setIsNodeSourceFileCallback(callback: IsNodeSourceFileCallback): void; - function setNodeOnlyGlobalNames(names: readonly string[]): void; - function createDenoForkContext({ mergeSymbol, globals, nodeGlobals }: { - mergeSymbol(target: ts.Symbol, source: ts.Symbol, unidirectional?: boolean): ts.Symbol; - globals: ts.SymbolTable; - nodeGlobals: ts.SymbolTable; - }): DenoForkContext; - function tryParseNpmPackageReference(text: string): { - name: string; - versionReq: string | undefined; - subPath: string | undefined; - } | undefined; - function parseNpmPackageReference(text: string): { - name: string; - versionReq: string | undefined; - subPath: string | undefined; - }; - type IsNodeSourceFileCallback = (sourceFile: ts.SourceFile) => boolean; - interface DenoForkContext { - hasNodeSourceFile: (node: ts.Node | undefined) => boolean; - getGlobalsForName: (id: ts.__String) => ts.SymbolTable; - mergeGlobalSymbolTable: (node: ts.Node, source: ts.SymbolTable, unidirectional?: boolean) => void; - combinedGlobals: ts.SymbolTable; - } - interface NpmPackageReference { - name: string; - versionReq: string; - subPath: string | undefined; - } - } - namespace JsTyping { - interface TypingResolutionHost { - directoryExists(path: string): boolean; - fileExists(fileName: string): boolean; - readFile(path: string, encoding?: string): string | undefined; - readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[] | undefined, depth?: number): string[]; - } - } - const versionMajorMinor = "5.6"; + const versionMajorMinor = "5.7"; /** The version of the TypeScript compiler release */ const version: string; /** @@ -4014,10 +520,11 @@ declare namespace ts { JSDocImportTag = 351, SyntaxList = 352, NotEmittedStatement = 353, - PartiallyEmittedExpression = 354, - CommaListExpression = 355, - SyntheticReferenceExpression = 356, - Count = 357, + NotEmittedTypeElement = 354, + PartiallyEmittedExpression = 355, + CommaListExpression = 356, + SyntheticReferenceExpression = 357, + Count = 358, FirstAssignment = 64, LastAssignment = 79, FirstCompoundAssignment = 65, @@ -5129,7 +1636,7 @@ declare namespace ts { interface InstanceofExpression extends BinaryExpression { readonly operatorToken: Token; } - type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement | InstanceofExpression; + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxCallLike | InstanceofExpression; interface AsExpression extends Expression { readonly kind: SyntaxKind.AsExpression; readonly expression: Expression; @@ -5165,6 +1672,7 @@ declare namespace ts { readonly closingElement: JsxClosingElement; } type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement; + type JsxCallLike = JsxOpeningLikeElement | JsxOpeningFragment; type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute; type JsxAttributeName = Identifier | JsxNamespacedName; type JsxTagNameExpression = Identifier | ThisExpression | JsxTagNamePropertyAccess | JsxNamespacedName; @@ -5243,6 +1751,9 @@ declare namespace ts { interface NotEmittedStatement extends Statement { readonly kind: SyntaxKind.NotEmittedStatement; } + interface NotEmittedTypeElement extends TypeElement { + readonly kind: SyntaxKind.NotEmittedTypeElement; + } /** * A list of comma-separated expressions. This node is only created by transformations. */ @@ -6146,7 +2657,7 @@ declare namespace ts { getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined; getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; getIndexInfosOfType(type: Type): readonly IndexInfo[]; - getIndexInfosOfIndexSymbol: (indexSymbol: Symbol) => IndexInfo[]; + getIndexInfosOfIndexSymbol: (indexSymbol: Symbol, siblingSymbols?: Symbol[] | undefined) => IndexInfo[]; getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[]; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; getBaseTypes(type: InterfaceType): BaseType[]; @@ -7013,6 +3524,7 @@ declare namespace ts { moduleDetection?: ModuleDetectionKind; newLine?: NewLineKind; noEmit?: boolean; + noCheck?: boolean; noEmitHelpers?: boolean; noEmitOnError?: boolean; noErrorTruncation?: boolean; @@ -7052,6 +3564,7 @@ declare namespace ts { removeComments?: boolean; resolvePackageJsonExports?: boolean; resolvePackageJsonImports?: boolean; + rewriteRelativeImportExtensions?: boolean; rootDir?: string; rootDirs?: string[]; skipLibCheck?: boolean; @@ -7162,6 +3675,7 @@ declare namespace ts { ES2021 = 8, ES2022 = 9, ES2023 = 10, + ES2024 = 11, ESNext = 99, JSON = 100, Latest = 99, @@ -7844,6 +4358,7 @@ declare namespace ts { createSourceFile(statements: readonly Statement[], endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile; updateSourceFile(node: SourceFile, statements: readonly Statement[], isDeclarationFile?: boolean, referencedFiles?: readonly FileReference[], typeReferences?: readonly FileReference[], hasNoDefaultLib?: boolean, libReferences?: readonly FileReference[]): SourceFile; createNotEmittedStatement(original: Node): NotEmittedStatement; + createNotEmittedTypeElement(): NotEmittedTypeElement; createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression; updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression; createCommaListExpression(elements: readonly Expression[]): CommaListExpression; @@ -8725,6 +5240,7 @@ declare namespace ts { function isTypeOnlyImportDeclaration(node: Node): node is TypeOnlyImportDeclaration; function isTypeOnlyExportDeclaration(node: Node): node is TypeOnlyExportDeclaration; function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyAliasDeclaration; + function isPartOfTypeOnlyImportOrExportDeclaration(node: Node): boolean; function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken; function isImportAttributeName(node: Node): node is ImportAttributeName; function isModifier(node: Node): node is Modifier; @@ -8773,6 +5289,7 @@ declare namespace ts { function isJsxAttributeLike(node: Node): node is JsxAttributeLike; function isStringLiteralOrJsxExpression(node: Node): node is StringLiteral | JsxExpression; function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement; + function isJsxCallLike(node: Node): node is JsxCallLike; function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause; /** True if node is of a kind that may contain comment text. */ function isJSDocCommentContainingNode(node: Node): boolean; @@ -9151,6 +5668,7 @@ declare namespace ts { jsDocParsingMode?: JSDocParsingMode; } function parseCommandLine(commandLine: readonly string[], readFile?: (path: string) => string | undefined): ParsedCommandLine; + function parseBuildCommand(commandLine: readonly string[]): ParsedBuildCommand; /** * Reads the config file, reports errors if any and exits if the config file cannot be found */ @@ -9205,6 +5723,13 @@ declare namespace ts { options: TypeAcquisition; errors: Diagnostic[]; }; + /** Parsed command line for build */ + interface ParsedBuildCommand { + buildOptions: BuildOptions; + watchOptions: WatchOptions | undefined; + projects: string[]; + errors: Diagnostic[]; + } type DiagnosticReporter = (diagnostic: Diagnostic) => void; /** * Reports config file diagnostics @@ -9932,6 +6457,8 @@ declare namespace ts { emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult | undefined; } type InvalidatedProject = UpdateOutputFileStampsProject | BuildInvalidedProject; + /** Returns true if commandline is --build and needs to be parsed useing parseBuildCommand */ + function isBuildCommand(commandLineArgs: readonly string[]): boolean; function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings; /** * Represents an immutable snapshot of a script at a specified time.Once acquired, the @@ -10206,6 +6733,7 @@ declare namespace ts { uncommentSelection(fileName: string, textRange: TextRange): TextChange[]; getSupportedCodeFixes(fileName?: string): readonly string[]; dispose(): void; + preparePasteEditsForFile(fileName: string, copiedTextRanges: TextRange[]): boolean; getPasteEdits(args: PasteEditsArgs, formatOptions: FormatCodeSettings): PasteEdits; } interface JsxClosingTagInfo { diff --git a/ext/net/lib.deno_net.d.ts b/ext/net/lib.deno_net.d.ts index f9dab79e68..6300e66f92 100644 --- a/ext/net/lib.deno_net.d.ts +++ b/ext/net/lib.deno_net.d.ts @@ -136,8 +136,8 @@ declare namespace Deno { /** Make the connection not block the event loop from finishing. */ unref(): void; - readonly readable: ReadableStream; - readonly writable: WritableStream; + readonly readable: ReadableStream>; + readonly writable: WritableStream>; } /** @category Network */ @@ -751,7 +751,7 @@ declare namespace Deno { * `maxDatagramSize`. */ sendDatagram(data: Uint8Array): Promise; /** Receive a datagram. */ - readDatagram(): Promise; + readDatagram(): Promise>; /** The endpoint for this connection. */ readonly endpoint: QuicEndpoint; @@ -800,7 +800,8 @@ declare namespace Deno { * @experimental * @category Network */ - export interface QuicSendStream extends WritableStream { + export interface QuicSendStream + extends WritableStream> { /** Indicates the send priority of this stream relative to other streams for * which the value has been set. */ sendOrder: number; @@ -817,7 +818,8 @@ declare namespace Deno { * @experimental * @category Network */ - export interface QuicReceiveStream extends ReadableStream { + export interface QuicReceiveStream + extends ReadableStream> { /** * 62-bit stream ID, unique within this connection. */ diff --git a/ext/url/lib.deno_url.d.ts b/ext/url/lib.deno_url.d.ts index b5dfd1cf05..0bbfefa3b7 100644 --- a/ext/url/lib.deno_url.d.ts +++ b/ext/url/lib.deno_url.d.ts @@ -5,6 +5,12 @@ /// /// +/** @category URL */ +interface URLSearchParamsIterator + extends IteratorObject { + [Symbol.iterator](): URLSearchParamsIterator; +} + /** @category URL */ interface URLSearchParams { /** Appends a specified key/value pair as a new search parameter. @@ -102,7 +108,7 @@ interface URLSearchParams { * } * ``` */ - keys(): IterableIterator; + keys(): URLSearchParamsIterator; /** Returns an iterator allowing to go through all values contained * in this object. @@ -114,7 +120,7 @@ interface URLSearchParams { * } * ``` */ - values(): IterableIterator; + values(): URLSearchParamsIterator; /** Returns an iterator allowing to go through all key/value * pairs contained in this object. @@ -126,7 +132,7 @@ interface URLSearchParams { * } * ``` */ - entries(): IterableIterator<[string, string]>; + entries(): URLSearchParamsIterator<[string, string]>; /** Returns an iterator allowing to go through all key/value * pairs contained in this object. @@ -138,7 +144,7 @@ interface URLSearchParams { * } * ``` */ - [Symbol.iterator](): IterableIterator<[string, string]>; + [Symbol.iterator](): URLSearchParamsIterator<[string, string]>; /** Returns a query string suitable for use in a URL. * @@ -154,14 +160,18 @@ interface URLSearchParams { * searchParams.size * ``` */ - size: number; + readonly size: number; } /** @category URL */ declare var URLSearchParams: { readonly prototype: URLSearchParams; new ( - init?: Iterable | Record | string, + init?: + | Iterable + | Record + | string + | URLSearchParams, ): URLSearchParams; }; diff --git a/tests/integration/cache_tests.rs b/tests/integration/cache_tests.rs index 3fbed3cbd4..e3f5c8cacd 100644 --- a/tests/integration/cache_tests.rs +++ b/tests/integration/cache_tests.rs @@ -34,16 +34,16 @@ fn cache_matching_package_json_dep_should_not_install_all() { let temp_dir = context.temp_dir(); temp_dir.write( "package.json", - r#"{ "dependencies": { "@types/node": "18.8.2", "@denotest/esm-basic": "*" } }"#, + r#"{ "dependencies": { "@types/node": "22.12.0", "@denotest/esm-basic": "*" } }"#, ); let output = context .new_command() - .args("cache npm:@types/node@18.8.2") + .args("cache npm:@types/node@22.12.0") .run(); output.assert_matches_text(concat!( "Download http://localhost:4260/@types/node\n", "Download http://localhost:4260/@types/node/node-18.8.2.tgz\n", - "Initialize @types/node@18.8.2\n", + "Initialize @types/node@22.12.0\n", )); } diff --git a/tests/registry/npm/@babel/parser/registry.json b/tests/registry/npm/@babel/parser/registry.json index a7e2b8c605..61ff9bc17c 100644 --- a/tests/registry/npm/@babel/parser/registry.json +++ b/tests/registry/npm/@babel/parser/registry.json @@ -55,6 +55,5 @@ }, "author": "The Babel Team (https://babel.dev/team)", "license": "MIT", - "readmeFilename": "", "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen" } diff --git a/tests/registry/npm/@isaacs/cliui/registry.json b/tests/registry/npm/@isaacs/cliui/registry.json index 9cef3f6e50..53f6f14c74 100644 --- a/tests/registry/npm/@isaacs/cliui/registry.json +++ b/tests/registry/npm/@isaacs/cliui/registry.json @@ -112,6 +112,5 @@ "bugs": { "url": "https://github.com/yargs/cliui/issues" }, - "license": "ISC", - "readmeFilename": "README.md" + "license": "ISC" } diff --git a/tests/registry/npm/@ljharb/has-package-exports-patterns/registry.json b/tests/registry/npm/@ljharb/has-package-exports-patterns/registry.json index c4a6c51af0..e46e4abb05 100644 --- a/tests/registry/npm/@ljharb/has-package-exports-patterns/registry.json +++ b/tests/registry/npm/@ljharb/has-package-exports-patterns/registry.json @@ -56,6 +56,5 @@ "bugs": { "url": "https://github.com/inspect-js/has-package-exports/issues" }, - "license": "MIT", - "readmeFilename": "" + "license": "MIT" } diff --git a/tests/registry/npm/@npmcli/agent/registry.json b/tests/registry/npm/@npmcli/agent/registry.json index 452ecb94ad..872f297d8f 100644 --- a/tests/registry/npm/@npmcli/agent/registry.json +++ b/tests/registry/npm/@npmcli/agent/registry.json @@ -93,6 +93,5 @@ "homepage": "https://github.com/npm/agent#readme", "bugs": { "url": "https://github.com/npm/agent/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/@npmcli/fs/registry.json b/tests/registry/npm/@npmcli/fs/registry.json index 3864ebd67e..f9e79f2383 100644 --- a/tests/registry/npm/@npmcli/fs/registry.json +++ b/tests/registry/npm/@npmcli/fs/registry.json @@ -79,6 +79,5 @@ "homepage": "https://github.com/npm/fs#readme", "bugs": { "url": "https://github.com/npm/fs/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/@opentelemetry/api/registry.json b/tests/registry/npm/@opentelemetry/api/registry.json index 11b8a35f87..c3de1632aa 100644 --- a/tests/registry/npm/@opentelemetry/api/registry.json +++ b/tests/registry/npm/@opentelemetry/api/registry.json @@ -127,6 +127,5 @@ "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/api", "bugs": { "url": "https://github.com/open-telemetry/opentelemetry-js/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/@pkgjs/parseargs/registry.json b/tests/registry/npm/@pkgjs/parseargs/registry.json index 035d6890f7..201e8fb9c0 100644 --- a/tests/registry/npm/@pkgjs/parseargs/registry.json +++ b/tests/registry/npm/@pkgjs/parseargs/registry.json @@ -61,6 +61,5 @@ "bugs": { "url": "https://github.com/pkgjs/parseargs/issues" }, - "license": "MIT", - "readmeFilename": "README.md" + "license": "MIT" } diff --git a/tests/registry/npm/@types/lz-string/registry.json b/tests/registry/npm/@types/lz-string/registry.json index 261c433405..eab29417cc 100644 --- a/tests/registry/npm/@types/lz-string/registry.json +++ b/tests/registry/npm/@types/lz-string/registry.json @@ -54,6 +54,5 @@ "_hasShrinkwrap": false } }, - "license": "MIT", - "readmeFilename": "" + "license": "MIT" } diff --git a/tests/registry/npm/@types/node/node-18.16.19.tgz b/tests/registry/npm/@types/node/node-18.16.19.tgz deleted file mode 100644 index 00307ee080fdd480c5891fe64f21ca2130b0edd3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 677084 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

OWKwQ~#NL(!E7qzr!c8+TyF5SmBK@81bFK#= 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

    SKm`+1x?D*Gycp|S_F)$> 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

    B&|E `b%w+ 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 z

  1. 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%0AN^*dsU{59zbKYdo`LHwY` z*3jgvIxX8VqXs8vovG0ZYMxvo^h%C8W*W1=;+@iEsVg$CRA$r5u1wOIo#*h)6Hw#+ zV2RH!YgBN)j*7VsWu2{m^OEVPTw0Fkvt*c}DvlcHXCLrlCZp@YKRvo0#N!^wT)*W^ zPYQPq6;%(M?`os(_s~X@ryR^y*Xf?>Q2i{J z7mlU7%Vz_*6lAw!9%Aj#pidD)wAB=7sccUaNE)mIDt31A`+d|?g+nIIb$vETxQ^jE zyuvd3^X{Wk<=l^9X3Pt4Wmt!g=%SIwDQoe>7IjQip2n3p>0_QqoDI5l)$`ezPJi)T zc?9xGN@F&371`u{UL&+>67Wj1rpx{$n|veJ(h}JXj~nmDrt=inZ(F&5+JskdFoe7c zOLmk|=$GxHtqxN3W@ovU82;C?_B*DxI>W!WWR!ox*jWFoPnfWRcgln-9NRvflNq^` zRyO7P)Lz$YzqR3)g-5+X-?>FKvh7RiMMJ@2)2ALPZM>;3z%z4IW6rkcY$3TVCByx$ z-*E3&+}TWCXF}hc(VJS=YlMSvx|nxrjP9#j+FxXFu;MZQH)CnvqN!aNMcLffFu4cW z=ZEL#Pmj>gk>v^okC-7FEOcaEsOI&T>lxenmPN{BgOOJ9=XrFtFz19STgH+22v2=G6ExCp z-vIzc@IU}aK)1hHLsfrqFd4Gxnu|NaJI_Qcaf!!i)PGKu~@JkONvpe9O7C zopOz3bP6Dde|#Is6YlqHrf*}NLQj2WJcStPfeZ2_L(Ozwl%I9-r@qCuI??amA>sGG zsnmrQ(&FiO;bzaOhuk{PE6l~kE#}skwQUc9k~{1! z)$aFfI!Z4WXshnCe4*e@j_gv|ur|~+P8L-)(MP{{Lhvo}2O9MJ+IqB94^yEh2oA0k zBxX-0#tKKkjp?jl#f&-*9fdn5E4aK>Y|1SjL#wvsKI(ut!<gYLn;_h^*1U&NvU&*&Go1PS)ZcLb_j zS>apiwR(r_D6GKaiE@iNH|9gIS>MZKAo~_GDKpZ>euT;oRfCXbV=mcbr=HgGX2Tl9 zaKBHda2}*{wJ&{uKK7eZsd)7lRXyX?-_%u)SAW&iMqd40T|s&ES52Me)!%*8rD6^C zN1u239Hsy|h#{!3M= zUSki0W_-PUP|1&xG|O-{RX2LtJf6ZyoGOPS97T(1`pY7bYfdErY@@DN(HM%JHz;HM zFpSXHD4=55*v^B24!U?Pf-&NEXib#_BomkLz8n+h)IpW`kCLPV!q!|QX+`wXV9oBSbnqdCmg@O=O02h<7}$E57kC3{-40*8GO3Kf7m~` zd;bA^fB!>u$o~1e!2dgRez$+D_5WZ9kag>SxPSNI;r$B!<6V6I6aM37KP%ur9;=K> zNeQ{Yx)}qzf)o`#X7?xSTl@n4iSV{6nzH*d!!?rbr0{ktkdjjZ@~7Yx6`iRZ#;PBx z;jZ92o-^_~9&Q*4Adh7fE@%NeUEJz!M9(NVhBdGbS9S(%uON*Qy72A!`HQGfVXjjS zh;b^lYlLmxDe>^CPH}8}q0kC)$z|=3tCfF)J|Ky1bUYpl9Th`q$KBdq&%PdWCSaEw zc;ilI0Qj;{r3AG0$DcUhm!TEnpwZD{%mEF`p^gDQ7?ez1t;_{NbEedTMX?~90QAjI z6YMw!1W0_nX9#xn2$`Dh=FprX%|hUuG96`jPJ015(eVX*N?Mu&n<+r(C7{i(p$F=@ z&*(XhL;1{k4y!}RC^3L0#RBLSX*q*u@>MJJ?g`IV?t6Klz6-wnV{+kn?OI?OTs(nb5dNVOM$Lf z30A+so#NcSK4b7{F+)kFM`v2$VGBN{8jk0=vJwtG#_p;d_UA6Xg3})(Nx2z$)|x(< zFa5XSLAL|w`@;I`Ns|e=N-wW|gzHQGeVo71wV=Y!vp^M8przFHTzn;Vp`zyFr9NPa^v{V}&B`!Mzsukf`ojKs_ntR2LtRt3ozm#cXNd+5dj%C~T(Px6!!T*ggj z2abVu?lgO34v0#9QZqR((!rZQlxCykV0K%M#Gy}&Orbw9`8poAzFcK$UlP)y zo9rfvh)&JVsk9YNEKWP>CKv)2p3VnuW_ftV(&9;4K>HWTP}gG6ocizno#2Z-Sd(ph zOrjXbu+)cUn|X#z!^2mNnrYYx^Uo%0ivYuNBw*c-oKFK&cZ14sP;vn9;ILIQ3BJW% zVG^wTJsuk!&fYBEz$i~u%(-L{gQ{J`BUXVi3A3*#ck!3@PQN42HWQ#;l&O{YpJUZw z54e*hMM_|DaN1gwWVLjr4!ZZ2Y>Qkkf78L2m$=`;J0o;RZ(iwZ-2wt1cL)sWV7p8C zBpo8hHXqG53F*NqSXu*)_mv#%bK1BRw=5$lNiv*%Sidi~NX$2IGA)HK;B%!dc!S1E z6LyFbw%SZ6@*d>`^{S;4^K}B3vqUpGBi1p$N%b7`>?~X9Lr_ju?)Y$(y+}?bJ?(ii z8j}&hhNmRw5-(#F0*j^6AWtvsfOV#=(r3=E@+4t0MIYhWN?GLYpg(W4>6|e?AG*YA-qf`hDlr?kj(u8&^;9@(oU$&)t--CWHCbZoXQSywN(MGc`_SWOC1ep!=NzRg6VDYK?wbB#Wd>lOy9fD~G_$Xt(l2X#*Bq2l9-t3(&G`6r!lqrwnIB zgggDnqbj+b)(7lLT_mhW?x4h%G(Y*4_sO78An6r)rbGdIQl;ELS*@*Sy2vJz zXyAcZopZ160TV+La|{0TEThCmwul}nVzn3Tz`UM2=eFo`b~0zdGDB{+?BN$<6PpfQ zCnWDhbUmm_$Fq+eXUcfIzBn22&xyPxGrl0eG#D1Vmd~f zG;)Gc5UR;|Ow@qIG}dUM%(()jg(~w`6|Gn;in~;T2cfThtD-^M`?#)sjazHQTf`b7 zqH>5(HCsFqPDk=Se~#v5RKaW4!60PH-1c}Ld!(HR;3c75+YRAq!y_zfv%G@2Z z;{@0g??S&UpcPn_gXo*|>qcZl8(3jQp#U?fyP4;7tX$hPC*yQbDBn=PXilfmNWd!a zgN~BSEVtGMZ$e^OF5(o(jAw$c8*&IRpD57pbBrrFQj^ zc+J8)i~AC>(4b{_$M`tAo+Ye~%LTsh4)rNlVjhzKs%~s`u*b}ZYOcw5%!dbGLg?Gd zhE#_Sj0dCSrZJ_uA4h#+4XH7WGiWrG8Tv3MkB(J0P4l*_OApqL}K7*?s2YIX~4K~{6n?}%AaGfG86#4e1{RwAqz#RIqo7e-Q7XVeC0 z@^-l9kda0nN3VZcCQP;}_BWQP)bH+WQC#t>TauWoO1HV*N{>~ae$G;OcUyAp*kc=W zb#i9-m`l)!OwhF>(s?o|L7p((I3z4l(?iQR8(T=h6K&Hj1zA!En<}^A3tK=u$HtCr zc6VhgrYNZu%48NwU!EFTkAV>)~1(htz-8un8u4*Kp1^>#remh{x z__Or(?Z0D6`MJa(N}0Q?Q@fH$ijJrJi*sLLgk>vhUA*nzOu7I;SpMdreHCeec z#zpBeUUZ|ggneN4eSCm-i^9G~`%ZavOEs5$j?UM+%3R+yWgCnMUQpf9y>Wx?2Exw% z^=K{TqerbBxf@fTeV0T5uT`vbAvc>Dbewzr>ipU6Bef~92q{~y&3L+MUj_PcmAtKX z!)}m<&+0uq8xLVxCe_=uQk1)4c}XF{cd2d!?;LSN+-HK7#9x{RA7wtsHgz5g@Hq|$Xkq{`SMr3 zTt;;q7Je9yQj*~vIp#wLDza2Q?~)y%EeNgjLWe>MG5W!G%$INl=h5$n_8RhCLj}`C9XsZX~nyhDJWre{ihkk|-N%ev^R5u#y;uKTBmbSwt);ZSBX{(l2a72^})? zZ06OdIWoXLqKi&c+@$lt6@De=SDPGGO1_niPo?Z#su$wmG`Dg&V$u9ow!NwAz+Y@5 zH0JG+5kO2C^@aei8KAt9%QgfDb*ocun%RY-X%Wyfbs)v9eAjW}#&b|+U@hB0Ww_Mp z57~`%yi$UiW`g(6Wb6NUZ}pDveJ48D-{0SohF!luIP^mb7K{Ieua2>E6=Q8t z<(;mi;<;O2IOC|O5AwdL(>oDNbnH;7TRdN5Wm`U0@kWT(4{1)00$SF{CJ zMq!{^kun)rm3c*L5q#P9=nH)26WA$&3Ud6sGkc~ORln}wiJTbjRRK-jGp4-BvsjS$qzH3wu*4j2{@q)I5=R#`7s~FFM zj$FZ;unE@CnbpLp2Kthbx`8xkCDXJJRgntfj3xcp5# z1_}h951u+J_pw%IL}1E#hBnQt5_4s9^65KrIC@E+UR?7UrP47C*76tl4=JZ_U z&QqxaiuB(Hg5*LLAS*eg?{RKYZhj9WbdRXB-&Z=mb{iIb2CXI9^bN)V&NxeM&aGE( zdWoLEETImQEM0%Qj0!t-Y*cup@+P{esm?3!j*2dWDNtb-ejVCPfk)J_} zpAADaEY>Zq(vgj&f}>3;*7b-`jA{<0%7_W4zG>G)Ruk2w2ms zFfh(}?V#_I$e2JHUTv{#a%}@@oXmOfc|KpNC0QB2dL7s2fq9 zm2(L=8qhp>QwfDGQ+xvLj8UsC_f%8>74z5WGTC08S^D3Ae)P0`E(*iBE zmgkBKDo1CDWGkyAb@hPCeuGZwkZyW_c4azc!>=dKyU_s*$I^=h#ZO@eub?YQPDb7d zAu)rZ{-^1msv+bOQlh5?Z!|Xv9?CHOjJz(scTQqCMKxqNg?DnCWJj9s$k2Bx6!;*2 zhlzSH(@)55oJa3VdFSv|k8R4i=aA7DLBPF5@-4L}8Ac|>)9YguR-pSRrM6hl`)ow! zamzQHO?CEC-~gSAK|GhsgEQEmZJC|RvVM=FR?G8*9=hp7JK#;O^HkUPs%6aeo@zBr zco<%h!FCBJKJ2;1AK)=usjigKEZQyP%~rS_3VnJ8a*}NUGCLReL7Z14m;Oz*oM(8o!oDyL0 zPVF$!dP|B+HoR5G<^%&)E)yGvqwJ#!vzW|nn^Vh6f-l$;Ho^qHt^{}J-k;6cVZZ@Y zW-A1`XYuho_crEfsv26dx()5sbez61mub+^K;sW752{{HnMfkLT@6?4ns}5E7@`J! z(JmA9q;13sE#Ntab4|rVw3uQF;D8DSQSH_OSPXsXxFF|S#WG7A)K0re*D3v? zLH>Fim{F=N2>LL!(oUS~0bK>DKQQZZNuWieq%ICaP-r`-(K?aWR)A7RU+PrYxWQsnE^YYj z6>#XI<2;XV`*u|3Go4jN#QgUC!fJzKobjS%)w`tFrRvm_{Ioh5)A)=fs4MzjcO6K< z+G$_BdKttS2H)TUp}?%Y?g1szHj3 zJl0eWJEPdL=A^LtSyYVvMdD2~hk;pv9yk)(f_zt9YWI|&SD1{16DBIiP}Si`$gl0O z@nsij)GwMuP{Uwe)5O%pLyV8XTqBmb3j`8!O!dOiG~h|M;ss2TO(I#|MbF2STwcB# zb@!k%yYVdDWgdnO1ud=b4A?~Zex-1|e6MA>x`E);MfW3Ul%3qZv|ljS5?&P{x71&v z$TW_`)i3Z>g&Y^jd{B{x+Y5aWUOt{ipD}CSj+4)f4Vk~L6^S$>3JN5I|4}t9nuy>A zV$|zc>8Y&NMzBaLr8|0rw7?|UN|-jzV)iCTH7eSx@g+#GaSR@R3Ey$Pt9Vn}k~`Sf zAXa_l>Od`soK=0$l8(jfB$`@BpYOh`4?A=YgiJya{?l7qt7KUvfX$1G0)YUbJ4l<1 zdVN}&oxZYBrI%AoOkKA15$Bs-I{r*!>c(i1lZ}oWQ!T`BzU^i+>d~}fr&8}QkZ_c| zr9zurjH_q0CklnKy3qkIi?LKNtD_YgFm<{k#3#ZWb*3X6fYe<_ zM-*B|Fg&jOrYdGv{`|1(4b;8c#k*Ab(|g@=O0G_gLsT~EkTSejL@dDVmC3DCwIM{rI!rgDvr6TM0F|O#{%nmZ9Qf0) zCR*iD;TVfen!JUa(doZKSgw<-i6C|@f8*Qa_SskHum}@(=&}t}cndLUG)wPV+ z#;oVB9<>(x`AKcef}58VTSjaHR@_3FvL)2E#gZk@=-S*EptC+B1_-XmgCQ#GvtNMX z%A6OVvkub*Nv+CnenQ(~wby6#emB;j)$=U>2?MVk7;E(n!C4y$J^*tS0$C4WuAVBJ zY&k}R17V6L5b=`p{B(8Ta|%OI$mc)mf*L;iX_@GTrci46`YX3`0sfTwQu&@8acetSdN;~UFyR*! z`a`aB#&x1t>=AW)MO^I%t9D;a&Z>~I(YoN$%QyQ9;L>UoA1Ao9leqD*<4dcl{LuK) z<+y0eV^f28EbT4XNhHh#MGV&T@>c&>7>jMVgHNCp+`kPMEG)3sfYbhjrv1^OX)jYwOqW{U5uxaXrc|ohghK zM)2fXu#|~rgTW$aOa_~-3bv8+iewW-+|t}|)MuF#r%Y>4ukL*m+OWc`i~@rq%Tli8dU2;vtHr$~HOg+nlX+~9rpMGP;$6qE`5Nb&r3 zW-Q*ah?SPREFLOS1n)|iY^Dtxd_(=_g64wF~OMu%A+=xzn$T1`#>2P z|4u`gSP&?;aFd(tbiA`tg7~eh7svGJaVoGC8bAlGpfokSP!urkM`dobDl+dn)j~I# zP0eEXaL7svL{Z|HR)Tz`;+yRS!WozQhMH#TV43bDew$7f6A)h$3^-p9bRX-Bkr_p*T9V>oG7CUjmxA_1xAh%(qzvvIlNG7nIt?$ir1O zkR+3sI13}{k>ty>v#8CzmAMj38Y(wKA)-T0F<1MHSf-LFgG*-RKub>sth*6BsoMNg?g?V#Aj2lT{>m&nqnkAUTCFZ67 z|Lna>a~oN*CRpqI6;YYD2B0nozC=mMETxJ`F)P`nlsF<)S=Ur)L;wg7kpd!cBLGq? z6*sf#f6(jM%$SW?&!Ts|=~e%ev7Wa18RM_>j1ze9k*TZ_@2wOGMEH66@#F5t{qwXp z8^uK+`@P7a17r4WQogvAl-)wCJ&nX!&DLf)!DwMV;jTtnHQVrtpHC+$H(e)VP$G=J zK{C*~c$QX{jnXj!{ z+8qhfIC(2*OTl|3RWu+>2}&l@`=*>FrCkcfm5nz7H`A%q+;`qBy>2iQ8FNy9EB3Z| zye?~5r;YcLrgW4j2l6nlqhwV2g_?zosw$r)@296}?_INog#VHMf&cx+M)X4rD?`ro zuCSS?Tq0@vxyFzqU4zD4ku$kG)P2(Jer=_ezE;iZ$2&O_08v;6YT>L=_6 zFrnt)jC1flGngsKSO*8bRLTgaAZlP5wXb@hC`Ptc)$`iQ6Lf@(kyK2;i)_2~#iC#mzud`=aX;&gZ9)WpP zdGlE9pw|7ml;VNsFG&PGIa^VKCX!GB5&3|eD2>a!81;W!b&akFw?}wwb#Qsf`xuYm z8pJ#Tm9x)y=xNPU$akv8LFheY01ykp5wCQ9u|9vh_-y}l+=d1mMq>{jvNt(nZ5wSM zm%8)MDP)CS_u0bmH+s%K&2I3{oHJ?(Y75UEbx&u4Pbd}C@`+eN%c?CWW=jBgBnjc< z!ONny@T@1P4owj8!}NscRf>y57GSAaqQK$b zO_cG8&PHwU3kY77T@(}qCipbv=N$+>yJ!k3u~Yt5(gGY z+6ygKD>(1-6~FDdGK~q}=w`>Tkdh)J!L5`EdS<=2KeEAj!_&RNQajs%6sfKc>1ly3 zQ60$)y`%=wGr(`K=3<zq-utfVO%XzvXssy$|aAhqTo25p$6UB1=Jw-DO&r$ zQse1>Ak0OrH*IGfr?|%%|w`)Ofm0z)Dd&xSD*pj*B7gdU>B%wjKe#8{rc?W^!4HX_h-)! z;g?tccKEzg6GxB!6+(7FzuKgkX`S zTn?^XhRUie@H1kbtj-v<=qa~Z*E*uNWS4&!D3lv=(9a25a$`;kgP`2O zvIhy@4M+W&(M(q5rJoIcWOWXz!!fzd3fIuQCEwg1DoF@axZ z${EYc<(S_#vD+jbPW?Paik6>EbIQKq%QLCfq-*nHF-09d=F>LC67VTxIxL%r*8=G@ zC3=#S*Ktnuj-9J5aj2E+1rE%Sz}(Whhg%#KB?Y1IUV0d3=XeFKO5Y;Z4t+-58bXKG z^9kjo4dV-}MU!*V?EAE&uorjx(|re~m@yK*zWtU~9B3A+Oy=@wtt*t1cV=|?lz2x+ zTU*FI^D&$Hj$mH2FzZoAp*m5KmI9X5@R^!m3Gk#3_4K0*pI?~+{)a3gFI46g+Wuyg zcdeGGB~5eQi>xl+=v7iCRE+6O-nY^Hdpa3K~t9vjGl`uFz;_dWb$ZAG+vl?kjEk{~njF`G-B4=cL`zK|JE&oL*g zDJlC2ZscC!Mpi-z`ME(t>KD6$eX8Qy?>_76Zs^`N-|3ggA*h|?`Q+;3(CT8;jL|y1 znk13VP}k`fPs7~Pq8O%UE}F9;Yn*DDqVHF8y=@=7ad>VZP2~C8X0v~*lTcf}2!SI8oJ=Q3HVop-=Ql}#F+F^nsmJ7bIK)Vj3vtBzNz;%(9@U6jwJ zlNrIrq!}YgUB*{7#UdFIkc6mpX@-dx(F-i!OyIH}=~f6$!=`tiPPG7z$6~+QJv-0L zins!{PO=)4+LzEi%$#Q3m36=681;-ewRtyuIn;%9+s801r<}yokx8NuVo;qg(s)!U zdp&TmTb!b@QdF8SUrWQFf}9%nio7fp>oTjiK{YR<$*h>fqF9Tp zB+3*!Z>i$32tb1VV%#y9@zjg41GKM#<79;3!ED6UWV^F;M2TsXy+zGs`9(4Uf@tq> z5oXW%QDH5s0nJ>7-9FSV#{P5~_b9t4i}n#J>4Z|iBiHuN1<=FtjYuZi2ovgiPDN@; zBnFv1Qmdom!E>vIafezv;3r2((W%?jD*w7eNKPG2`%0?sqhf{NFbEFCC<+7wO9;Rn zYiJsRjsnWbRT;CWizIi7TGKG3n7dD}(?QZ)TkGVuhqJERUV6z=Y1j{{&-e5IrCP2x zY$xqPy+j7~Q;f>A#@)1^i!8!z&iZe;-|PHu6v&eP-4uxS_D^M=HP+VbH{5<~Y(y{6 ztKJgOE(GIW~f4lt#{S+4T3PUWJXXn@nfVK8sq? z9w;54WSoW!Sas{?+pk0=a2Kh}kfnn$Rtfi5^lbfEY~~53_B=rdmT5XjRhqwxnrTo0 zxr?npme>P4xhXr0DpX*>`o2kWA-o&lgK<2asl292ipw%W@PkHrSXehcaKsg*4L4$m zphjHuhUrDpp2kHz5!G}Pkt5OQ3&|nc?D$n>Ln^2-nv!NiT)Kle#T05z3h?Dj-QIRk z%TDxC_4AA?iX&`Qqe9Hx=XIkj$~G5_lDhSD=UbzO%sCBtO+^Jw6*mwLA!S(i zk_ON5GqFoVTZwP$|Vqt}zK5QPrBL z<3BPT2D*;M{_&BiWH4brd4w1Nu!UAU$LF)~h7ezpHH(4z%eIZ8{spef^G@QyEKoY-=6F6up4O?Z??UF(+Skt6;)1YC=N>`cr4> zwG>;m>o0g_f}m5z@hyU5>hy%?H4(1uK*7fj&I+4`JiC}Vrb@?O3m zbh1B7+@leF5ooUTv-w=IAdTr2{+Io843{^ zBt0BXvx#A}U|k74c2#IZTmLJn$kN)=W1tDbc@-SefDP_fmxg0hILMYUK#JrX*&hKw z^gal?1~d^p@k*1D@@2}|rY|zXWzGI>KX2iI>AGKgz6RzyVxQ?ILBr1SLrOH}`%T|3 z+YDS)-2XuCw7Y0jloM1;^`YYGpL#rJXMD1xgR8T%`&yl6mF0nct7~QKd9aQn-8CJj zlLV24PAI@a-Ae!d^lQ9xqLJ%+?9=Mi_NhfUK#s}GC*Y3G8Fg*nY8ut-iuo3Gav zO@X}t)kXPxV9v;)TsybV4S1I7hQ};wM*Ia1^xv&4TGx&+uxX|h9WQQ4vHkH9EiBC^ z)b8Sk^;$aY@~n1SFEhC(&T`F}o)elMr{z5cjIWsp<=79*f;~sX7dQ>!IhfNUdXwkm z*q;(kxS1z|TMT>%f-HPPxwiz3farFnKrzeDG6OJb!<*G04V&8?LkSj6J9U-|KlRxPt zjPInhOl{fVwF(u9i0#N*xr6DHawX$l(5QNiZH6Tz*8zK!@j94YNiBtdR4F1Q7jhPu zry635nsr<(S;u(#YaLBD5+_S|iI#Wp)NG;~Y@@{+Y1yshzBSkHw3wxD>2sRH<2l{J z`Oz4{92&Tk{zE27F4#sunUgmdq$~sWu?n}NQ z=6iv0HH0COwIGVqVVDb&px}@E> z&RG7LbIDC@2D=kUQjK%jeSk0WjkhzNih@v45uyrf*KHPHGJAf19fJOKGEOK}9rRYN zqQ#LxO2yC$iIf4S%n^LT+e*&rSvO?b?Oi5Tl%)4EA)lkV!YN1snjKPyqh{Jp+Fmis zwMbR0R!{Nm7#imHWAuDPTfMSt7wlFhhjDf<^6dQeEJI6jkTvIT3f@wUxa>EoI`u#D z{!sU6dj1vWYmcIJes0gOx<1fgjEJKFeeDJ zeuUBC#VU(I>t~88SRv_|2~)xDV-20Y!!o2V9l@bJhQYk%_=1kE?1`wYMw#jn>Z~qL znc3H=>YCK1O|_2^{gvM9+gQ+C5mS{fD3eT;l!!D%4nlQc;~CbPpQ1owXcks*MHOx- z&(v@_o!F1z-@yl0ag9~qE|cPdVjhvcNX!%Ztl0!on4MY%Z+CT#p%WFl7*zP$8~Du2 ze0qp!@|Ai+NJ=x3p+?QtUo9`^<3X`a-W*f_U!n#MVhG!)zJe|}hA%FO@nAzVC|$p# zLMa5>Y}ha!;WoT7K{OUiRcXtWFbs%`CDCU1?Qeg(glEV*Uv76z?o|6(&C?jTiB>QD ze!t=aHTJP+$1Nfu*+Wbjr*NdnXYp0@r}8ZSlhEY6uz!`22bpT zzYE-BFFOsVTlKd}Y8Dnv*6G$Nv!ydhw)UX)f3}%C-JbK5n#hF{zI|5{uD{!c@3wzM zi{bQU{>nIyF11ST8%wR2`^wI|SGGg1ELiXzen-FZwYh|D`3vkXs`+~d{@!W%3%g)3 zKds@iYk2x_-YYvdSoVi^x$OGyhw%5qkA@9A8O9nqV?!ch6z479O~BIEwL)x#t9)Cy z-Njh9YQnKvfoHe(YDQK!6)ur>yRGN9GOtTeqsXJ>XKL;173Ru>v}v_(nUJ)Pq@MoS%fIqc!kTR2#bodGpV(Y&TH8mRN0H0lW2T zFH*wpe)XI8tWwSIayZ6tPH(H?bOkNRJbz0~34iWDTkxvj&6eI5jWBM>2=-dt? zJq_dXbuwtypJ~i+T7jw&F0pl%}4P3=3RE8?q^m`;{v*JTRJ?LNdNm0 z{Md79|8D=#rZwn478`UFZ<7f{%fWgK1o|0YMp9%B6?PuSS;pZx zQ?8j_;B7AfA*nLO>j(%Gy*d4M{Rv&C;%{4zkWz0L7jbWz(3R>`U2n!cu4~TVB72`j zG!D6=Gq-6c)Q#snq{@|=HC)QOG<1lRv?!7aue_cL(o~y3Qr~XAKL90b^ZowzkA}9oV^cyvFeNb< z#v_@`io8nlkVrmZ!UqcpBat z48bMbdpN^jZ`fP-3vFO35fe2#|Ih#SpD``FNc0+Dl~|!zCU_q?wGdd!JKKvZv%Je< z6$brL7;f%kPxNCU=EcePUO;AdI2qI!n3%V0@BG-rtN3znW8*xX4rkpqFwq7cx<8fl z&qjBYcQ-D!s2=XdDDC=(@lWO2XQ%-A3WGOeqBAh;m^;xQT;)X|>}v5+t$XPjjV|`K zOpCV^hg`(dWp+yxJ9q08gOT;MBozTb<(xaGpkejNmXHsg$J6-FX>!>irpzS@NkLcJ zbaigM>}`tEnW8pK=TcS?6A~!s?9e$IG`KZ`D(z-_tNrDdfs1@;cz^jpi(FC>F1(AW zemC|aeACaJ=C;&=uc>-aix(Ug6wySuQO55x)5w^9?mQBN9#d~e-(U~jWwCIMEKc!H zf16=UAk<_OBVdl7LV^X>r|ERYSY{TdO)!n6pi1XzdG*&CjIl00N@BP=T{)6;^lDlv z#i$PplqHO_x=5CLmlOk9P&*xWC2VZKgXe|8${?HkO(3y8`^_ic!_TSFt z!`;We{r7P5(atCP@3udy+JCf-rWCPRG5xU2Le`H*DCq=gRUT^JUgaVFt5bAzuhf>- zhtvaf1)hU&GF6OlFEk(Jxy-0t%Fq|@lBG9se`HOgLj(}S=;@xu_{Eq?)qv?=Qc{&B zm6d@ZqZ$*KC{FSek4ygkbpKeP{C;L1w%lbkfAAV6%YhDdt&TBC77^=jkeP#64mf4q z$?+P+J?jpy0+QXE6$QRboM#}a1&cZ=-=&j@I=Jwe7Gfll1_}QNauAF~QSYbmd6t)0 zha}Cgd71<|5Ov8U&`%u3QSa(?Dzthn^B~?w;Ubvne1vWj3SiX>rj(~rVPR2xDy^|< z0cU7dav3a`seW4a;-W9wz%-vkqXdDCxp&cb`6Z^gv@CEcVHx5SH4OBG%v7DHhXi1Js zb85#U3!D|sqLp2_R&7^xkOR>Zi8|SJ!^-+Wyn}!}?VROgmzIvm(|BN*33Yeh~wcw=}1+ zAP8Stf>Cj$!l=Q-0MV!YvJ?-rnV0B`gkZ-f_b>!T)&1sG#G&0+YMDK>m+{b;T!rEq!mfL3K46NQ| z_8C3+QExQr;Zi$|o?L=^Jw^j9yH}*$WEFNf!KP^G%+2#cf-Agv`?iCR-k!1kS>^XH zEO0%RO;?g_N7FiPsnS{e!i`(1J`pmW2yl#Sm^(Q~@A?omE2;I|z=Arf#zo3V)FT|< zbkFWhi;~3lq9*SZuQ(awi(s9rm8Ocez1|kL8zx~_%ebn;5&?tbS~!lIuKCX~j-%<4 zgD{I>Vx5d{z`F7A9QuEds>%@+R1SJzfrZ#O?p-}oh25gRFAn$F$AJ~`mGAb&RAv&X z>4@FGU}O-}&oaVvK%BIe@3Ap%5p+m^MWej`GcV!T3JgN}(BncC&1PBh_QyG0MuSd( ztfW9mnypXJr<7n(BD3t?>}hQ>*b_!Qc;~3b7hry*hlV zRII+(=V8@SeQT7Sc?1PG2%(0w3j)+${J19O!K#QmpES|3oDCi!{Kf=J%p;T|Ds()u zR8OTGg(>4VFX`FEb8yU|J>)Fuv3c2^=Kb6aSqwD-4?SDl{}6q=uUkkTAA05olLUAM z8TV)AnNJIQKMQMHB$){(rb@)d`_ZvXbOQhG4dupCoA8;K5%4uJOWb3)DHCw`z==3; zZ&BUGtSC&b88@XUC2yh@ZYRi!9*HFP9h4A#f{7bcxEO#)4A-V$!CmcQT zV3w?ntlz90$&LdtFwtPAcleeZeKXnU3YVuOZiDro4zDb~hcG-_vE;u1PGWPFum5#j z+zx*0fJLz{6t7m>(JRcgx=c$9gdfSBK849Dw+q^m8zYE{n4NLdk+Ru@z*T9iZoK8{A}qB z=Z-Ay_e&~F{_6QFn6nh?x?ymJ2sCFcD{JL1P*AeXTPr;DmRKwA7Kj_TkF}C%xR=$U zvEFjEtaFHQ2aQ`(yzrHyvjFyF0 zKg6EKDlm$LN)Ui^S2Q)+FX-vN@2iHb;IKnCP;-?mrA%QgVMU>$Dn-oJEM0sBgSaMR zo;3F@Zplqjo-EZ$x00IEJ~+bqdp7LBvnA5#SH7e&!sydX)Q{^<=E{BDD$6{Mi+3z1 zS$nwIVh7dH@M2#MuN)?mW>;Ko@i$ag8^09kDS1I3w9+nQTe#O-a(JsSCei_~{~?ow zIR7U_%!-ZsYGXeB1E&Ho}c(79jilSB*pe3W;=f>hWaWp9|k6O_Xtig6h+=!Yr(7IQ@q zcw&l|Az-njIs5-euly$Av8cF1XxNX*yZrC!bl~o2Yvg{g8B{Zwk=S@cZs; z%4N>r1jOW3@@K2uXt$U=ADJm3By?x#2u-AXCMvAz)!Rc#rFoI(6O&fQxpeKkINwOJ zjeg!MH_m66rnf;iXzL?*dYwDGjt)CaDw(FecN<@n34AElIkR@y9_tQX57;Y|=-_(Wd_r)2oFa9jOt@Bl>UWAzT#D zz|=GHr##|zMUF>Zq30{#{=)B-0jA=D%&=-rvXg|Y;SOms9nYPpY%$(!SY<_q>iA^Y z%PBq~+6)f+NHr1Q2eN!9wVX2JE|RcP1u9@zrz(|=ZMyPKZkunu z(obXI*`nro`@64f`f9NP4XCfY7V6$`zI5AAOcQEEedo7Q_m2B5za>J|Fo(hN<&ZKD zw@wniKy-A|5f}pOTgXS`Y`H?~$i*x5*i-Z6>tt|1=yH9p0sL8jfG3Oqy8EzMxzSfY zZ%-(!sXfh)3y`D8Yd_-CcEF(exvuH5*}_Y8+u2v@N0~HYu6Hy|4UIr1+`A;1)a{wd zPBFB#?X~6l1oaaeH<{eCJhPZcRiyrkiwvVtg)V?uS`N`5(TTfCA`I#La_Qrp)|z2}{Iw4EMyayL)3LrJ&<4tzVVSBP=Ok0m zZHVrFh%e$3uze>}<#!D{6?*Xv2fbj2a3pGa_y)7o#dbtXbmm5)fr&fhO090l#eC-3 zY;OmdNBL}_UobzYo%Lv?JJZV1s^6(H+&xJ^^P6^Dn-lZ*r~AdZQ7$M9>g%SOIy*v& z9@G(1t!P|o=Z_U>%1>#ySLc+)9}qaRX*z0akXcl|i-i67T=zZZbI5*WT7p%8A#Eip zKBRZ@Z83Ibo#%euDD44pKb^DzE&B+m^HVOhzyifD#sF%NH|Kz&X8pCIzY+s@_P}Be&;v;2 zm%HTwr4-zp3F_9}Q%iq|wO2h@u=sQP?5??1A6Hv+&rn=q)pggkS#7Pm>Bds){O_}5 zmVBS~ihLTE@9fF2r@*{ii-hGG+8zRye5st-?Ef3xpY!iG^ZkEY4 z@Skq|v$FqhR0ctRJ-?O2H&CGfVyzeP6{dS8pr?{dcn~#DU!1Iwx=f!Y(Fs@RJP006^~Y?x8_vvG$|ow#pmy{Fnd}ATgw_H69V`T)#EiP6 zCVctibm8kSz}CT|Doo(T!uMYl=W&+)ZBD57tCeVgCNj&?n(@4Pvyj$7J|4pssSg%E zcB&{#EcOQj1Gd+8k zT%FDAh+s@M)-#e6X*^P~_5SNce5vp)!>jZ>nZ_xY$o^{S!Yj3_$m?W%w^v6j-10#> z879R`SjPRVe=I_Jeq2$HURgSUp@tHO`VBZY^uZ8afTB{n>*ULYRF4i%zvZ|*4gSi# zEiHHgk2Yf+7X6o%Zu^sU2&6!tibsD+u8x4m=g(6)n+WJ0DxDmc-FW_8gHFoE;Q{7FC3{3K-3X}7+H4#D^J%D6jaV-f)Q%~zMI#g1ISVJ_tyxVIHubRmR8h(1YJLxdjuh`XCJKM(v`;eeHN(4VX{66ADg>a*jWNZ!A z-k1U6I;Ixm2q(iLE^CHjzMnId75V&ruyAzW{sqH6kNGgT{W`R!btH@hS;{wHpiRk2|noXlxvffy=v2UbO zg36MzfIMQJE;znx<*|IJVVjp~USA|AFL-HgK3^T29HS(j&Pr0?lTz+0u$fShX58;v zKJ!tEe*0lE8s)SbVD=kG@^u16OI9WgxseDEN(50}Fd2nQ1g#so0pc`OuJw}b8_bOX zwT{73gYzRpz%DGlNVOqu8PBxjB4~mI30oem1+m6dSq99#<*||@oot>yuAHKkCFeP^ zw*~2>zB-asr+N@*3AXiS>{zi8I3N8P{PmtHaDbK3G5go2`8}b0$dZcZ9r>uIcPs*d z#MJF((mrpiuy56J`#hO?I?J`4A;l!={mUUJICeIk)d=22fGJr?rQ2+8ZM7eMX0H_2 zPtYCE0*JO1e>BI~k-R>^GI1tRU5=4~h9}~CzRZhG4~~Vy!u!gu*}%{3S-o)}w>;@t zU&w*(i)<~SgS(LO2IzJQrrbF_FjowNhB@E`A)v(vaIo)0w3@pt(la#l?Nq!A4o~TV zExC%TR*?{O1r+pRc~cb6fX@n08~TAez?zZ^6Qh9)A4ZFm`u%ZtM#@t$TS< z(1A)g!wQ`{O-6lPSjcX|BIPV|Vz9sG%6>HANO*EFu4)TTUrB7j={&!-hmI|*%t(vc z8c#6S$_j1hnpslWNbVGoyhnB;v4O=(i~I_Cp@WOosZt5;9@snEH9`F_GuEu&&9d(e z_`B-x%6wvNH9NIi!&9>Y0sK*CMcd@R%?q_wdo_=czt&Ni>^mDqgZ>33)F@)^8+cJR%?SuF+eD#*(hum+#o z&s=+5pTo~@PflL^_3Ys2_`Ac`e?5aG`|BAF!#J5QFE87umXzg)LOCgpa~x+|ZTLU@ zWoH9O2n8fS@3)83@o0@U!Wbo-wMeT9VPqp(MC72L*XK6!1)U5nawBluOvp9hXzz7i z0<^?Bi0V)3Q(j!c0;AepB)zK+2br+4Z&NecAJq&jOn=?|%$Z+_*B~AGjzyq)){gc| zJ~}AC1><+LPsi$t2!XHEj!#Ry*=@3*Z%H5wy~{?N(gtfiMjdn+b!bvM?82e*Jn{2G z7kGd4yGv}|sPjR5Q2bI$JbH~uk&YACN*7!38GCNvujo3g*zDG35Cbpzt~BJzihFHY z!M4vDUgujXH-MR!lAg>{sIs8@={conse?onqSEKRO|wZ6moc1j)0prKx4zttx){QQ zyAc(pt@b7@3++t&5H@hM)81U8NI8spas-`Hy#_glXHt+jYIwMfr0xc+W-sZ(Ayyh@ zbszB*Q5~1A+^GUF0>==UgBIvWme0u(RD-7mMlG=g&qDt_5clj(ru zCJMxjV$j2f)`D#Jr2%x5FO)HgdQeOmU{y{rL2Go3mpXS@dju@BmRL`>W*yGVwsL=A zw}X}uXvl5js?HLGnOE=P-dMrSvV^#<8b3PIn#@6!N*>@glzKN&ntV;kCcT={R8{Jt z!E7|DdO%4x7f%e*Ca53B;KNo_6__~dR4!92`D**e!V`mJ%E`%VLukWiOPJ#Dn9dd7^}1A_T>GM|+f>Ki zERi&-Gr_@@+(5$7BQ7eB7@6V!Q4Ow*}u~rb{2$*Kf59kP&oNHk_@O#b|~H zXC{noX%l+47F_|kUuL?wwr5B8F5z?0mympM#@84@l~Fx$>H6Z#?!aPU)~y%k?i^KsZtai-_gXL_T$dP3>lQhPhO4tZS1cNf-2oB`mq&qu5pHpKO z7r%2NgM5u`Ql~l#m&hjaGRH`l4lIdKLh!B2ym%*ex}2TJo^)z-lTm)zCM#E%vxTLC zM{?RZGd-R$))3EKLnaRd2wx#KQ%tHUb7?NvQuwf#@14;DSxKlG=My=dKqA3$4F9I* z@#ws~(Kcclio~iesI6@rW$;XVA;lpGk%kh*p@F;r{b!8D|FBh*es`kenc4h zK>vMo4l(-fMCbX`o?j=_%n6UpY-2l?%bQ{3nON_&qGms1#&tqyrg&jyJ7e%Twsv`2 z2&(-Qdp9=LlXW(aw*&8a+bzkyFd3&b2RC5g+xBa>{V2q5?med^SEW97ODAJ%lc_$o zgI<13?*+3D1MyMTbs#XMlHVw)q#_1Yr9dT7LN3fxT1hY6+qO3oOh#ZuL=ZWl9hE#_ zRex2=jsic6aD$8zuN(~%)!JxE=$vqfbm*3`1F}x)ct}LXfXt;eI=D!|spB@jaO6>X zC0iA(ICKR|=t>HwZC1FNp1I@KJ`^3FQSTz4OFdQVQiH%18m`w13(~#_PPs<+2F?Zd ztfQ4|odzpOVDtQ{`owY97v_a;n>8P3d{BaF)z0AVm9O*$Z$X`X`Xt~_(7Bh0e(7lXZf(aOegiRK{LhCY9D@0St^u>|F_0Wr@3pC{3*8TT-Cdvt%BCABpeS3uI?= zmDM+yi7Z$YYG&S~9fux{WnQ^%Ie%K2Nih2ofFNqGPF2!xfN0cY?Lt!O`}tzBOs3z* z?@yAf|7{VUqnxs&WvLRl$MO4gJR6h99LRHY9pS9pYbOQ*SB~&cbfGG&9Yke|5>S=D zn!j?+fi*^EDcqJzrG~K9*roFi+d>~e*1J+ys;oxr!N@je64QF0s;MO^&?BIhcy5%eGiPbtv>v97B8P7)36z|;$ zrv|j7N$HanAUi&%$f9Ra-%l6~u0JDbF^NgSj`ET$+#(^}4RsX_obFiP-UOEz>xZta zB34UI6{5OVbaFyJ4vybMIglA9abJP3f{Nt2m}PnJIgFSS<#IYK&|g&tgG;h>Ybzj3 z-{P`A-Fme1*8+?MDe%YnxhM|}lG55>64tjG3r_Wu_QP6Gb{fiSdl1b^W~DcN zI`)$cUxZ1GG4<_0+0jF!)QxO3MyNH}%qm=ZC zIvcVs8irT&lzX{=1#I6-CCZVjGj_Zry-wh^!?C?wSE^5yT(5!4E=wV?9X`v22JL!2 z=88Yo8w1XZpL@89e>NB|b~p1C2)g>YC+vrcrQoB<9&SgQUq)YUMG1Tk|GyLU zx}a=Ck9yJLZuDq38a#=1ccQ^o)PEB7zjTLzLyLCfXlEztK8d=!(e`fCAK;5SkC9rk z8714%!vTK#=yCL9CyIBX?LpM*N4x##;TE?3um`RCWFJ4o{%rRU#36e8gq!7cmAKR1+H7yO*s1t92*y83vU4!g4Sq9gg`}c@ zP69iRZ_nPj`!z%ghN6;yjj;^IY;@qOArBF7E`-rwNt0gsyFeK*76&AQZ4z4a2^VXf5#RPS=Bg7j~*Tr~vmV9A1% zZ?xko-R;C~aY&J_XQ!cJMkd$Va`Nk&Yc&o?>zQYJZchGE7V<~rfLo@Fh~-#X zF@@j884w4YfSam|PTP+{Yrz&U2bg&VH;#kTy4mxJ10`?$72nf3G20e4fpeEopJ%wj zT~L+B;-ZMD5*Z5;^5)0tvOi<5{3M5MggGcqnxwlN&0~!QCT_v51a#;d54u-KF*xL^ z9p+G^ujxE9fgCWHH?WnS>|#=K6--@x*x7`J8Y~)b}FOM+O4vw(TLv47+ysMg9)@ z({17%9t>>yehsfp&`$@yb6rn&!-w!FqGp{)fkS1@zxF>*=*pkM>0J+n^(MRqyUFhT zWn5;BsTIn zZbNA%eOYNFzWL>LQspO>5LdR;(}f4Uqzx+#U6*_vsW7Y=Iy&H+gMC$%SH%Zn2pz>E zJC4a@Kv{Wo2d<@v)VE!|!oVuG*%j!RQF$xSn3jc{0w2vgS+TH#7Za&AbS3iIlwf4v zW}x<&0Zj;(9BYGIK{UYw5*EZ=4T{atC?z&EO1*?lC>StSo?}9hb5_?dPKD~9nu>=u zrLAoOvTVY?QX;Xe*&lugj7I2P8aK*}T-90Qupee(2Yp7WgN9;Y>`g&e3kc!HmjmT& zjE8xf+@IChvW3n_QxkG$b8{{L&W+~a;gfakNn;$y^CF%M#j%L@9(azH$*iBR7ckqP zFkpCZ4Okcj-Tf)KDpvyI2{;J(3MTLc-%DcPfcnLx^->a>c6;&>7xW^6*1Rq;o|t}1 zMUwQ_B0X7otKV9qxe9erZ_#qdKKWs)ve@F@G}7Qt zIDvWw6bcLVsO3vL9hOE5tQ^<`RAFruDq;wOA+8yd_;Vz2T(#c>?1^i9w^Zmrixbh${x5 zvT+!!BJR?(3h;Nj_PrNFs}!>Vm7kK^L`;Qxxc&Ic8hE$zomPo7ERhc9Xz8`Hia|ez zRrqt7T!Ji8xae1tq_4E_xj7TVlsODIjZ{aSXOA3|j3$*G#JgC9c4anEV?X)@G7CA%!PY~}1X5&bj_zrv8agXax$P!S;HO#~eA1^uCn_V5dS)!gO1TX(DoXcwNAU>y{Nor+Q*=c?9?Jn2P|&aiwU z#l*4~TAcnc&M&+Z?8t<`17G2pUtDqYioPR;6Bo``f_4jVMsv;ShsNJEd@8~B$~MGA z8HpXFmWU?pZ)Bv6qhp&~?r0S8d7NgF({4N05TXmUiUz9?a+8l5A9e?p$0pe|RViV5 zE_3uVbUl27Nb>vd=0pwX)^yhCG+alSRuQUv=mlVJKwZI=5!+w!jMT)G!>(pRK=r?8fM3&>AgAqcKr$C;(GZ{H5$w?b*`!@kbSS_ zY_wIC3R)*(oTK+Z1Ke5MUK&*|;+*{eBIQnd`!l<%3`i-~yn{x`ADLs&0gANmN1$nS zD}nB-ineClP+tX!=?nzpV`)XVZXp!*&-~qv`+a>Cp=15w!_vlEWiO=dXJv0*>Yz$l zURLo?HQ3Ec&QaK`y`j``)4s2ck~f{GnUgo6-;0a>+FS#WB?du0s33VFu9DiJuUyGC z8s}8~ya!zZRh}_xIYH3B(5Ovq+X+bx>2$PD!^1y$jMfksWHstE9yB^@0UByj_d{rK z=w1|&s~!3l5TKS(Dvh}61ir?&WMZF=acQeQ!NEwWKtPUDg5bZ&v{&PCvN%KyJPh=l0S~$<(ePlasmBmMk$F*|{Us8?#6z zqqwJbk-I$!{oS#86zr|g1>H|Ru;rwJS(2l@V6+9YA&MDF)jGsPe+rqeh3kF=d|jDl zEqiam%eubh3XFU}q5FCXtT$*K*x?U`g-NQH3g5C=)-pPaq}Le{HW;7-!wnNgU#Y&# zLS5zDt9qF~`yONlqT%1!J}jMmh|gKkVsjUiYht&lCio%w51fm$t#;%(9_%l-+i2{` z^w?kQv?C7JpySc;O1A|8BJkF3yP^WvUq5O`9QaTtzVA6))4MNm=$czP3!OKptt``$ znbctL2$qB6#nlmo=uI&n2FtwNAT*Vg8>b7F)neLHWqbnd2d*zMT&EhTvQqaP7Fsw* z^Scw6K|k;G7U8#*{@tEC7DfN8%7J$oSzFm73pd6hiq2lR)dpBDDp>LSy)pWtZuq=? zFATj>gfsW!MynSLU|ycqU57Q_j|jIK_<1FFC1Crb5ZG3)J{mb)7mI#N@w`H0`RYt{ z_wnZU#r{?kKlcWxMALsHTfpkqN3;p*QUz|k4OR&IUzNRnzGQ&=*&cPR{k%J6egect zv1#hM_|fd2r4l`Exs`63sc}QD{2B8%?sazsTl__K*qq#zk7<_$yZN#0w8eQkceC4W zlw`9Cr&jLt{?JEE_Z|hE+8{tX(VH?{*DQ&ZhgzIoCj5o{xW{p7U)@>durwv>E)MLh zf^RguZ@H^f(1YpzSwNAWMjCM!7E;6Vn%}p~@2Z%%*G1RWTptc?C66PJQlaAcrp1gh z#19e)&#U8?HH+u=Jk1^MDFh~sp<#sRfe2PrgwEvI*0}3%_K9c(kgy(U= zM=<%L7q7MX9+yW)C+)cA$=tjN{;LBHpq~$0V&R=q>64Me@ zD~QdRBXt+1R-vUwWuq55#3V1`n|XI;L84q%V6?mWbV!$f4w(kL`>)XI&Xb1?0!zgp5R}hR z*~1b?bXTt~4T~~9o0KK}57uLMYrF2ckU@)AtJ8g82MjxyK`oJ%YHLYY7UL7o$&P5z zCK~5`2}*V{vg|T(Sj?8gUTsP$N?Ky3@-D6#EcZnkQ!0zDQ&u)%n;w{2^JOTI2)HFF zFy5`N#Ry3*g?EF|!xW^0-5l5OH#fK1yuPFjPvy>4TS<0~^(qwFXr@Ewtgw`t$}3i9 z=s7$h4vE}qy>di*bnyBGFqw^P^*Xu81=$9*s=5@PUNO4s4gWkHz_A;B2WR~lr$!^# zv`p<{iqVtOZ{JGkw-YY?)<*5irl&CP`a{07#rQ$GtY;Bv0CGrTV8)3c1qGPsoL-c0 zSwz~xYMn@NYjgV{*J8m>u@a|-16EN;h#z_Bht?tb-TBaZ9pU$IGjPN~i*CBNHy=LH z#2F71XTYY!sX&xv16mQL!s7Xnt5h(o-c548Jqs`C-PRNUg8%h z5GiS^!k(PgMZyf923dwgSlGen)M!k_J|;?oKsC@+YI_{fHbMZ?vZZ-H=`ruGBe^r8 zAPY(L31G27zE|?*bfPdXfUXEZ)v-*6V58!9J?>dJX%OZ0^TTiV-@G_I!|6Obc=P(t zhheTsdi^2I#cC35-(=n}~IQC(ldeKIV7C&55d`ZLjB z+sfb_T544l%|V+O3Vxn|CNyEZ*v4#snm3wwdlhn8Sh1M zjQyR7eErs;Vuq$4{QAdhK1&p)29m#*hpl zIMn4$tQ$)4;h<{Nl&~^S-bBAL)VcPS-D6N|;&Zl%DV9}JB;jcDrme+{-@1bR@;$C>%j;K!0tISpQ z26j=YmR)+PWf!R8%4e#M6<80t!h-Sp#F!|qvkvT5IxNT)riewF^YyQVZ*#6T)>sAiM_J*lG;}DIqWoaWXZy9NUQ;Nf^rSIDn9+m0p!1`Be`m3TxoM=5Mv=MQ36 zY(fzh;)KsmP(0}&<|Jr7SBrPLp*UnXy{;)!qFRNI92 zK2mKHNA-&-o4`9ODVxXd2dgNX*0~WgY>^Fvt?P<*lVN<3;^lT7f|Bs0Ns1Myq|#AM zVQmVm#Rd=Jy$010`fc=Q!RBzb2WA;31sK-dbUKd9cSor6xvQBm>X82PRmRDY^lU)rHM zkBE?1_)wvXX;2uPLE_|oe|Y-ctLG;z?aa_=;q2lD86*ZS`{Biv)$$bsKHtu^&NwZr zf#U!f(Muey2#!$Np!l@?B&ka7gk6Q#Y&LObXj#3*>O^TNF$)wJ_rk%`Weg@$1`3s2 zLg*E$%e}F+vQ=%C_}^y=OoS{x+UMOX@juahc9NBx4aLboE#B|T@z&kG`xH=8!@m(Iu+C$tlyPq9fhpIH`y`_ zm5;`7PB2+ix0uSim8GfL`c_Z$&4++-Q)iqm5ABp+yip|2Ff?b)pSe>X`~#O&iA|lx zo;erG%EashU^a9SXGVh+RhD5vfudj6nZUkE)ft!&^a&*eg%=QROvh#lo_?uOE8t$U z0!}!*cAzklJ_$lH$=>g7e#t-}-@$rdj<6RE6`lfh@e5;8pugQK%S=F>)-oaVdmLAx zl5ax@B<|GUotvH(1}))9fu7RIt-7arf{i=9MBz9O?u3MCJ}XeEp{t^EQ(0BO2=KiU zbdgMeF5-Sa6_6J$!Pm3pWj)i7+V8>1+9)MbsXw$(H< z8+R&Pd>9uaJOlNi4ns$9sP<3D(7n6>eSi=S=(0WOyKyXR(-K0Fg|~o;vcXO0%(4`v zDTrK{(q3YGjbQB0*b1`w0%@q;A*PK0wJ^Tx+k-zJu5WK{Z>>LkxVy7uHhb?PX@eRF z@&Pw_?>t?HO^2T%xiGx}1x=dD*QTs%uwfGb9eJXPI9K5$@T7IXB#w@eWed{aEF5Z=`vi@r?NKE=e?KT- zF!Y4iODp7+TEK2hrP-K)tr$Rs06KdS7DuzfAJ$AHtaspA2d2XQVzev~r`(>Hw$ zsYeFR69el3_c=A>r%ENl`dROit39C5hGp!3n~su`tE|^-aQD_R1aFdz8*44|0<%ip z8~CmJig^=kY7*3_@N38{lGMNkd`MQqeh88|p*oMYskQ}g{VZyjzZ%hA)R6{|@bs7GA}j_{q9676+z-BVPxOj7 z4l=HMVN7MJfDknWa*S^6kFvhVt2I-uz`?fFMVC36h7fsO_E$yu5alS&jMnG~M=B5f zla93V&_?KTK`y`HEY4Nep}#GCJ=if|l-eLbSGj23T0IwYw_@tfJMq*Wku|kWKD~{c z{bMog_1v=&1p9u8DL!-uVbfK%3^NpA>STm)8lfC%yHfbR4_D~s%iy^qoz?iotDJk` z6I+g;6;ABRp%pwo=l1`$=VnD|h<;qT6QTvfnj;`3vfAfVHW!)obGr*wMOdZ7eNg+1 zunVJWJ$H47H>1YN;VmM9k12C{&pofydf)50t#BpFDICY)L)U+Z^X8i2Q+e?TFOTF| zvw`l=222C~J8vrJ`#H@atppDBB{cv-fHZP&kuKmCuHUISqGg5k5gMqE;T%@>F>0Th zUV>Vs0TffF&ZmRitU2r1&(-{$w^wU43M}3P)BaRR4)W+-=7RE!LA)7-Bk;M2Qlunb z9Vw;ySfE2j-`6s-y`=B3pQo0BSObzvXgl*CM1RD=p>5dm8sN^6=L|L%I?gueIFsXg z>_m(J5NBY5tPZnmSwVITo3+7v5lKl7U_Gy_o>ix9l4NQ#i(%{0 zx2r={n}BKOa2us`3F$fI@?zV5m5M0QE7Y9mDiyOHFq*%k21eIf+;X*Ve%&by5JNMl zLsj!SreCfbP0SKixsL>iq~CZc&#QH;#(dWMuoo`D*wU+Lk_lSj>VB=c#kSV=tSt4) z!4@)PsvK8`tuu!>uA|h*xH!M)_{jC{c>SAs6a7iUQ*;-Ok}{05 z+-+s4gQE)5+tUh3$9Y5@gc8c3sLrTbjgEk0R9lYexj)J)%bk;li1cV&0lTZ2=;BOIA4Hc9!?8smOxZl#9j&fT;8 zzK&^MF!>ure7QaV8*^itPBv63;6_%K8>6(l(R(+z-005I5lF{!1E++Pz3KbuTHv69 zgJ`SHEC_IvQJQNYiJgxt;zNZE=padr_RsfUs;Yxd`leHdmzghHBrK}X&LoV`1q(Zt zEIv4@rXbQlMn@bUP%@(_OaLoE*tu`FHEh3p5_W420JP6JFLMg_vqoW8f|3fjma~jQ zOgi5OGpNl3a9&%*J>_IX(@rR-pqGedi!PtD2A7%{aN;>eZnda`+H5G*_gboOG&t>E zs*PDux&4bAWvBWn+iMhR__h%zCCJ|O^WGSXp=|Fy0)tn52p=>Ezw}3oe1KIq>wL_1 zgQoCn(0i*h({+AjCq$6F^)i| zt)^7EMV4xY=$uMcw4!Ee&GU6VrBgv9W?YH`%z{jJ_NlfDyqH1QfI9lVWzc9^28>3> zBwlPa{KV1+_RC9VCPZ$=4CyEK{VLogm$N?~ zzCJm6_0mf(Sb+;n2&)lo^~66AT%HT;M|t_R)LD`XI7MW0@lyIcz%OnE z^I3GSon)8??yEueS&nZMy%jT3LTq#Na#^<72Nh>Lo=sWz^J{xoLNo|&$HVZ+4EE0h z$w^)_c`O_+LRG;Lv&L1|)J1khu~y_{hI+9M>&h4NuGG;Xw>Eaz3jZkgKp%&*2e)B8)!C`GovBv$GR2S&C zr{&$YvAMbV`0?ZDH(T)E$B)dvSYLQ^YxnUZ{OsY**5l3HtnC)C410tbaFey6iNSvP;ZPGWT`Mn zQ`^y~>HhgiOPfl)yhv2-QxHTG3}}|xmfRVkCnt{5mrZd~kg?d+b?WLm?qoz0NJ=b` zIUWPybp-#52BY{K=^-${l@;F*9H>Nc)st4#Vkz-uFgvJG3%N?(x)SgXHL77^qkCw| zDB<_y8PI!iLw5F15+lmRRYV@pVLs}U=BXcP$K_SlI~(TtyAmEhq&dRy!3hCmL9hDB z6dJ>VR`#Q`Sc&rf%fdSk@U*b+A;yB2nDoGp9QC<+Wz4QS@&Xj;`8nPQV8T zUpf8mf(XXz^GUeZibwQgSPLDFyFBBW)O5t;2vg}Og9Ix%q7#Gz!{x(XKFiPnk!h2jzj|F~fw-?9p-d{N+gm(^I5g=aTFqE%FS_hxx-iG!NDdbWpZ&LYL|f`UIl# zs+=a{2w$@NDTW}d$)IN15NipyFxp%D$4BTqiZP#MELkWI#5mJ*+PH&Zl3{CwNz!e$ zM;4vlV2ILNLQ~o)C9kS@7j6xg6BURR+ETB$4VeLH`f!Y=WrFwjKS>Rug;S2dzEe_# zZxugdHD#6|m>%xFW2PG!vNT5ddYy7s*3FkrpDxC22IN_4@kz8@jFmuZl$~Oh9c3?* zOWWthAKIVL-k?uW0jqcpb(b!lKsQKU{P~F%6R0Bn@qke9CR7ud=_T($86y>~NJcSN z>>>&G&6UxFkrau$RzRjnzo1c1R;u$rQS5X&-MAd$uSg`Sli<hMQ7vq>I@WiRc~4lMd%h7KQobCOU=C1Q+pLG&($)EpgSoKe}PIq z4j7bs_A1L4H(Nh<)%HzDJzZy8bFDHAl|r#VBiJ)zW7d#}D(g`vw95LNf->wEu%V~U zt75c>uG9Qr&F^0HwxMNS<42C`c%bOCx%=y7mwtJ9*`}}4*_gcPI=`#j80MGj)4bfUSq|DBkSK$1^3hrZ z)-Z1H18Tw6=Ad)ulp=(uZfb7}m6$`D>x_uE|K&p=C1kJBPugkmb#ur1yu;WD7+S%y z0I9>X>*|Rpl@w!a5-W~l*>U7|oEhwvgHFN@V0S;^i|g`IhbPr2vxAhtayv_6;$J>Y(*AX4Zy7=0?&hezXHkR6u6vW#sFT&Fd2~Jl^&8HvL|s`M?xFY< zQbs{RFlGtoixR5rNQnrHlh}|DrXbv2KH-Z}*z_u&6=db;>#~Y`Q8$bj5XN0-w2X^8&rVWcH*_C=U}Z+> zvuJlU8?TdI0z$7J@vCi-K_>n!d7n<3TRWSwrC$|xHEjHnx)*V-y@Zv%I-ynOIYM$G zi>#R+8Us)?Pr7No^;LiBY~Ipox%$1O%7f?%|dCmPEe zvynI$W}NnlT=Icibo_DbbF~Q_CB^qqS)8f&>@7Y>2yj@}0R=`9yI3JH8x0(BYt^5GTJiL6oCu#$NU|q1Gz95z9|4<2qfoo{8S0joX6K?7QMwE* zS^4UGqOL1~zG`Gz?Nm0>p$2u0R$FsioF+S5IZ$dr`}Zq8i;)EfU!(Q) zFfCRk(Yp{P{z8Pa-3#%xI;xI+jTPvrC>|y6y?O1}Z&AQa%`nbj*Phvf;gAzG)4B

    4pkdnN;0xeJ%N*In`2Mb^;pc>SU3Ch7YpHAS3J`=2QO^2yoNOHj zQP7LxqmISj3nK$ou$k~M-4(=TJEf( zvl+3-$7yCl>qK~-%`zCqS$%JOu4JyoE9mMO8ZhtY%VwW}|45uZ6*CJY7^s_|X>~Xd zMnzK7MMG!4k)wGw(lo@p1v%BJaB<7d;O3A;cO*Y-SfnUPec=pB-n%lSZbvVR! zRwH)t#G#_M=~i_&Pq!@xL4EU1dYz$NO64#vyUPZ>tYb_fwQ6^%x4Uh1%~^VmtDq2Jc-tm=<{#bL~Mp=u6@oo9{%`m>I{eFz(De)7?u!Vuvy6vaaL~mt!eMfTY4XXa;?)5HkK$L=~xsH z%P1sIZrs78s7Xlljok5?kOv*CvrLl`u{6Kh*CPXs1 zY!Kp>RY(wRbMiGSisacvT+#I`Ij74+6Q>P&S`tFh+HF74A98BhpdamPWL>f)RD~TK zXz%HRGWCo6Kn9;t`e^u><3VuyuME6w|$0*MGEp09~_psqSD(=|TIN zr|{~ZGH@hLO}LY8wFah*GJpuH4|VG@!Il*W#lq2!Fa*cxr>VB1gK07P*8?9`mVt2M zNL?_J+;K;xwV!0ExF)y zO-$*y*7dQjNkqShX)Zy(;q5bcHSQ9DQDX(s^=_R(j zaIWlpJi%)PW?8eATDW=LBrPN8-nPX5`T$r!r@vOTt|n@f4CIUjnNyl9u4ogVAw-91 zN+{%+KFA{L{USXdh6r$%sKE4d(!^6LE)7lp9Z3H@+FEodA@sxwhf-^Kz1BXes-}q1 zlhhp~BaSLnwQ^di{@>%FWp(f-r?{n;xWlEdp?I@?y@HY5ecwVG0I`TB2mK*o0CKlMi3DV8p_b># z7*~DkYYC}K1aNo@e6gJJrg1(5Ul7FPMg9&8yW-=V9F~ZRrpn!y!DG=fc9 zRhH-lyT-KrHL$@J+g{r(@AHTJ`PL)7(1yARprzy3EzPueyRG0vWu)#P7UE_CACEtagnO9v)DNwF~?$*0xxyJ ze&ZRiJt}_jL@6L;4+cwDNGZDxw5bD;5PT>dV-c7{5^v&ju_;Bo_df>nKk!S&Bm2?w>n-UyS0yQcYLDW9;v*s)2SH@_m-uX zHBIbODRaXMZqn|{S4^4_8ehJ8et7o$=w$z!7t-WOC(NNi@%?4{OBIqKU$FRo3nZTE zfcfm=M~u@G{zHiw)8*H^?I4ULT$f02rZBF0H^91vUxP9h0d8=%o+p#(unBF0B;|gs zDJi>1h00a5HEM-X@dw_0AM}UllugV1 z!hwKlR&i3bkae>sV5U3DkyV{wy>;44bpST!-S@%l_~knBAv*p3&0oL*-)fj3t6+DQ z98~lG#LmN3v>ag`U(?@yB0kY&z-~1>DufBCg(pffw!Os<$p!*MYj3tFa%<~RSWXbn zKizutqgRVgpZ1toRU`_35m>aT09&@*UVQA5$1E0&`B~k~r2DKVq2@eERE?&%=*4+v z0POl7(hN-Vlk{(i4gX6b1)(Z(eL?3cS)lQklbkmVsbjwFz*iX@?49b{cl3;R-a^-5 zEVD5JUBU0K^ULzbjslZ4Uy3tZp0Fw&IqBo3SIkZLCWmO_HJt>VyB$W4`Z6|(bDG!_ zwHLir)6f6@IPWHeAL%IgRyY6M?zOrKHTR&f>cXDt+Q&IdKs}uF`5Iqc$g@2o{yt^U zAbYblv*Ng=XA4ivWkyNs@$n52yS2>t=HF-C$%R#2z^Vxo@#9qCn_nY{(y#c3qI_n> z=$DHB+}hgR+S;zfe?Fq`@2Nk|&!_lL9sdbzP>uhbO|jZ?D!!*TuV3J;Jcv>48UXbL zjWi1>QlTWx3CxuEFlbS>KK$0OVlr*k%S9wF={PP@F!uW9_Qpb)NVB+$N|VM%ek%({cyu}QeWb1+ zaiYtGDh^NN#@687ATKYaM*_RixS1K0faIk42MEHwaio}K5;d|S=n z9nIxA>P)H?tZ=Pw6JZWu*}yjBYK@@#UGQC(KaUnpdwY9Vf6DGHy(>vX7~azJ;g@B3 zOP`Wh;uoKi^Y2GH%9XgDq*KR>BNb!Tgp~v7Z>d_>8bJ>W{W$x{jgAeq zuLV~oA*|9G4q2C+lH#Bl9MjZ5zeNW&$q`Rj>G_be=XnBRC;1MxQq6=6(gJgy@^`?w zjBrFED4kN-4w?1N#s<5ikoA+k_HJO3PG`eJSkh@hZq>d*?vWaqR9s30LAF#v#>U1V z&o{bp!JScK;6UE!QpHwwKCo`kfTtTR>)dYOyN&BkRK#?nIUV9H;0OBw)dDJDkMO&IyE2=D!Q&i_J8>eE>%e80e3^#927Y*|gr?O3iNBc=Zcvff+AptgMmVui~$( z)rM44L%C@`Ve==}x!u4I><2`JvKqvf&f$eEr!FRU49NUc=2^phbFF@@X10S;|MY9= zH3)XAho&pfu&t+C|H~Kew;z4QZ9H{asMbO|VpU2eU8_=Bj8ZtYVi<3INqUerMSvn& zQwtZ?rKRWV8xB6O(@VJSZt0hQL*)$%D>6p15^5}FsIwCG-8L^c18S@F=KL`|5Du+~ zCwPHIB5$2zIuvP(-YXRw(^6_@h&0s^(;|XpuBVo^DAK`KL#>uj(o!-D5A%Y7X!4py z$)9`H&!v)c|4dR=vuOY1;ONNglo5!4W@oRn7FlUFp|fJooCkVl!gB(1ETJf(`IxfF z2(6Yf2v1sy{F)90XCrVr&1-Sb+A*t|7U)UwSgkBVmE zO5aho2GFfM&RHlg=W|G9UTRpIUt6wAHS)?|AUVlhcGWc1Wtp6X_VKfbg*9c6%?VSW zI$fT8#sl#Zt#XoO7R@H; zDsQo!=Bz3-Ec#9O;Cog(6TU#qwOh3pK%KN~%Z_DR@+av4)7?cSM$d&Z#zITPgIH!A z)FfHl8|2VXEAnobQSl|_RJ!@F%6P&LLiYowK3l9*)X(j5%xaJChOBClxF1GE?|4{{ zEWH#&V$niS@zQ4Ji_V%wcES9Aam)GVv8_7$3nysaLMWn3u7_<7C^t-~{-y1#vMM#d zAgAq~gm!D^D;lWi$EzvPtj7ihiskZY`lXp2UoBQLRXLxSGN7hxjoeMXx&x11Bvft9 z@oNE9B|TDeJ*e8Kag~V8rhC1Iowo52;LmUA8G|%9r|{q>JO7iN|H;n(Waodf^FP`7 zpX~fkcK#YRjVr& z?F*42?EDBur^5Q6bq_5xr+G{N&M!CQK^R!WLfDT`zBDZ&+O~_HK7DH5YOJ|#7?`IH zxtLf!+u?V%B$Q5m(7v9Q1O>NP{9Y4J>Ben?Q+B?7Gx}F~6@I~Yt!J;zukw;TplQx= zH&(5JYj5`Ngm>?jZ|{p|?@fkNq6Nw}EuaK}9MuP~ZRRkFP=M#D{+*G0CPuPG65AWZ zL|jety@gWvwUx~J_IQ?EVYr})=)_``Wjjr#11fSkoQ_8u#h|zQB>(;$A_>_w#X_W*rW5ls{O7R=r3w&=S&q#9y+`;dti)r?B=lPNNBzXXa6) zc)*o5G!9Ik#A7o3)BH`A;yACXK1FCq%JWf1Ea2DWmt<`Z_+9kJkTo8RK(HlKvn6_5c2#|LH%@Cp<|1 zeS7;!Zw0FOR{G!n3o%PQZO^uzv-uylA5u>KBTCK>?=80r{MTyxO1N$1-J!OHqWN>} z4jSn{?cR{pVrFxBKg@3SE?SAW#s6W-W)rPM_m|ossuRoZ5#}gGCCN$+39Yg*D0&@} zMR2!F&`Xz1*OQDx+AYBCSTFr$f`R%aQzHdG!s4yvI@Tb@Z4mKE6L%@!G$FmJCY2|| zQy&O&9}eZy{21T7Uch0~=wH}I^$FEL~{<5&!Ltt! zQ+qZU-;v?W3iQ&-ON7r?mtgS}lYFK_aUV$smCPB*U5zeQW2Gh{Do+7cr!CwHEfA?r zDN8@9{3-K9IsjkEeJfMDoGimWp61{3@aM`h&4;)fzt|#^5Shp3ZJz}dchMV)kkh0l z=TNCIpGD|*+dEr}wu%W|_+7i__cYu^`;EGuI#g?9QI+2IZo7Bm4MT?$6;8rm{EgwS zwYxdg9&?jjD_KqU80|dhH44)Sb3DU0Tv=5`xmzk1R~63A#K%~`8BTS%q+qUmZ%%D2 zW=`HqRreU}&$hr^p<|G)HpwWpKLsAfzcweBXs;%k2sOR)N0-~XTYcvV zN}g{}@2rni4tfK-UKf4je~zE|&vOR7GbdJ0HuTI`uW+(|10L0m7~k_0+7Y|$#|)VE zu#G4jHD^i3xMeyuCrIWoUS+?$a=s4ll*(e#F~O%p1+_yUI!so)7w}dE&@j3G0hES8 z5uamP?xN>3w8Y$}W~`>qd#sXz{|!6N*U^vzvk~n&P8g>u6fN9nqXfIid)P$oxQ;VL z?nJW0+tJ%YcGa#~YK5iAR+!k`MI*fP&|UgNypd6FAj zZdF-@g{0auW6rom0-2GKk&%&+k+INfbJZYus7l29%HmfouJEL{DGB$OVO+2h08`54 zcfpJiCvkx(<2p`wtC6jkblDl4dn*~uWC422a*P)qC7*#Xl3T!X;mh@Ywz8)VV$3)l z2A|_AjEoN`dCyhTOoMjZ9d=bu7PZEWs#E?#xdU{9xahA@@O+vD@!1)@S-S=+~29sszs{}6>EKw)Vib&lvx}RBQv02Ww+Pb z!7geC&Nrw;P7@TJ(a8G3D%4fL(bW%p{C1$Tbgfm>1648~t6BiDT5chUTcX8m`PVPH z!84HE<4GaeDR_n5QZKJxC=app|Nig)Q@DghF^6U(yaJv99dAe!r9~xJOwuFF99d@j z9^g@upvwUsY3L{5+re&XsW_wz?uh%Z! z4{@Q7QeHr%T2YcE%PeoMRn^Vq7q_+72K5+;iVNO$G0jB1{Na-iwfIWHVlmz#fEv_H zXF#NN8vW9mHx6j?b>r0I|I1=R@wL3_Azdtc23I|dwTi|LLg;-mOj*A170_|-vEiaP z3rp5u$)yX*48Ka^I$oY9{d0R{EPrdjxDZHtyue#3-rcFh0NoHTm61jsNk~V%CMJ?k z*bU}doL6#5NHXE%MYZXV&*#dSDzj3qqi@2f2m8GZ`+i%?KY&pk|G40qITk1O*olxi z*x$NM=4FUDr{#E;Fq5E(DvP>~$E3awQ#=uBmfgx-x9qah1A=GmiS0oF4+aUUXfYlH zr*Ux^$0>PNF^O^F3QA?npbB&;HAw*v+CB;2{I}LI6=yxm|wVaCMgkHu%BX zp>9+Z4(a;+;w=^0NLec7L@&p)@_W0kTd_m`NLI3SHn-!_>DZFekf;FDYqJd)JJ{9_ zxmtya2M8GG%E8MB^b|Ec?7;0?xot{OH%BQ=U0XHE@dvN&nF{gPO&o7v|%eSrM99T>9kQ{`8%tK0el2Z3Mc=9Vjc-y1Wg0` zD28%&p}pC8WxJJOb$O-{J!sB~JYky%b0sVSX01i})%w zMGgLVg21=)PLHOkHeq-3bEx?oaIs#}gHxL)NJ2Y~&U|EpLR`#ArPhx|+aP zwLtRivz3Jo@X~oW8;c&rdM=58I`yG)j5(`KoE&fUZotbsLHksSk?^_dJJC~li6_;d zrABS7)vvgv2wSCfmQjLLaPT*|#LYkL1)b(|p!vAc;m$$pOcxoe9kJ=uIdejAO9$nG z*EEezo$cS~>xYUGGlcV=N~Y!$PQ=~?;NS00<~XAuf+QPzCCi8T%i5?mF4bg1ikKaOW`F2-t8 z>0&UC*lTJsLU(FX>jC*`%;k^>dmCnDBK)$UidxAEFgdTquNI96KI{ise@6aOD(4BD zuAmi+^12O=PqKX!Miio>Zn?Pw6eo)BI9KM)Cy@%~L7@cbK*zio59y0~I77^+(0z!h8tfWIlGJ?O`;r|NPygRLf z7>#_hvnw$P*rZrkLD90;NfS~ld(X1$@&Bs$YcyGOrb#&k-!R2y<+~xumke_ zMG^%z%eelofjyKo$l*k4-v*w4+tXjPN>?{>JVdCfguDRjg#TB@v75?J9#!l{)8qU1k;j@awW=}^RZ z(RD7OPLEHua;!u&#&E4prXAm_!EobV=UyEy8}~jfazrUccG=!vVz#1dV45dgvm6gQ zV#&*C0tzbEB3JiO)}JxY95Gk71|Y{6p~g$WW=ielqNyW{n;@>kUu*^ZKE||7-F(=} zA6^H*HV(O3c-zsrQy$g@Y@!=EmOb{SDy3qn3ZBZ#H z1z|gZuHTxFS(1-Kz#8r3s)RlBfEdabNF}(C1%R&2wh5sA`Y(FmFfQ77kN0PO(WU^6 znFj=C%X<(ZQcMw3K}nAfe%x7 zPSRx(6PMFP%#Vj~myO5#fu*KS8oWH*4MHMwfhm#!pJ@tFJ0lu)@CE|_7n z>G7ZctnmF*8`lW?Vw%J`YMF{N73r${S4(~Ff<7ji*kvZPiOkupQw*iF!^>5|io1A@ zFyf{Ecu=yMc+O&=CoX=Q9o;*Do%mJ`LaaViic@!v3+f@=t0PcuUf;pWu&!$^90#RO z1577Pm0l`e^n*d=3-_v_^S-9|fR*9XHS*Ei<@10*CG**IhcME#E+H78G@#3 zYym`xwK9J-+V^M?QLc2<44w+q zMdeK;#)CJ1nS5T^Cr(;ZXNmY7o!{n3JawS?Y&7zvbC)HMyb&k@q@}>+7>Oz}DvQ22 z5H?6+)W}O>SRZjX*5dS`=ZwYA1x*_yhz+3uAYmIi{PR7H zi0MVWzqb9lVEHR_P$t1r7fF9MiqPRa!>E#J9FYq^A49N{qSjGhr6Yp2{_&^Bz$?rr znEUH7D`@n2kn$IP+!tvlE(NF5V_ahm7d-f&_#?II8PZd7;vA(j^N|N ztMO?z>ROlH#V@t2Oz5PWc%uZ;o{;ZN+5974IG77Mo+Q5QSe zP?V6x^iF@z*|lYoP+CPS=ka^ss&!7SNZAzOJKvt{ZDQuU8upqxG+``BWGV`~1kBPg zZWt_J3`$sqd@sB9^hM5!%aM zHzm3Y^d<{XW%BFaUjKFw0|lnBddzDfoeq$!f@b`MgvNbG0$l(0H~;$iFZhFtyMalf zyMu0#-_01Co11%kd%IIko$cP<=7ZkmgYDmJ_I5TOJb>@- z1|9cjhNTt(m7Buh5Sc*#`%my=)71Xm{vpY$D*RzmOSSFu*@WW?>24dx1JYzvntnQW zQxL-Cvq1D_4{l#A~6m3$&t9k(j{BQ(%w0wYhYcFE?1~SZ4CjE z+bAI_iny-v2O~K}{@`!Yq(x&zVI9YCvB_qj51MPt5H!cxDLJn2F+l%pU~lFQkJvpb# z4-aQ-$H>Go*D+a#0kL5wIV(?{+g-xIS$k&cT5wtbp%rqCAO#E+>ugqtyS0IBL#1I1 zY!_x;g?S!bNRb!J!JkjCPP_}TJX&=KzT73l^CI9-BMR{4B*VGHSW}gXN|ZHY;eB$! zN^%_N8lFXP==(43GL5GP0TC?tM?jN=f1C4spJ$hUNd|*BotNvow9*=>EiXDSS4u`M zkyUJ+_5if`HE!H)Fuas~jC z@ocP<5}eg198o#(=n;m!OwmX|83>3=`SAd?$Jgl@K7C)2w?9sfZ7lMR?l6n$yh%ON zc&H1VQol5_5b|>wMO1nh6(+|Q&}GPVI*p^x)eZ{~RwrUe$T?29pLbR+PsnVq{TyFa zxBei>C!^>p=49ez0vW-8T`XiKuK(!9HW=uy*ar`k-axYF+CWEHI#emqLu*o@Em_=z z0b|TN7vk$0)sj`~=4n*_0{^l!QbR-=PI49yrb0?a0at ztgWB;JjsyO>M9+`(TS&Na9CW8$Wxz!ZK4rLW$sVEo?^l(men#e{jT9k`w@3!9QaqV ztkAE6sEFy8X*`6n=~pT3{-}b`b6beMQuQbv2W=A92by`M$i+eF+{gK#m5bvhx?jXVefR+Mp`dPEci<$B3n;alUNGnk^+ZCNYQ;8l_m3HB$H8w)Yp ztJ3;oe(=YfO9ET63L9C#O5lHDGbV{H74(jVbnO7(EK#J_0VzUD&YU7z z93{vcGwSrw9JY&xvn@VfyRE0qyxoTN258I^^!uJUy5mDf#+&o zlm{Y>3Nw&;ao3!tT`$m9Bz0AC5Rq}d;#$euUFm7gvvSZXz$W#}_xjAU<*fXB}gEqcLLu-!}r&S97u{-Nh2 z%|WGUs*R`PVAyv((YUEA65f1`a=FBM|1p5|u9*&hSwEdJtCL|gze@Y((=5$qxyAdO z<0!>*K|P-g;?vo1$QP_^qO@I0wt}8C(0{@;jF2yQcHz&@U`O{!!2ki zdT<+M{m=G>i?O&4Xj<8%D+RjkN__l=!>|0PDPC}%h$uKG?i{$)0Igc!54zj>L-Ffk z-hHMI5ziUo7FUyV)l?T`it;~C$^6<0y4^0pr$3KBEm~p_$xcNk`q9X$+$-U39myKP zt`ZT2To=*jSThT1!HIK>hlX?cAk6j6NEOY}LR$DbBK_73E&wY9gX`GzXILCnMC+?u zBoD~TE`S-dFbZ342!DJB(&{U|ksky*TgIQyW^AW})wb1<=eclai#_FVAjPeAb|B7S zgZDXFVM$mPaAjhibQE3;Ch4RO!jzjmUE#?fSg@YD;t0mAXS{5Lzwp!`#XIN5fB3XK*A7-IiC z8;^l9hgUf|>{6a#;KQ@5y9zST3L;kXl|&fG^tR_1B!Ex>E4f-LXq= zSIU=RNyOzihtNMjX82Cs7i%8zy;m~y3o+X7#AMeK?^hM8hdNJQ3_yno#s4SOc~%wF zB7vnXqVZ&b7`a+gywg#m*g8_ML5jhQZgb` zGce_JgkkS0E)noFRjO(h1Ce7Id7ZLq#JDDFbcPlhzN^uN2=v2z2J1S+Tq&&3V5%=o zy*9d_>sT@_IE)p>&`AU@m2O|OW#w!7)~bL=J@??AToOr3(8i;C!N)(ndiCl>MT-J1 z-S-sk^b@AYJ|6xg4l)%2)v82_Ev@@s#Z;h+S4pZHeSMJZ`k`wtyl?bb&haAZEJvdN zL!%0dz3qWR%1|H`HzL;Ck-d$+H9!k4<{pqDXd(>Z7K^D>C$I`|w(CgsZt!d{NDxs_ z@4`%}Xq+`y0ae!vQp-llbjN9GyA`^S6;LI8c&y8k_56DBEco? zpTo++Wtwekk>wSW0PB8fypBrgNyQaz6-mGJmV%9^e}|@Dul35p2i*v>8o)1~oKH`y z4Ntplt$)mamA+%x@L%81y3m186`HxhsNZ3Ql>0qPW8j#fgWxzg)&#xZ`xJcYI4w>O zr0>=fq6i>(VE5Si)Ip>UN>HvXAlLOvNkMWtBY-l#%PcC74=OBKEgL!N%G4jVbv_3W04f6Q7^$SLd_n-~@dWyzG0`uvUE^co&W-VJ} z$P=W-hzWKKtkg+1vm={jlc3Bcw`e2x7R=& z)0Bx=s-JQ$4a#YP4h+)-loGULlA6<9asg?W6;`k!PD}JzU_C1YuYNLbBU+oxUA9Gb zsM(LTU~aTg?OD{a7%^Do^G~Hus_f_dUC)Z8ZiX={U)XHweCa#Ve9Y@SKLZ0(vGCr5 zP1a)R+DQWbp0%R)__Z6&yB0|6N#0|?b8Zsma8l=m$|iFh{tWm49quCOlYm}B4P4>F z0|GhjYCr(Jroz>2pRW5QpR3aAnC?M-6t4db$Kb0tSp{x5gKHv)9FL6r;X(4CnTx1W^ zBIdE=our5|^`NQu2pxFVb-Q8^FexH#ylB!EFZ+~ET{q)TYFD@CYNtS}V|?QzrOi=V zTVWK6{r@yR!)+d(hPFc3XT^_}Sb>Wm%1qh>dv{uE;9&Ve4BgQLZRXc&IDT0?~%UzlheF5R^ zPisrAk-fatrD0Z~Onm*K3k(#E+NN*gVs$+2wmj`rvw2szP+p)8`MI8g+T^eu3@GFc zJ*cL6pU#^LjBhT^r!k%u!=#|YDpG}+l)uFyS=Lq%koX3lqv`H(&^y`O+$`z6|%b}Bv-d4sBa1&6_B`fcS%Jad`Yz>SirI_>uN)G0E>$FbMn2YkbrK=6)1dnsA>3e9ZYz zkj(6DTH|YJ@?9NsqO30F?SX&qCciC#-jE^I%0k>cXfmkF93 z)QgXJn&0lDq9V)jC%;pb$qiNNfCsx!bjhAyy>2dIWvR+%OR()WK4k7#51FA17B2RB zsZdjLW0rnSvrCjVCW*3qrqcg-UNq;fZxDWnhcCZOzUlh%knIi3Fdncw_Qt|1CY^Dy z<=0k}a^6_+>|T8J1;AY|{|o)ioFx~0n%10~++@LD03zRXxnIyDAFLPsviRyyb59>O zv9^`tW(z>KtVd{mJY4eu`xg6LWlzT_K^gaY(JfC%HmyE3Sbgo`Pp&ZUTm3s){Fm%} z1FO%!Ex!DwCq^`^*88g@)oan8aLd&J`K?HKQ)T`BY&yjtlI6I=+_X%hnrX}xOH-x1 za*;1&2D|1e=pPtGnN2Ci%D6*JvOG`dtv`cBXMb*T=E0bPzShLaagrY0)aq)7(s7g~ zli3KL8%pj4H(uD1DQhXhHZljk{>~>nwDLI!VAK%f@Mt;UHqYGdmVZl;gf#rZJ6|JP zyY;C>W$%APqT41h*w%1$m&@WHfxG=|3QY#x;QfelBq_fX%63Ek8k8q3l#rtkV+66r zI$i(KPh7(;5acv2vE^M*Zu1PScABDvDi=~*W^&sgJM?iL1BLE(hHR9(e6g+Tv!`rPVTttNo73FHV6n`}P06C02W zNH>Rdot__Uu@S ztYMgHn$3pi%HP0@OF&LcUBcUvbuTgE;U(4Up4yEm5+bjjd3r;?xjMx1xMSC!$_CfP z9YE<|&7fryrn{vT%#H)6f`e*iojhDUV>sENVMZ?(&5 zBzc-Jb8fPwNf%Yg40zw24a#U+G~0dk)Ofuq6>(#41%wCf!pzn5galQeWHlDti~2E$ z@c~idAh`F3ulURLz0jhH`Bg?BO1E1WIGs&D=f7()N@ZC3`+N0j18Z!>E6CK$^qL z!>!HU1EF|+l@`$#cX`!myr3STWQ8RhwKh?e*S4Zz9HZ?x=oe^9{xKU4p_t-#-q}jjXq|?c1bU zZ9L;3M)3)!IMJDeGFr>_7$Al!7qUferi}uYNcsnP9YIYC7Y;qxK39Us0T-dT`sCHS zcft17&Vz%XJQbM4r}{Za#2t3kr59j6R4FTA&k`&2T+MDC1EKCIOP|=qMadl~O0Q^U zzS>oWiFM*B=soC1(*b4FxUpa8B8;+bCrtJ+OTzv$7##e!7G(s+E{bcmwznJECQ&4< zW0w2%+)`o_eZnlyE$iPu`v4sCU=KLPnvXploJa%fyqS%P1oaCH_=?s|RJSXMwBwA5 zQyu8M;B!RVflHXYlLA*2qug^(iRDoYgD_OR1k0{bdbF{t62pqpOOldGdSh@dWaCEU z%6fD(Nn0vy0~P25(T~|_}fzmwz+< z<0-TsEY5q#9&PNm;5E3?Z?V&`(rx);*z{dS&o{l6VEann zjsNctHIA>%{pLAS-r8oP4c2z{)9Lj(_P=1T|Uu*GQ zq?jFTJys=eGFV`?!*MU$2+BW-Y-QrqkIHCaFcPrMD{% zJonOt`C+m9XZ^*~b{i2SEx!?b^UJyVdz&Ah zCU4B?XHJQ02y$y|#H7i)*(p927qR8EQ<`4e^Pc!3v)-ZcJz3v!FiCJ3CO}A>Nzgii zYH|quuk2Q`h+cmw^~ulpHqI|=9p75eo4GubmECseJ9IRIJDs{7z?VNq)09#ykeNSwrq`oN7=$EJw7)Wb{JP?7G3TGnGJ4jf+pNJQgRg zr&s2ZqmA|IXg%aoH%=KR!2EglIk$)P#GVaez9rA_d6l2^$J!qN#>!1Hb$cPSX|5>I z%_f+nXqTFfv_?GQZOhBFSLJMEVa0tNV(2&Qv;{o;;^q6z&COoLo8&Cr@&h8#??R)G znm__pZT9;_Z%Iznu9?!J8RkpJT%Q8Lbl;NhFH~}W=4~&S)0hirCFseJo25p`^}7w2 zB2Fk~j&{ZRdYY|U(AhLgpUOCS$W9{ZV4X_toQ5@3Ji4RgY&0g4m zP2!K-t$=m{J1m=?=-N;Bt?lKRc*iOg;S<^_kBHAtN%`BYuNTv(ANyv`U(B04c}Xd# zl0{ihoIor#_m0`VBy4n6rMy7@1cJor;1`oZ)=^t8hw6!PKFuy&qEx0YQ|QR7&7`sK zqLU_nC=3^(4EkI|fCP!*0DzX7cqjk7Y9@5F#B9jtwssDB3Ygd*E0_1?pz zJYtSIf#b)FXg#$uAs;PvdEhKugE*du#W|pyFG+Ewv$msd+Y`Ti_;o8>!Fo*j+aTB)R-)3;uet*0(rVEGs zwK*=`eBX1r^?TIF6QyBi-iBLFGtFv|fiD(Fy^YmG=n*5r)GwB=Tbs6(D&jG zHm}zd^YFQMK%gMkYM>(!S-}d{vG*AEZT11x_d1w0>ig3)6r~r zUc6MAi@Hzp$jO;hgi8l}XT#24lAP?^senic8WXN*=_&g~QK4q1wXK>R1YFEVl4ZTb zqA_|G8;@vj0Gn^j?~XoDQidmj{bXGdTb=dp*60lX z+pe7e{k9FiZ7)uB)#F>xf7@CEmP+um++0+D>V8Xex|>yk|LrU@P5NyIe%q-o-h#7L z0KU~)?yR()H4|NOWtW`m-K{bF@4;%*r{5mHZx3!^#TBS;x%Llkxc)T+SeX-+q`}?t z1pIIJrevYtcHy_(TjdZ1^jq`F?yd1l4PkD9bC#sdiacbJIXtH%s5}869H+PV?ub9G z+FmQ4SXmxUP9_S>$q8V>Fzj3p^G0XSkkv*%)`NFBvFoQM6evGNY4nD1A2(zA1eT$Z zke*7BY!|GvS#jvgsmgZ%_p&BQa1+SVe!NA0~pD52~V^w5BqbUB1=5>Jfxou>Dot&8R zrDtTO(H6#pD)K;M+^R?i7cd1-Xy6?eBbq0hkX15B4+sml(^)|TafFHtV@W2TEbHim z8hIhcd{r~u=}oI;M3t+4QsOSG1G%$h?Xq%?t{^y#rrNGm z0--*Z;+_m~iPT^038`y&`bAC}B^NQr@|ML;mUT}{!L&My>_PB6N+}yo91YBlZAC47 zoz`B0R#!DpTTX=tg}E(tqH47@)rS-Pq3@-fD4dwA+?%S2?rgQZ6Fp7R0nbxI#gAN% zPHEI$Y8<~EcitoLWWK^f7M>dQ2u(STV$}fOv3QjgS}LY6S8rXbv&+sI+&AV^8gzj% z=!P?QcC`l5s`9@0TpNw7^HG|ENfQO?EzS#3VgU>1ZO~u~D7shZAdNmoF7pC0y zBGjulEZ&5Ub4;C!Phkbjm!of!fq5xP-_&xr>H;ij7`WkjunG7E(^_?Pnrz8SuhZ>W z`M%Mr%`q!3Pk`H=cipny&O8@cWnxO5$;$ldbTgHcbU(}9vwU$N`*ub-?$AdJbjI5+ z7L;P)!%;l83tXY0;P~giJUjaNhu~$}&jxrofm?Grh^7OR&ODZ{x_FW3Uc#&{hm_HL zEeMZ5PkRxgU)?lB-^>M!FavHb+PDRvUA7d=_M@q4_c2L}eW~NKhlTbwd-$Jy^`Bnv zliOYCs4`ra|7{aYQCt6l9zu$YES<@=9?dJ_|1&PJiFWUyr80lAhr^iw&k{fmy5 z3yOnK;Hnk1JY%z;hjL3Zj;2HoDus+UnB1z#76Df3W)re=unm-5sOO+~78TK`-4IKxz48z79*nOAeao(Y#M+6?u`dY`yy+g;OYzEwNr1$ z`Pvj=bE}}?4-v%Fc&lbDv41pji*&fwf34NhnK_K@tRW@q4@(ACo{tz+cphC&Qq9qe zDyks8vf*;M1&rb1mB?cdL{u4^(jZ)bsp3R~BmbgU1 zGgbaf5~_8mdQ$XL5?^wl2tpiKWxc2>1~6nHHHZr(P9)Q~pUs5~4xbPLPxYIPg$0fd z{AGQjo^TdsZ)TMx+0~U_HP110F2%3YB4b^pS<;dL=3|;rXaW5P4o5yxY5w(6;lRlb zQv)6|cNcLQd^~!!zE3PqprxF&7q)b9!8>#P%5`3_Bm$q>8)#bs9_6V|H-uNe<&iE! z^O24v7S*7NCu!bpQq+p*j>cpxKoea=$%wL7OD^^y)n}0q;7YK=0{VgsbR&I1BdhfVSfR`4 z%7jC;X2se1ek;5!MZ#Lm(kUVtciqDzG|F075?(e`CC6wV`DErX4f2=@K#eEGm5kQ< zL{vgCPC+~b#y?eI3nlw>WQ0L*nK|dvzMe4*EE$7yAcKMDl0p?Iw*i-=d7a22hx4ku zsXN%LEw$XXvRlIhvHVqa6M5R=#H+e_Z_@|&E6uW_=W|`zxhUYGjlZu7u~9Sz;wr?^RYpcH62eAw%EZN@##)CFG;#m3Ud6 zM`a}(FxQq!1;QYYpG}8(S&@1_%`TDwxxSny!}E16O9z?{Erk=?tDlk)7+sjeX-2`4 ziUwA8c`o51FSDwDUcG+7eRGC^81{j2-$cU@_7Y0Qy(d{NrDdwFFCcc$k|B8y$kg<} zh?8JXV7Ms^ottr}jHI5DD!V~pL)s-so;j1a;usPH>p=(u=Ak8ZVRtW?}#4>Y}LLKjm5sXkqE)MBc*``)U>JyA- z_--4kGz+2Jw8Ef`D=IkI5aEY=4yckM$C@*~YjoF?lw}S8-DRy?!cOJ#2r)WIGCiO# z%tZWc$jmAHHqe87LhT z8ftP7NK~`go;FH21(e$}ybMb+4C-Y`k*W4hks2hl)MNA$vjbp>V9Z~7zjMr&V*4_Q zXnou*6(J|TH&Vx%Cb5D@O4$IpC7=w(4$Xawf~G%3M%yftslawGYDM-rP922kgW#*| zl52?$w?!#8>2gU+F6DJL8`=2bg7fjFcJt{h85QeEs_X4`SSQ13lqgTFqLk-x|8pKl zg-IJKSDRs3r{D^@0C=FQ%ixV}F1gBF_-A#d9GQu#b#YEGztrZvgnMAjWob|n2^iT} zEC$uNluSjM+lT_$lpTlxx{GBUTw(COnMusr1}|c`HlaTg;p5~bXtPcC%rwS;NnKs2 zT-~+C2Sw=zR)UB3>a*vxYo4@u_Z$RApzhO`16K8+(-TqtjO|MIen+HZ7?z@h8}dMB zDGdH$Ds31gh=kJ9>J429*r$~WcFjoS6)cYNpyMyqFrN=^UWD=HC>;`Tfq!7)zB ztk}U0Zi3XtK8VH%?`^dW%-PSZh=)8Ue%5(~IIuka0w<0b1nF32rQ#s))G{6?{b`nG zXT^pAr-~Z)wjOTp@=#n&JVNn8E|7Q;HC4d}3DsK0=8xI?VXY;?)e$e2v*T5PNIJdbVx! zZ12$IR3%NdwwMh=<E^e5!V`lGNDysLg?pB0FCX{q(-N5?HDPV19-V|sVoLM&RJG+cc$ zK2=uN179n3XhJh3ZYZ+D-#5Eh|uP}Y}xa5eWzm_DCLopIY(F-*`p^N8w=0z zX@tr0L*I(*`>J+^u{X3HmG*pKEUhLFV;x}-z^VfmhKue2-b_iR4zJ>u-gPhrG6EG`ePG(W;!5+S0os&PxZD_lUAY^gnL@#POdicYo|ujueNi zKB@YTm9}>MS~YGkb1{8=RZx9~4Mbe?7xGOQ)i77`J)6K~Lg)Mi}i zf~D>o~h6Wc_^O=lFEP6v^B8pqwN&ejo>g6UIE>u)yQnro!+z zJUj<74DNXJ${=fHSAHk!GPxFVqIp`9ZjxJlDF7cIxSa--A&if+->cFEpI+Hr(Pzs6 zwZ@ql)q+;aw=}@QGiUoLBLNG@HO`Up+}Hu z%zloP%?D#*2txxmh|?iHNK@UJ*xXPtDh9nriljdSt-E8@?UMPahjHzfWztyZ*=*Vu z$NxmTxJ8&zKFue|h#g!CxRH=g3&s&Iu?uj{I^%d*U%74)*9~yW1ql4mZl?A*1KzY? ztEIMt-zP(m1G_t=7`w%3>Hwha=YB#PaG?X$3kd@X98kA*p1Q+nYl%J?r{mHBtFSj9Y@;NM){c{ z_XbSpz$ukQUI`bMSORJ_bQD99WNkla0^{e!N|`E$8J)43xbaY#UEi`9{2wCh@fU5O zJzS>xvfoVcO>Rw#opu}*8J$Y}q^-YiZJK~(XZ4(0gZ?8rU09Ym0A7uujYNN2n-pmcw^&h-Muf9frxD_?%RsTyRd}9lHDXT&F%ELk|z6uY`jECS}1o zcZOT&u6ad3j{&(~;#;{jml%)#-8h@Z@h`xEY9?H4O6pL-e2WYz?cvM5`u+FHIQ!k- z^An!kNi<2i=TE9F@?tPbPOYy}XnDfRJGG*#1J1CW^z8<3uHM2QZTcimFW};S(c$k^ z*0B=|AE6i$$8ZnyXI6L|wDI>fxU!E%S-;)e+}g3T%@Qyic$Nq9&tn;Z7WX6;mTc45 zZDOW11lTyd*O7Hu z^YpBqGM)odcAk}7cc$t-n{J1C zeNOkV6k%H<^g^go2X*4J*_7mm9SH^hANrO)>~MrRr3dly=~}gjaI^5&Gr2|cjCG8X zhO)iIMua<%YBu~;j#az=+((sqeyD(PK3G_}^Mkn?Ly|LA)9G(Fyg4r@gVJ5`g1}#y z7i<&L4S2x@VVVwmm znY!(bju-tfd>3bn2ENL{VxFv5KUG{9)kpBTx`hki4iyVCP@~t9o4RfFHSg`-<)RDp z6<1w)-)z}!Al9GDEW8ckZdYE7G-v6h*-h8}4lfo4`ig6R^Gihui1p_(YyXX|6V^y` z*8VoG5^ti(T`W3)U1hbQ8<7|Py;aQ|0DgD$L=*G~BN470dKw@64-y58eW>~X{O3vV zG-#{rMA`!%KBSnX;K1K$4Zgq+bilLxQmr+(fMZ@E8i~>3&=C7iwU(?rjiZS?b;))1jDq7g z93Ami7j<9`Ff3K{w;y&T<4Tfk#Qkx!wY#K3GRO&U)2sI+~ zE!lRdD~VG6ZDGbPch@Q1R|oMSN{0);SbAOTahgs_YO%tr8$Z7<;?cn`^-K8^aTnpG z&4o1?r<*nOW}}@kAq8eA!K%^+mU7TD3dI>*i>Cu*dyVE$&Mi+5=XX{p3 zR}IrdT2-uPWu1X(`{hoQdIG$ZR!~IKVT>8Fzh0Lfr6veVGzNm(=C&P9AX2kTy4k{e zhda?|x4f2Le5(4&k3Q3Qh!!#oX`EtC#4KGT`pTK=hj{q%%cQ*#o%S~t72DE>BsTxr zg6^$b<$D3##P;0eMiS*PF770@33zRVI}LQ>$4&V6R*4A!m%h_rpJlEysy*Ih@b|mD z!2Ie9Cu#p0u3+@iYr-8nTl4p9~K&q91G>2mB*0eIJ3;tV*KS?ty~=9xS6wXndi$|pDXwkSif|6YnK zzLCR)J=8o-xDA&JgmZ^J7Z&(cdEn+=7iB2+-%IhpH*&nNhnmL&x8Zv6a~yrXqbGX- zy~^54S0c9h{Z_Bh3TP9FrOkKhR<`;ZNQvHeWMLH0tI}JUh}G}6PHzM{kKSnB~{y}~ICKY;J=3L*Pv29j+GsN56|O=dID|NayF*fh0& zw|_{&NQv}|{ZMT_++=y2V|mn^W2tdxstso;e$%-}ANKqIfJzCK#xkUl(5%>D|G} zsheZPsj>KanG$M$iKEFOI$gcS@MNoi8h&=-PoB-+<;gE`HR(2ghv6ZO4RoFRnpTtZ zs~js)oz#uR;UsW^-@hLmCc_lV?&V55SzrGpnw(%P3-?!*1hIHjXudq9X?@!QP2KWos66vi+C7Mspco8Os7JjT0$1Uwu5*I zB$F^T+%Z4xtM5DJImIeNeFn78Ir#+8Fs5Yh&)XT~_+TAnensU^0{t#4_H311|460m7pwlj@&1gy{bYA_)AS_UFC}Wgz%R*{}_g z)Qt5L&-f@Bwj~yR`{B;s*7nZs=AP;dA0FxZj`piKy$Wg}1ysYZLSGA@qV&=v#z*8r z1q2dG7F2o>$Nc_yP)&fzVy+5DaJj~GHXM$uveht!JT7os<*xuy^~AWoP6bC~U*#wH zRa!(}N|_E8BxrAcdv9xZYqQsIx!SM4Tlqn|Tfx5xSZ*U;4EhaZW1nDjczGO`TQy`;&ElK z)=Kiw+Iq0f`P;v#uaT$-UwILq+2yB;Y_dK=)h|%Mg8poZRgPh%QJ>zDgV!m(Mdy-& z8New}=%Iy`!*M&o0b9gcmP7%cUqFKBbHhw32Tf@%>ie46Si()?Pm6GgMIlvZS{sb# zy#mTBUeU$Og~eQeTs1V!()C~BX=dgJ6PsiOo)yukaf-HJwQ|E$w41%{t=)%vyPeu5 zj()S#d$_Z`xl?If(s1g4mUWz7@4?pY1G`;W%h}%91F5ucwW#Phy$9P52#}3dMUCn0 zZtvR-{K`(Rx3#zP&_<}L?rd7$HYhheZ!?c#qeN&m&TWToZjnrTH%(3 zR$H5}5%;!yE%ap+nmvRq-Sf6`We7Cg-`wBYaa($BrDkZ;^18Fw#In&~{=~L7A8tO_ z-JCbEt(}M4dk+_z+2$g%l5v-xl~I41rq$cp-R#Yu*6z;EmLtgPXZ5fQ%|9<0c=>sa z@qCy&t<8r!3ruSZQP{t|#gbu{pVSBgJWhB^&!64gd3hUDrqtVcxcP8@vqAy?-0WGY zUq3Y*X}j}}G*?`!b4{DUQ~@pPcoU=S% z)(W@M_jF(S;duZz1k^rYvGQVo+6tnDXC{n1E6iI}gNc_L)Lx~r{BwLV>|1T2;SpRe zV7PXBEqMGS_*&l`$Z7y!1<&2hc-w$lPNVY-L42nyyqGOMO9mC@mz+0rOUTn`0-RZ> zvNdw6(kdRZipnS$X;ZXMb)USlcMDbq=R`+`@7@BcQ@DwM02mlER#eTG#BCWU zrz8v#&S{zs7_75>Fnv+3iry$d&(DDzaquF(IKr>_X3c;>qaH_O)Jj2(qrz2k>nc4z zSlgPDGZB<&3^>J{he=@h^fPM{K!16S@abmH(Q}%Od925(wGf`n)y+*b@5=-jf(8dd zss-a!(t-#-qN^^oQvlKU#%|golUR5lX*sJ@l7B{k@7}!$J|}SDoN98aa+69g1SyEG zC*`>aPw{N*anWBq?ZcX+*(_Ja1E3Dy5KiG<^_kUl+Pff;GJRiQnKGD3k3l>EHlS-l zYNn2~XuQ>G`QXx6)i8oR!g2`0^FrbhQb!@aSfAd6RyhY3(OqD`mQG8x6fd-&_(+gkRs zf^(y7ZJBL(TX$+NSqpFCXC=PEEN<4QKsZ>R5v`882?jr-9hV*-gYYt&ex^en1!f+0 zD#Acgq}kTzaYXx;MC>JOSA7A@bYg0%wP5FUHMe&jQB2bpC{u8<(Z8hAuOXdSo_yu4 zV{gphdX5aTt^q&OidxDyCO}EjBjOO-m=)oceVh;|-+(F^~@33?yH>HHM`Fb+6S4+PVuVRQ9#Peyvcu2WdT+jVA}e zAHJ%d*P)xG8qR^Y*(F)EBi%uw@|-QztsTwYclMB##cQv*qhEVwjxSO1Xk=|kloz}a zEDXC9T1~RNc*B&!QgYnPVvlPo+iVlftb3Kv@@tjOxZ3h%@c8lLz#7VJNK;Wqg^#w3 zccqI_E!p5C>!yS)Bi(hoSu?T8;8_57@vnVr(QHXAox(6ODy0g^Bf%ISaLxm&k?lQ% z=^cR1w>-K)0r&ch#I&3d=%WxZAOfr3x8z+Y2wOO<^*?;Qf}intFt~=_&(Fu>JjdTA z34Opkc>;fQadb6!E2QHAMpx6&he=0p4he*AM`OQ#{X)rab&C_Z+JW|FEYmC84Eb>~ z^sEHEy5Wtva)c@9vZaJwl7VC5bq+}5Z77^`WOI&L22FlUZpxJRt3y?M6||?;H7aio zm0b0GvgYxn&bwf%x8=TZG`S-5c6-~qcH>50gx*eXbMN8KLK|bNyFbSuKov+JiUD`6uj!xw{Tfr7Y(j@XTJjVAInJT$l$H%o)erEU4JV1TVS?WZEZ$ z!6G>0N-~W{_|gmV^tl8Z7nZ5b(jVbU5TCKxN$g?{NilsGkR3h;^-mt`qg={d_^Bd8 ztKg1+(*{MC3(W*eWsrwOivAd!bFM!F z-W~^`MZ*)85uldnxc7#A#W67|DIQO08N_#Yyoh%|vlu1f278_i&q?0EQKV*y3B~ho zGrirN_IYBKYm_ZJ&woEuJ{WERr#r;^MK(Jf#j7j}E(#vVxp6@@Sp47r{eNKN z?1&~(t>kJ36T6JA=z5TiC$oZe98gn+plyhzRy`E%hCm;p%kOcP?Nix!mC$g9TouR0 zXF)zYY3YsB8BGM}lE1>zNEr2b}O2j*uo#<^@N z+5o~8GA2_xF{Y!dibTz|s~(rjqG~wgwNPZ0AecHO=0$uK!O>*tGAfspt=?3KHXm&6 z(~js)KArV3i4dxWzQt-d$D;v16~Sgm24V(er3!0X$=i}>yS4_k=5XPg=&D0kL8-ur zb%eOS0=l*mY}EWgkj*CO@lIC2se(!6%DCbh9J(DFaAXpGDvhT`dBdB7(cR`LFcvYr z3Y@;fh&p0Fkt9Vu2CPY~kskF=sx8#%3Uf7upsmxC5uh*`giI($(!l+olI7?1fUbz# zug~s#HvXPORr%U~Q_Y0;91_BkLe_53ca-2q^41K-Amhl_Q}kwZ)h;p{4J~9vD-1|%pdW(`dknL%M60r1`jj(q`2`-B zM7cbZ+v3sHuS(aiJE5Q+jM23eUi(rzPlvO$kFa#i2suR1;0)p9q9kk;Rj67%aE=z` zXgx}ga#f)U>K}7D)IFn<*NFPlL_nwXi05e6#(?+o!-tdaKfZeP^25o|yLTr)KKt;) zOWT%;DhV4#i|G}UL+hVtEbndvW0|c>C_f%afn>PoBT~>E(xK$UV?!Ko6dXDSDK-Ze-$=2AXsB89l*((#ga) zFyQNIj<1qRH6JBsF+I78C{iz^!OIA1hN;I`_THx$ooq(+i|vQyQ!1H@FK1}Hq{lry z8!m6AnO<#i+4uwCV!VG`nHLWY)HnU|7Ne(f3vYU~_r{Ib)?RQ;iE-3!WWY|4XM9qjQ)84WgQt&86hK(xY$~@!-1cLXYp8Mx z@7kV}3HD9@t{-4fWXK}eB)L|>zcjJSNc{R_GVTn`R=Me-xO7&FQj|CRsYraw#Pe;Awm4-`1b(ZC5k-Ov?@J%ah3iZTJj z1jwJCl4&uEM!zM?NdFvNt5rl)SMoO8zh52!qvSGt0n9;If$+b&FAc{rx_Kq}xEs76 z7w13%Cs9S2;bT!Tg+&7)MY4;!VNc5hMEHp~;~9vn8TL=c<9Lun1>Vf@q3OPE(&0zw zj&6#MU{f`PXXHGdrGyTdK-g;l8?vCoDxR1^caWS>LM0N;&zTZhKZsJwU!hJe>V>aa zcDEs=VN%K_DU$T&j(rsU6?DO3XxSZ1&}R`1 zv+0$362H<`9|4LXsQB=IU!i#sfueSbo`cU)<)cTGDSeM83>_{KqbdXQ3c%Q6ujN3> z@~FC0gf|Vy*m1)ea~cry{TKMU=YFK%J`TPHUk-w;;F>arfFxw+9$B`wwBx|)=bDxr z5$E8f;0~~Ked|l`r^mt0<|CYafMq~>dyiT)1i%TuglrPO3Tf6ALb;RgO1IZ(f}x_A z^!y9)j7bW%r6Y_kmcQS=Ps|)j{7k?gk z?hMM@#OIabC&h(+9uxfOF(rShUr799Dmd0<4lzxpho{PvP)l{Bzyz)kkqGCr=pv&8 z0HIJzVS$4BF3&>F7_-*VvhCzfth= z3;M|cr9kN!pv${WK;RDl$j`(GV}`j zPH;LCgN|erA*Wn)#MB{)QE>|k=jU9`FzH{VQ;-Co-=&9G<-S;wbpb~b+F20NEM6kV z0E)19dBLBOTYP?}JGVS4^TQigr;A0WGB@ zE`ruG^=@c|eMOdW&r-&jP3TECXe*DH%V{*3sDnjCZ{>ZsiLJ@|aU@G#I<9K85*q2H z9tdW`4^GFQ7T|9CA~cte|1uj#>H1VfzmdW#)@)!F*qahPWL;`ZXRTeeetM(nowV@O zh9fCa*)a0HMDKv~kEa;mO}V$e=y13CAq-KL*OH&>$Fkf6nR%wf`PcZ|4koiHrO@n_ zxi*`kT(mfnpWP4+U#)}iD8L! zenSwQt01X0v+1bIc!cJjPp_3Qv|E;u;k-dNEx574+Fo@;NoE4dJhE}Z_FhnTSbxe# zQGVXx{4Nn*^`JZFJc^3*n$>T4SBx>8vt}qGRRmcEjSVFD`G>`~=EqrP^J5=EB*MrX zf}R$vG+m%+W@_b2GY(v^lht9+QPDQp)O-{d{WbrPbfVFTi=2*U5S_+de``%KlR~@H zWW)0*lW(pvxgvp(g~yXZIY6Rxih`fx(`R`ek59=BhA!gvOzrQxa+==$yf34Cyx63# zOI-8cLSLaos&C>bpH1U86b<@Dj8yq-JO+`0JzJQ}3eUw#vRbF-++)D(Wd+X++E-yi$2XXAl6Kc1j;@?gFH`g^@8Lw3ZLoJJ~ zl$`81p@M_)wyl&EW{+GsS*BLBm|Wu6tf7LME&IEyi@ddMcDK7KFQgN=!~ExWOGVkL zq;E&L48UqQ_wfcN)mf_SGcp}kXnCH-AZ(Mu3e^&0=n!sSsWE4R4kWqx9p6q0MW)D- zuCf~NXq2fFZH{yuMin_s2IIEhWxX@IQGxVJKHXthqjz4IyyL$mt zjPCZA0ZbY89Bj!}KPp-s_d9ySJ_xq#Pp_ND5n;*!&YG#(Edqsx`Q9T|P#*{PJ|{(S zb?;F<>h(_ob}Ll<+9Nm#5=>A12>$sl=)u2#`ctx2o~;U<>ogS>O@u zxa{VISfB3|8IRg1=cO!343Ydozc`|B+d*=X3}%3sJ_+vl2&fayJcXYkOiOVO=5TMp zvm}T1$6v2I0srsQqw=hYN+1}}ldi3$rIkp5o4Qi@ZG71*m>ZERiRQdkHXnZt^t?e1 z!?atNZfx;SKh=xuMP-~4Z>i;OU>pTqnMa8cLaljI9voapy*0U$$`kVqWnFc_cwSF$ zOVq8R!`h-sxiMG?vxQ;A$QSbJYE5iuNyP@E6UuR1Zf08(%LCo2rmKM~K}T}VhO0!L zTxF_)?%=Kj5Tn+$CC%ndg%#?OE!>;x{T;UE_=@sqp}#@Bobc<5n+s@+_>QLailx;> zje0F+=%N9LtRz|Pc9YvPztLu9%XUtddHu3tU9IgjXSk>J{oLG%Te(v|gVE`lWFtEG z)pZP){EHH{g=Lk}E9dY>S8wv)POt1F`{k?M0vn@-d7YIsX{-l>b_5cn!g;cyQShhW zbYW&=k1K@P>jYaalZNxob)@RgKzg`X{0Bg(^)9Fbv(R2?7$XL2v%A}^aTBQk z^k$~Gsjr3M%=hBjGSB>JdVHX`-(`9FYB(d77XVo0@q5`;Fe zoERn?iwl8*X)+Pfc}}(JC90T%)THpIj-gM@GbcN4qJeP`O$WiTGrn=Ai}MFvai~kO zjo*Jk|NAvGJ$Hk5vqD9#DU&1GtVOwjvzCqcor=q%LSL@?lsO8pB4<$T@vj6`Sl*aH=nB-+lYSl z5Ce%XQFYUfPtZ3n83T_29#)O3zR7yYi90P?aX5VWEEhj*t!WB#cPV01g^`nESPX3h zxaR5jG&sdnO=#(-ylCFk<2oy#BokH0xFx~NMo9UZnns8!s`wtO_h0pPF4&UGYy=|UBFPh0;HTMacy8`3^oTK` zfHABO+4#huRYIFT+?z+G{FK8C;^X1J$N4-I)^y9-OmJ>hWwBPNGelSyAL7VotHjyt z_9v%^gX*=15WQY^&p%6}m&gn?+U4XIl|Zv``H<55s4i#9ZILW)N#VbU`VKMsSw*qp zQV%N%sC)Ia?P)v--!qO-{sg@PPmI@`IT$$u*r+0Hj4P&hU0l9j?92t)0fSiLU5UcCrCy5-kT9*^UkzFx0Jdtvn-CxIgsT-RMk_ z2oG&jxm01cyuVeoMmxHxl6vzNuHt3URf!!jPs2BOYJkgw&g5Ai)IF})XF>d(E%6M2 zN{;3vZ3e(Aaz!yZQ_4_91Jaw@@)1`+eKNQFPO*?+RRHTue`Ue?PaxhJpTD(aQIX9_56>%+cj^# z-%uFd`Fq3N%Rc9^!6W{beR`ND`n1?{%vs@*`kt-8SKb0vcA>EnHdNjssQuC}5#LCH z0q=mG$%Qjm2|LY-^IBT#_f%GxE%rYS(IXVv7z4`yi=d(zr#sGmfq|lKHXUxn>H5dR z4J=K#@pF8-VL)trh)FB##~VKoMNXK5@(qM+6&tjojdPS6#C05F}7T5TqzbRI3SJw@KybB-RfwB=nM77bu09WItvQS z%<1e-#yb}zu$~RAqk}$vQa=IHnJ_hfEHDt(j zT9ow;vpb?3nS$WdXW!kkeeF}GSK#EC9YZc{maqOdrXpa zVQf87@Y9=8XRAbw6lx7?Uq8r6%eH=7-(Gi&*9lh5Rwtr;j+jb9t~#g8P9$atg2|gk z#Qy1xK7{DNru9V2H>TZ^YCD4(9X92vvr6zqT>CC2i=0r$T>e8`5}jY7sGwuZZ-o&> zA`0#LWO37S5}{#09vW*H+YXXY+|H(ocQw?^gM=YPQn^0F>V zF5X(HYqzCSxrPWgN33nYJo#!p6#QHa1BXO^h8ySfyn&8;xu;5r`lhQB^tZP*H}ToL zMI4wG>zLH51)>gDWn(e|jlX3V0db(j>7d>EOAIGER<9Wi{`R-DWjDQE>yDBfz_#~$ zTRWav*iyX3^U%3XA|?jx?B3QM<`wAn4iLfb-`|=9<9N$;b;-A|_1GY^_${1BkM_K6= zNhz)?GZfa#tKvR8j%YUR$b7Ws`a|Ni0D}vO6!gZYpCZnjG+&nKgcd2U<|%|Tu2)U_ zrx)`y8(gV1v2|Bj(elNRM=_z3`1Z(=O6u~jo=kOaPZMXY;MYASxDmRg1?7>Sa&bM3 zvZJhm-|^Q^oR=l^YVO0HY&nQd zq#vpCz4XAMiPe$7T~~TFPe5?A;R%kIx?++r7ZHkF)(SzC5kuZ_(`B!CWrS;shqvv- zPClLtD#ZUvL0|_~6x#KgIij)f8lGE{$%wAIQC@{&b?Ks60QC{1YE=m#h=v}za_vE> zQMpq&Ud;L;@P&xzV_qIH| za9sr?%)2l`JKOsYAMP%OkhBHn+}+>Z-dzkKid2K{o)Ns;#e-yT`@!C}7e^14(m2@J zeXzaf!?C)9f=a8E_LR5E+P13)#a||%BO@c~`*BGharc(dFML6^pk2tZ{9PrQ^+|oc z({WwC)3Gn#DWy@njPm3TGk`Yc|Li^3?QNIyf9`DV?EEYL=S_c>%>ViGv%}Zu(4#IQ zlyigZEn{8qPV~rQJFfrm3a*di;I)dqHnuV5tN3DLO)E}ZPoBrZTSl(3xPba#1En-4 z+&V8?|L)s`H>4ae#s@MUm|Lj;S3s!0oO0#;yTjN2u}(HU?JHTyB?(i-{qmI(p}#^U z?OL|ZS-vshotSeDN8Oa>p_<`zOW#M+;RT$R>4k12S)W>NI!f%S3i1NT_SfI?v*UD_ zA21O903gY4lW7c7Pjfm8Sd_IkgqCPX*~qhTya7`gZD7KU4LnqFLB<>XDBWO+wz%i@ zZvzQwx-Xd~51}v5?KDXvtZJc@!2@Zb3`aau%bx^iaxz0r^Av5G!~*!A*Gv*lv)R;F zRRujEhoAVeR|CW$9;&O+Wdurtol!z=e{CTqeXka`jkNyw;m3BXyDYIXO=6l5#j~~*I39wNVA75>Z#`@W(v_LC zpCNIJwP#cg8q{lbwc0@_vn#>_!|~V@e{J*Gp*ZN#qd-W^_Y+$3L2x$U@?*>r##}&g zxMb8d3G~@?kYsTCt|vpxU7h@QIOlRQ}6j%?_O|E;d3u&BgVlWG=goZ zXtcd$|8Fg5s~ar*LF}UkleY28XwyM56 zmFkj|moVFXp05SrZ6+(EGxT5*BfP&$?bX~`aIr41Gi`>_IF6(P%cJOJDf8jJy~du zw7=2_$+&AcC<=v>f!;$faF3SS-JhQBo7A0loM2lb6@0_iyN=-|sVfVdDLjggaW z^Tr(cfj0qfMKj!SPeqfopOdMfPD72=fX$e+2hOTwD2ZJwvK}h zY_w)u(nC50C|41kcA+^BnJ|g)v3R(#Ag^h z|M4}dFEe#HPvdx?0F;OW@E=zH?ew?8Jpe!gXmM#+G zT)4fC$HRxPfkcz!_QB!$Pak{t5=}lFfIyRX`JmV#G4fI zVZ$YtnLG$BReUYvGFbX~5yA7b7F;pURZTAkWe=+U+=i4W&r4$-@Ll>6Mq42ZDrx%G zp{`uVbr@ihPG*IA4yfVwWpbT^wm{h!mq@|95T2ldtcqx_4$-BPMK6S@Wc*$M(XBc} z0p#4g@nvs#+)XNJoVM8%%911I5KL9TdSh#<8^JUPawGB7%EYKLF67`nc6lf#a7 zA(HcL-90rsHgprB+OeHD8w5I%<}4Y`rcNAW^$~o#yRB+f^>)1_5NRF!DfNu$*HSg= zQ|LW2$u&=7Odo3!dE;rL$U`-VBlqn8|Ji%D?KX~NLA0O!6*b;71JDhD7g3T;ThgW| z%I4k@$swthyVY8(B2Xl&1){J~fGD=Dv*sVp)A_ymk`uSgjLfRSji4;|nBB`FtFj_9 zBO@at<9c@E3daD>;#14)_%6my)((R878K(Z^h%f z=5zAkO>i2WbYSz5mlBTaPh&d;`>pWlV2qL#P0mle^v@MVHr z*u7a)AX;3?%qK>1KOcH<5iN$Onj58INvnbvn=~1YTlYT8U+3GExY`i6A!vUXzbmQ^Deo?++DFrJNP81gbO>pGS3}yW-_J(B*6@yZ%y$|>P{2G@NR~!>87b2(CSY@@AA+XDe)#x{>M9KDF5cbmH zsifOnx+Qp${dawBeRJbcX#ahE#B<_E7OeakxCuSvwBo&>lavJNI4se^;pcoh=vVX1*V`Bx4s4Q$^9t4vVH~kKr zKK*=L;D@Rk&aZ(dS9*R9Hw&o})VI^&q$0*R{kl&^>$r27^}45`VBmba9gJT~hjFXC za0r7u#zm#wHWNdTMNWQt!=zsTb0y9mli#Z(EVCE60=q#l)Z`f9b#+7AuBIxZ*rj=5 zAYK)(Kzcf%F_P;oO#P5#Cmuegk|IO&G#Vi4I**zf;EL&uX|`=-rpM0Ah;?0npKs&Z zH2H47;%w)l^+BVPINgu~8#=;bWCI=g;>l)|{Q=#QHJ1Kpo}QXm#FqXbQZwBWPjvT| z4e(w=Dh+jobv-W9M$0(n*0dv~M8giYrqRa?!+|+8A(&4@SS5AWe|!8mTJ!80k-#Oh zIhAN=#yndp$2>6k@|?=-zyE^&e2Q1}P}C&tuj~@=DN3=Dgp5Zhh!@Q#3G{2Y_mAS9 z)aik{|Je}TM-8|j`<+9%ymyq>9^}R76{ELFJsG-SSf9#v56={jj<(ly9}rA1nG*A1 z-GxVU5;}%qXkU@G5N;=aANYJsHmMUf4JhW8jE5M8qT z*?~hKr%LYE-rS@;ISX0es~+agL2n{S0fi^`HvK8h+eoP?W^cfvGraFmfXX=4?P07>IYqpCS=XWX1+0buGx#)|^_Am2%@ER^~+33bZdHCO= zfWh<OpY_-lqlHkV+H7a!p>d@vs-R`T4=xcRQF; zklgPAu$|$}V3f-z;^3st)gTuYH*g#jHP&$H{529TiqCY*p=`gG8Q{LaI2--9Zh8FE z_R;R??*3o4;MSb|*BF@V&DB}n(`}eo_PTy)7JUr!$yybCRj#`tr=pB}2V}5*+B52O ztGwpAV~$t3+>h7!y=yA;c69|KHukIz!?D_860E~MFu7PixB7O;1W8pgV?1B|_Hc0A zWNELfbpdqN#<;-ivX}Aqjaa3RG@ckk!&Wf#7jwX=wNk>~3_&5k1OuBYs(AqIk&c6I z(LWmmp=!p~>zY~za!^x#B>~2ZpYXS2VdWeb|0WVa9F?{y zJFodp+E>Y_1A=4pR+3iw@aNRVfo!*`K3|E-k-gI>nU*(|qNv_cTMY!{aH2=1Flb=MrYmp7P0j+i;q*z&CeH#7 zp_4M`$Bj-eFVY6@BvR<6l5G_QTFN+6&5t9O+f&FBz2KBXqJPrVuZUU|UKtoq(ESr28TNzL3B+6JfHPA+%)uKdHd7J ztCxBs!RXP_+q=j?NV>dQfR^FkQ@I(P;@`&>_$dKDwZK?RAW_V(JUAfA!Q70Qx2QJlw?^#m)Ri^nN>7?M{e;l)p znzLAAI=iFvV)x@9E?V)k>|zfn6F6S{DjCqf$0_}tjyf}Rh=9B72M6B}MRQ6HPpMQY z^i-iwnq_){1&l5ecWwcrURFw?Qq?%M-5iUke@LU|&Y%B$?+h-uX?MjYPspu1(VXQj z7Lvhy0P_f7rD4q_kA*T=37Q0`3Z#4IonPOq zEDUO(lk)s~Z$?VOiA{Bfgv3AGfN#A`a0hg%z^}A|qlC7Zlc`LaHJ^O9xdN%u1`|WO zq2mUrc}xef@fbA6uy^1x&GO`@f zmN;@E8rhnH=cXPwT}nhGVjduxe>j(L=0KZtF=51ev|H<>pqN`R$|O?-vbQ>;0ojDi zQfGa?o9}Hl225+iXQvA06A76F1IlZl{VvIbK4%e>e?@jV1_t*nAzudb+CFH$jj-ZM z3ln{AM(;|6$4Cf9rpL8!2IRUPJAm=lWFF~SR)bc)V*s0PJ(vk{h#nEc!s`mwoq5a5 zeYT>vYVvK?2nMq(jml=IFfmOrS;o4r)kv~JZ7AMFB*+B*y#SAs<|jR)eddW;CBfNE z6bGt+t?~kf11K*e{#jxL%}t*&DsUA-o{SnLog+P*!{zu=RkfEnaE*CS?oWs9Dq!k9 z++rh$30ZX25&X-Q93A$`8$h+?8tnboGdxpzU_2*=sf|pgL?Nu8G%T>Z03>}Gjxc>g zS89&fM?^zv(`Ls~eQ&FtznfL4V47vzi@FbyigN&5JPL{wksg(XH)LK26c3D0Ed7{AZ zOk$>exUW&=pq->gVU{sJpsJi+6$8^W?eZQY?s*FA^OW+kN=~o~3^FCNDmf@N*b#$N zd}u&~8wLwQ@Xh%My&+O#QVP%x>z)r+$g7b+W0$Z9u^B{*6e4=W$ps$tqOE3HnIJP6 zohSP^B%={kh(afVVao1raxn}zWXldm1Jom9QC6WV8IN)#M>c7(#~o>hFesTSq-aoX zVCD?q3dB@;X3`K4aHOk%+W0GNToc&74~FmZ?VN_$rE7* zz|zVlJ%sNQnk=y!+2>wk7}yuNt}=>gdNFkSEtL98D%(K=$`%O~@MtU5Ao z){3?)8JIGG9#+uVHHs~6ekodqCUmwxmkw-@JWS4;FV=fU&ULQmL84i$cbXADQ`klb-TzX`aF4Dn18Z zyAT+QHm9gu}lHU;3q z*sFoNL_{9+(Wzw#$gBi(TZB#mdRwGc!CnSpS)RNdPHSK+jLymM7RF>X*ro8m^YaB+ zp!#re4p;`VI0JOBZi|>|2bihZK3)(tk%XqeaO zPzQ=(CKuziYVspZDA?rs@=n+T1`G?SK}+#TK`NrY*8i6 zJ||5^hwO${5nf?8b>jwbf6d4Jiyx5#k?Qgo0KYn$KkY;~Fq=x7#s~ktdR9AxgI@Rc z18^9Dv;7__sybo_V81oW?oQrrh^7nfPYOp=j||^X?%qX*WXQ(ih9U)Mpf*RH7&?!y zF#c6IAet+CqFgg}CgY%A?Z;s$bhGXz-g!TD7BzV~#CQ>SA##4zzKIteX=f{!-oZ0s zd=tIGls!f>vVFKGS|7{krM3gP6oD$3&J2rXU=dgOBRI8$ebU4VwiH$4VN&!%3fpps?h9?Q+s9FdR$t+Mp2V~#ef_4dl(6t znl5Y1N3NKCR-#7|e zA%i9sM8?y6T^gy8x1C*h&Po-oM%f6xZk+FhvC*l<$C&$6DxG4hZrVddCq-y+*>wvJ z73v_~sv2VOzg^2G*g*q`jxvGXaDqlohN0?A$ee8oD3u_^7yOOA`{#2f0641MnsKFJW$M6MJ`i|I`)h zXUv-E?aClZ?OiRsDmIG}n!M4OX%_fbcVwN@=&&^%+WoU5diib&cNGk|};yVjY*ujZi19n*l3? z#^()1KVoXBZi`F^CNenbWf(6*BbEkk_sNFQhGgNfI@lnH{vdKUW5|Pv$)Jt+QhD}S z@xl2`P@JDE7*%97JF{t>so_KiDHz3P_EdMJ@jQd@H|82BAb?u9eq@GO>N*(GK~+(U z6a)B8j;Ri+Acy^8g~C83P@M;7X{{XTpBAiL`DistS2G*%plDK-H~Ul$7jiKm|2IMN#R>KsNqQazwwixyy-|+?l8go{vxz= zWJi5uzX3B-m{@g4zZu6YvG%%dhd5e|&t~%S!7nN{`Y%+GX0L$z-H@Xl9YE#m6Fz*W z!3HlkLSH~y|8k9-%BZ$2V}q)xP~t-9%}W*QP8Nh2dS;s7w{3s^_ILym)*(UP>+h>R z^sw4+>Mj=5*~E|fxyB5jBz~m^1B(33uT!Ix%*|)603}Yh1|#1hl}3!2gS^V8)qs6>X}ias#X3yGpwL?N38hh&F7u2=8w5yT3?yp-kQeEB{KN zz>^d3W-N_zptGF{9beYbI-GUsYAKRgX>x6|CeTVR3JL(TEewX-Vecs6Wdqw@Pb0kP zltw2Dcnhr3@J%%M-QtsOyT4}whG4>w?C6&lJ>#GxBHutR+@wFs46!F$Ga3G;nl@ybVS2YnU#1B6jn#wSD^4v zr=XQG6#sE-ibNWvwh&2zQ93pcyq`NG%q}=$rHxkc+DrM2Y}aRtR1cS9Wbq=vGS~#K zH?_!@ln0m+-n4`?C~=ToAoS+C8jNm4^sUQDw=sK8x}}%{{49b&AVC<;LCKMMg=uoT`Emoo-2g9vJ^R@ucUTmkfzXA zVry7iXKaK1lOH5B{@!{)m-kUr9*+Bc3K`~02ihR8BsFH1J2w@S zYB8+kC(KJENQ;>}|AQ=qp19#cpZN5{RP(z>N2hNNj{bA^=yd1P z)(KzVS>fxEx0=zvi!`?#4HPjY_WA$>Osk{o(&Hkr2Z5ltk~~Vw;E2QkS7cJp4Fsso$Z?{lW{RVccqozGyH0xfkm51OP0!YPH~Qv4Fq#@Pav4_%{kt zxZQ$RgS`Es|4W2HEJgsIIiO;}^{<0=i>3cvM{CTv)}JTjW6>j6gSgEJ`~?S*%zOOa zUHHkfVV-n5Nij063dRsEp%F*v`A$CWqZi08CI4bC{b?M6idom>CtJ_^>Ag{Y?+Tp+ zJ8^k6}4C_-FQo(pFk7r73vn8GGIgHV%pSLLYV zHrV%{{|p^GejKf@tsv+MPYLxqDmI!ps6Gt}{`mnugn$41=M@cjimOf8=LCB8+&#FE zIj1K3fOaNEzvt^wG1`f)91q%?m98A6y;PArS(_MY6?1#+4J&)Wm{R|4oYBZfj4n^zvl%aC5?^213PfXaR{wyUHw4F*q!SfuYDkL?kJ3OF_vytQ;A5ml%+GP|X@7+Vv;{2Jg#R~;6 zqck%VV28AhMz}Lf{%$si-rhrUhUYwP3PfCqK2ExnnfgC8O6Q&87PYM)={3YX-ybE+ zWUk>5Z)@Bec|^_9Cx~)`4cEY(>23>QxG@`-kida?l4F>-Jz_RE;9-)`z9I$vCK~3# zf}X;0Z3(bSJTVsuD|?1~*O=6mlRL*Czz7qassF=OY^u_*8>dYfNh~&Y8T~jZCZ^1i z0L7M#D{w}!%H;5tQxc;^3L5m_Dp6)j^^kNi5py_zG?Q|6UM#7jie*bFBZ&gSUrZqR zfgCd=ezhY>V;gv6z2(EjN)14ow<|)hYC)~IEK(eBQsg#lm#5`$rDtakJ_?EELQPX9 z7a;ei{2IksHe#ACeIz?OsgJ<7G0Bf7G@?aNp*~+>qH(SQ-`p*_1J5xLFiqDS=OvCs zE&$bS)AjcHeY-o2Bt;RHI_ss)I4Ya29ef~*NWpZ+QpkNfiuL1INl11NNVqBN(KfG` zY*dtWI8d@(!#MH}sY1v}Za(BJpk6dY#o)FKM_8$-$D)|b5o6O`I1EC>1@9umblO3N zIgs|KmXN)9Sa;J_Y#jr|sLpt3so2Y)q>$}7HVM^iT&>+mB*hu`;*nmq; z7rTUgUK&778SV$7THdkIzF&8+*Ur-0Z!0br^RG%Xz&{qVUXqYVRShWl*;0+8W0SQO z<@3i*J1D#ASC=cmWwSU#iJ-jwQL@XFqnJ39+bBa|_q#5#8grU(-FV|eL?WXB1`;Sa z-}^@~RjlN28{=^=z>6y2b`f?-bA!9Vx>pO%3sbwyiwM^d;9V;0%5c0ijI-?WP@$(Z zd^I}3@x$agIRecqxZ2Uwj!&cOIgWL7LdD^e}g4@a(H@)90Xhiyk{T{iU zZU>rT)vSWbg?g)ttc88ag51eN*hM&+kW*#>CKTIyR zBkQKUROKHCD6WD+N)%_Essb|POC-TFg*fd&QqoexWKL^L8SoQSu)xNF=o2<2$w### z!IbrhQu{ODZ@f|D-cuX%Sfzy}wL1j`$k#ShicmhmvAzUMcV(_CTxyo?D9IpO;#SZ)XNTMFASSX{a!5r4IH(GAymcmdQNE9g$wonB#nbL8<8jfuX#2fr_I6&T=cmq6Dv{Zy(jP34WN%S>aI58#mB)G@+s)458c0O__O(NeQgb%ZQfshwDw?q?ZN#& zt*vja-QR@wcQYLSXN(bbFqGTEp~I$CC}sr zXl{QvAbl&tzv<>AmlXPDM~#om(C85(N1%j7@EiN8z)X!DFy?R$GB3pK5FQp67;117 z?IH0wO_NI|p#Vy&7=fslF{qE(%8(DQOyE13V93Cb zVk#SP)A>eT)?n=yQAguq__tbxKdbS|1}RywyoOS2-fQ|5-!%y|hO98|TKX|2gGl-L zSK*ENoNv+JIEWWGzQ<~?P2HcM>T#*ZW+Uql#-sM= zJ8aRgS{ho5+{=tx4rw0F<&pgDuHfVl(QIt@Ibwp%??X=Af?s@ZKG2B+(VGs2ye=<4 z5$@~&;mUq6Y)P~bX_Y-J{vx4D+4+r+@bM_?c?iOpLIc~pX{K(wB0n*A|LNwZh>Rv7 zt`+6u5&UZ>J$VtMsmn-E{l?RlP(~o%B-csCv#MV^Zu?2*XC|a5s1*ft!LZvM%n#5E z7kTG=!}7Ck9bX~FLuilkW75nv8)r$8KHO}q2x$b79##~@)F=1&2Lr-j9riqNo>@>_1 z)5K?`dYJG`5B)dWn)bSc(ZApFgEWoaGS_jo)r)L&IX-K{29-M*{j+)o7p7IwM6AM2 zV{!W*1R_mv~q zU$XQXfT<@X(8A$YGnVNId`sMk9CS3Yhq)Uto6NNA_?X0;j`x>o|6(+W04f~l;aaf> z$v-!JbbJ$A6tycMtX4dIOUig2`a4ZsVV)}f`4miGsWga8*C#z(1lWn3LH~6D zx6qqWTD*}&Y-rw~G-6fRji@C`%H@<>ej9;SZdRakfVbnUUAki0>=2E%n6sqw{%H^h z<9kWdE@)yRQ;QwWxH9Xf)7w_z_K=8BVVJ41Nj%sM#PG-R(B|sxC`J2`jvau%n-f1{ zCS-I6Rx>K;>+HS0C6rSA`Ew`S&kKMq`*VN9BHO&5iE?MkcP)p?mbZo>IMET!4z6}Y zN6Gb)2Q?SOGL+YI;8&TcDKRxI?vc~XO+fF*>xnYATG^9?g{lnCq;=Ht`gZ{ zu=sMW0n#q6Md|dx@U5(NIP`j+0m*J$d_)4Ec1ZGmo-xUOUVKafpmt31egQlIj|qom zK88E&cyKXHxDo-W!|4LJ-ri_`i>e{~WqqB3E-~%9$&kkJXtBG>#I7jHw_M~17@G+6 z!k3CRcfjESzJ~^Ws-Xdx?@*h8**8H*9c8u^cJTLhw4YwP;L8u`uprso%z@l5Q2TvN z0SO;FDWTE2Vimbn(Zg;XXxWVW})#fg+P>ybhjijp`!(fL|ut~3o=pNPa+g0+1`p&9GvA6%UZj(V`H~jaJ{C& zu>_`=@dDIfWR=?yfqx(@g;N+|x8k(IXs3;dSf8@W{%~)-#&}*YX_>1)EqA5y=KZBE zHVRJ*tv7u5nU?%Q3~jes>`EX@T4r(__~I6rF8lK>El%WfEvmJj-fmf|!7OWGS*iH> zmv-t|EsBykmzO^JObaZgwOg-n9h@aCv9SPtfop8^Jo7EGOz88j@-mL&380p{*1yeh zJnM4Le;~VQeWpcU4(q;C&i%zQ?$-a`SM`r^cno;KTl8odboRfa_kJ=s3p-+T7#sj%wK0A1QGRJoZ zJklAPA8sFQzrwAJGxC@`%o7?L4!SC(hS4}q*-zdV_1;PT0W*e!oO7n0@k zlX*o)Yj7D^7( z89$kAigONSZ-4Hgz$Y^f1zOHA6hJocwf$-IN9}&x-QPXh+nJ>)$_!K5Ip@~hS9^Rs zKi@vtp7|?wiJiSU`mE2~T3mdmwD)-!EDn7B(i50p0$-a6$Q-;&KKPM{XU4Vwc&3&! zY<_OI|9tOgcW2rfOWVVPj_=g^t`$nZDV3lObUapvZcDT{I!eIsDuAEMB>RF5bTs@ z$A8`5nbzjT>z7mEOy016JDo_+f2+Iw0zSAtUW7&b3Y)@3g*dGG!M^75uW$xH_R|Zl zuFCkNkYMuBC@|Aok%jLl9S(L@4AM@9-bUk5)W_PgJxOp_UXp_e(>sRw0ZH%f*NWJG zBdLMzQuR$hlG#6)-peF;=WnOTho`l9wL29I$aB-0{AKs(n2vzzX0R?gaGU(Nt4V$5 z;ME}rN5>OnMi|iUG00AbyY<%?X)_ZvBiBr99L&JDo|otFV(%regGnPZm!5LA~_XF(Y=Se-783C05Z~AdUFTPASNznM4l1QesvqIE#csoD6-k-3U5Y&_=cJ-z} zg3f@{U+(^8_vPgNrnj;Z_H=mA>kM7a*x%%4FZZ6|Hr#(5T!uvfJL$No3Sd!TJMIjM zZ2^XfhtpJe-icKLI^jH<3fUcUC9rkp-&C0HP%Oc$J1?ihq(ig}ui|W-3X2Zh5~zw} zcq$}1n@f-?PV8Hs)^~VPPo3pK8Cl_pKAq0&F<+*$8VO+fE;C|5d7D)W3{xSJ6j6d! zAzREmUp(JyXIwt~r^0n2N(pM6^fDEu6=_N!YlNNYJIqKx4i2}~uZ6U33whItuPphMsc@QfI8id3;T&LbvEn4C zk|U?W)52v5X1(M&6)uRQC2%DXb%xpgTshT}G&}Rs84IAMfn#P5vVM1SH)3gEv#Cyo?7_P$>M?B+t{SD1wxE^y>erM0x+BKa`;aQ|b;! zt6Yq4`H280=Kot;yT863=Kp)}5ZnKe|L=A`v*iB^H@-&-K^~f4q+FxTB1~L@zmPOE z!X_R|%Uag5{BC|D9RJ>bX#aQn#VUJv!To>vc|a%b|N9R&AC~w3gZmqQ?El;T%$xrc z$e?Y=fHUFSB%nz@N_wMo*ysB>M*8OGeqGt;`^Qp5hw{!*a4d&+MzQz-#}65bB;BAw7Ahi3+%zk)Z+V{uY{{zE zUgr7x@nE~#MG3zZJU-~B#sf3_px3K;Q+mAJzd1@f`LOFA?IcO~=+(#Y$$l~z4a0}W zdFjjJ;fL_iQCj4^4=L6lIT@7)%FX3%>8pz7^nB>O@c22do)uU5yKh8;#N>uCw@74r zhf%_)mMGn#g*unv*wo#tLWjISm=ae8DlVYz9&pX)Y z-wLiDdhg+i4HPG;MS_rO3_Yxo+&|AQ#zRpxA(;31j<-=W zZC|vbxZyIJH{umeg^Mc1^K1w$&ncbncGTQE{IIzKyWfD^h97$Ra0QFh0C}`g(;da^ z_-iX#Wuiso$4O5Lr!vJ#i97=nQ@UJ8wYNUja=e07#C*T;CNrLgarA%w_y3D4>_NbS zM#4n9@-YtAfW;7a9H^mi8PQojx^z{`04B{fq>?vWjugfKtTUErm?RAGXgE$|u1@FJ zFBJhJgiDFw*mfMBrIbTK?L5P*uT4h^apuFA<`ADJS6S~S4u^OkIT$O)fxvC4VmKry zVBQ=NElgoC#3U=jVH-8dn8AW73sG1-KC%Ab|Cy!(Ox19eQGRFG!R{+t>cilrvAch8 z^5Wq2{_{pm%R}k3Fkgn_0jZ+JZl3ZorXR6pE^3%5LF+YF!AheZvGC|T$$FG9f@{-W zCpUHnn^e*L+|_2ItkIaMma3-Y!%}@gJdF>HOvZg+sTn(*eu^h!G6b|omkAb)>)&Ac zC}M=&+$|a~ECUnPZh>`u15@T+Fe-QlTbAqj7KVSv&?y`N z7A6ZW)e99a=Pu_8f^V=e!X$prY8n8l^R1Gs^L?p_=@*)6;Voz=3<(;kqEWnKx1xvY zM7ZP{a0qJq`SYWlgZ&qKKSsaOgTHLP+CDtoeeUXIeILxC0uK#Ik%T!>8#eM{MRLA! zPK>bLJ&xIAfNcmhZAJg%A9lpRF#ku!WL9mgVT4Qy7;j6exDtUG z4g{3$7u?k!KBn)!{|vZH37Zyw)ri7IZ-4n({`z`r7PPg#X1sm9_3+cXGTP=9AY|Ie ziFLjBmR%jzUaBY~PcD~Wqv_ym@Kh+jFB`Ix|LY*XeYfzaCj*8(yjVw5a8M=4A>~V< zQeQ?GNDX5uXy6W5d{=;^hzA96RDBMIhf$-T1eU|z4Y6JjG7$#mmyLsyrBtZ?T#ZL0 zGfEhhb=4K4h3QE#OiY9kvv(<3m4(UIWuA{Ma+asV4i{QXgfvN@%to%aUV4%ANb(Q* zsqW^pN>P)~B6ZNz+`lKVu47)^W@CNh5hlTIuLJkl*qEJl31>INX<5CHO~ArTDbrrw zNqR(QMRB<-eq`oiZ@Ttmk)3H@aQRWD1bV3UlG7!G8_qfL$mIMNpUNBWbs?J$Z>C1V z%HERn2+wq5Gb#jXV+uwe*yQEpZ`dI@qiou0I?Qb8R9BF7u zskj)x<0VZp7}qTz9Upk>Xf>pZfI9k%2g+zx7aG^e&nHzgTm)9_wgy?y(Ff)@)XNKh zTV&wxZZ* zby0?`Xs^1PIceviPdo5)SLE}sL_T*;0S|9M0p)L(P64xYamN&Z3KLoGs7cz`_kFBD zk42&3yl0L4H*xe|<8*lAw(KHQ0N0RFlJ)Vn2~sCkmnP{7a~T`3R)(c27c3%1msA>1 z6y`TkOrj}kP*I@mPzKzQ5qep0w6`v)1a6HNRMl{h_Q}pA`cH<~Lb}Y@excR#a-npJ z-?X4Y=KL*>aaKY3CzN%`8WM>LO5F`m!Bq{;H)2J&@xl5CGB^-@u}Hf;b)JIqEmThW8HYG5G6 zxW4#mI)%S9oap}n%5FsOs==YqqMk=lzu;Y1 z8jjZrck5MBj4)+SBk5jc{ra{A6*1q6)*n24_}#-tn;YKSVR{a$cDWUOx3(6%7!7aA zkJFEXYzX69|2B95W1zKu2)JI@z$hCQ`0%++`(x*!Ch$>8D_FIso9!*(GxKB-5%kp(=zO_UK za+j;wN&0yo5yj_y<&t<{ZO=|5JxhijQm2ZXHJC)ObI1|%AQB11vQ>8u$FF|A6Cq6Y zh*C+KtwLtBYF043V>%=mOS%xmBR+dmOGq9hJ|z5K1Xn@(MW5F^muw#0emwFaX^Byq8=Qv3ej1 zPW=ex2UGK(40=h2)cX1{OfDVj2Y`=rkW=~&UZotO4WKw4So%UAfmZ3-INm$_^Ye|@ z`X!GJ-uVyh0O8GPkqz3XSsrZg()!y?zoUR_S%-Ax2_y z1^M`B`a8Z8E}%LKLy+~uVtY zf9G*bxkjv`r?mHit`QrX-cxgnc(}Id-y_T|;{L;>@yz3Vq5vA|iRU3#W8!u@`uONC zcPTK@3r+SjQmK`u)U)d}ySVfYU^0Gd+E$c3jnX_R%su8#;0CUbMlzyqtZ!`GS5Jjd z1*IMlE{hO`A0`q)Ny|SEDU8yOBhpP}q`o})`DA%?5RI<$d)*Agk%E;%RW@B3z^un- z^wz2^2Af-Jq^((t@DMfH3Oqbn`BjY1?sqYkWK}KwVLC+D zbX5HfQ}lXdA|O4aiHI=%&g=<{s!FZUCjXJL!Q5K#OMaqXj2XLxOqzc)8_ad=AEzVU zJj(4KZ*}A@kKzjZlp~tXBmo3@;tm+|NJh%xRXggF&yIW!H^t$_7-e=*Y+6Jw975n? z671qxivjupk^i*#{L}ol_qR=WAVsCx)!9qtZ;95jA z=zyK5{fW-WcIS~BG4x&T51I+o>wE}Y?FzlSd)fOmdTY!(7&7AM=PKzxBFgDy{qaZq z^WGr2NDKV!!76`4pR^yek+@crn;Du5fa@b#fDo<*BXRIHM~S1#tgE&I)<_F zdyhSaVJyiGS+pdlfUQ&0Y1pF~AFzA&%O2T%Y1b)wVM^j5hRth&%>}Gw_hz2yBTa_A z40(DV&rtN#&c`F9WCxO(KwZ z3+GVS{#Cc}dD1IX-HdP4%L!jmm`T;9G>u`qsQ$}y0m#p}=@BjQ0V+sv);cQS5+p;S zYZe?iZZN)g4*=a`%DBfGA@NQV&wSjV6lI8I(~Gz@TgMcnhO2Z10*rhNd%fQnMF|!A z)C6m$iT?UD1lnxeam9uCAuv><4ga=8qy)f)7Bwv18f?;R7{oW?8WVE$q(teY;6=Yi z4wy%+on8VQ*TnCIMGw#~FCVHBn?azT;rZA;fhqU=s_FRS0>ie*vIW%d9=T@1Z)_X+ zyVPJaY_VBt@-S@ju+(I`e-k!>N2O*vEED<->0znqtB+y3S077_NCg+Rqle|DMX6mG zTZd(6hZV5k9ve1;N9AV252a?q52a=xFNe+Gk#0tkplU;ZYfsnFOZ3$h-|{As=~L%i z0DnGws)R_NoQg6z6#+SYs>?!973~`&I`NwP3+5T1`2X`e4ga4Q|G&O@e`D=oDgOWd zgFoW`Z~ZfG{J$cDF#KN!`cveh#0E;hzmE3*ilt|!rmrFkUY;RfihAa|z6<6s0epPm z4szC+$i0p_MM%=G#D(NkRGcqYl<*I|^alchgrg$WZIJ_jV9S7bM%h2necTEO$$8q2 zc8F8RF^rLe{n8}>J3z$0^9l~vY`|lJlhL^B0DG~vdK;=(pzVUN2K`W3qfR~?jyYcU z3dPY5d>^JLSgT1dXj9m+|O7 z`wI(f>fu#Y7e`m6M~K6+Op2En$`>01v_MP-|L^}Kb*jEJ4*XqliC5qQYjUt=qELU+zJNmgaF)JESjC@ z6t}A1UUISB@0tZt&|zDpAYIVYUx^=`qk2)nhEJh^{j}7m)E5i}SCkQ>=2%@#UQhMx zW|S8AZ8@i}sk&A-LFrUhZfdX5;|fgMn=1ZL4mr8-aZ?Ob%{$GtkLU2S604@G!7!iN zaZUoeRtW+4IS6o14F&+;{c*219a_v?w-JXg)BeTivU-F)dRGsh6V2xR>J}m1cSz;z zHnreildo`*r&|Hj6S&n>myAdGPA@NzHqYQJOyR;?*)YAzMl&@eYpI@86|jDHN(;P+ z!!AsRuae>W32m$Kq}a&s7g08S_Q}EXgRKZ|Em2H7X_vIM!x-++xnv&jH|S4EzuQae zHynyd&}%x(I$?eYkQ4gJ1&AtVHzZU1;^2J}eSX{97J(p9u@Q!%xr)v!*iA69?Ov7? zq^QDiT~fd8Yg|nnhs$?Bt@VczA#b91G3_%>j3J0U3t2F#3ygx6&WA1^CD)_^9Yxm( zrePRq&?8B50dlKV>OfC@qZb=evIguTBNZ~nt$s*)D5hZ|kQpXYkHzTUCAHOyaSs6X z#2qTOq!LHtL2m7K?aBp6259-Beo-pia);n+pqp=rW9xF2%}TK(`k&$HwqlRbUUNMhcAA zY_Jv%qat;|2_CYaO8dV(UQr*7VPRondOEq8FR$c>VG63l4Ck6SC5Q03C%vgZLFzQd%0u7`kj^j9Ly4v7iHcz`$iB07UxzBo$Tk`vpTJJWrK!W&vm3LYH8WsaCQ6maHX0=JHDXaiCFh93 zjN`!0Qj=Va;ek{)8s;}>B()a7*ovn%lN$*sWR#jR&X;7dF$s|xlUCuZZ(a%3Ox+I|VD{ifw@GQ?alLh2WZoivUxINW$DGf3~I z1d%s*W;T3Uv?~{DFfJ~eB(Z*9`5tG~T=QRkYN11^|I9j`l<1n$0hy~Kc}vk&lN^oq zxKtM~wgBV(1V8DvXr}`j171Ev;W82T7C2F?!w(3{J<$v|$Zcf3xec!H_lw>_bD}B@yCZ^#UP6C`6Q>Zj()W+HjuVyypkFt4e0`Y#eZp*DedT2@?_X^FX56n} zf78*&QNZ@9xYaK#BVl+X27`k1j}fku=v2E4tgqMH-b?+sdt!}FYGq3)pKIl1CxPNN zr{HRr)Yb?`?t~&H72yRMISm;%KwdyLuYnqoCK})pbNa@MtWRME>Q?zXmK^DdMoeFb zR%N*MiHL zCUiF;CQ9`M;R+CDFGh#?FkNy&**fU%Y(8uI^(Iq6kfUHL!TN%+?aX#4bx)-b6($F1LzrR!8|NV$Z+xdQvT#Q0U_(1Ejz|WFfT8hq63y z>oS_W6<@uhlm61TwOw&H1lDNwW>fsUp|~Gfhmc%klPmh*Isrz$Ymp(^=)IiY&|A>p z%JLcwk{CY6{)DVH!*_DwvtOENm@u5WmA41XqtXGBegs~Uks#2kwjIWOAe&;H4(b;9FHDIuU?3CYN(m79De63;R?9r5BsO3w*=xN7<|JT>X+ zQOr7sEnN&~QnxC!BJ8|8>u|WZSe4(0Ua3R4@!EW~QzSbpIitg7FBx8#DxYx=O&X+1 zXt6(u3tLz3{LHlsc8Gc`s)W~{I)oE1(T%Y(GK3=R_dFjDowd<`{tR|SxKBh*PJ}C$ z?}CnIjNwh_$l!gT?`RmKPsYer)ENG`5!%e%RY}Cskt}F)Gq9keRi2z2ewhs6Y2}^k zQ-G`)hy-1DGCott!S@pISxGQlMTfNv$aqEG)^N?sXpnH04XsQgIgD4j88`mE)`(Z? zmKm=n)HQPZ^nwfCl58KZxpF_MY$tyb~#>0(OOgeLqj3k+Sa?getxH_l;x(s!3qd39B zqvX_NwJQD%`0c3~hJCzJ6_KE0KudY6W}=MWR*4`!4z&Z~YQBApAjQux!nH2Oz($Yq zMk~dMYPg6V%z=U|nB-`YfD9_xJHTSINwP5KeOg&S;X%V(T;t)*a*E0W+m6sWC;ACb zA1PY+g|r?th)S@PUMKT1A2-LPMs2_o8@_w{2oAEDo0z!Rm>Z`_PPO~fnJ#pK&{_k= z+#BO_ZVL1jAO*gLSai}p)^})?##eS)sE>9!=tnQnTTxN&GrA|nu6LF8O6p#30P1L}`BDt3 zWu>V`Q#cL3FA!rTW1+CP3JW9`gp7I6@dWOej6AcX4Gz%rz{nrxO)%gcwK0cZK)~F7 zIAP{v&3cZrJ@Id~*6_$5w7i!!rbw?%jakxbQ)i;Ax)J+VYNCWUjLCA0W5opA%TJ28 zGD5xYH0z&jw0^5;!LG}kTUc50)3js5ONbcQa_1Bzw-5JL0|+ZoaX05tvfznCa!O2# z{9%TJC_H^M=w(P}lMfM;bAFF!$VU6S$}?oS%(u8x?yHAi#fSqo`a%3MN?8JH+&C(n zG1TtY*)}G7RWU{q=S{^&tg7*PXB)e6>F>AU|CIG^L)Cy;G8MRGw?@xJ7QWi!sPfdE z?C~?F#OzxNmP`Blo)Z0&U7wa3OhU)hro3dA?xfb3kRo%bej zv}E!^=RoPk@efHej(|9`YJ6U_EkfEaP7nSwrdV+dbSF$@#Yl0dvuuPu2hqV1nM3=W zZq|cwgfLqEvp4jN-2em* zJxWYP&j}z}oGOJp6NUBRkjcSwRpdqMfKDtMPCMjHe6U&4K=Ge^WQR%S(s_Fx_y&nR zRm8sHlyeFnevg+MxA_sCs14rJ48z{ zMq0&fFMx}m(RJ-ZIyC#8%t!`mU`-0>cR!CV#(*a{{Zgf$PtNd0N;EryA$Npc+5K*C z<0LiVv<4h69wneGl#eow5=0!<8?iW8lzeW)BGRI31!szPT$sga8XI|CU*#Xt5cF&e zZ6c4-%?3Ag&Q0Qc6Iq&p&}?wnz7hZQh;__wiHo_<$ec~|Ku+iN5GL?A0%MBwldr|Hj9RBsi-pk$7-Jf?}^7-lHc3LPrSdj*UVFna1lq(KzI2mBD@_8_XW-ht1~-^>gJWylgAz`tn2cB-)C;j#i_;!x}t| zzKK`p48i)~Lln-*V>5b_^}CpRBq?l%PQnJ^^zD8^S&(t&MT;;fX+`$2M$rI7nL>%) zAYQlOOd94zem=r7T_|^ti`8rH24wT%{U{%-BDlSS)jk2gmr!ILTw-3+nD$Rz9JjQ5 zLA%D(nX-o`Jn5m_WYS4<#SzpaB%X_lO5DPcp=W#%eM_M|ua2MZN4N%y&w`k*eqU#+{Wn5dh3M_-s3~2;S>0eJ%M&TY!WiQU{vdMmNRAI!LMORN6xr#4F_i&bSZlzL8)_uoJ(Wt@=PM+@_#kK*R3#A%5IhI91 zpD}Zc7ui*Y#h>LgiHBFwz2SKb>@oX@I#xI=y2gD$&lIOgqce{1@h^BE1%W@K`YOXQ zZbQtUz<)%aKF?mEB?u`(RhCit&u69$4(g;3d|5}Tv533`eL;;W52TJRW~bv5888{6 zOCetJD;V`=8~(rSxlf$=(gtEpsX9dL zsT-Unt%wW-Ubu5&zPDA`X+vNIGNHxTzLDH$*y;5pS9t{Pgag#e>QuJotcrG66{9!6 z)qC0MWH1%Rn0Z)o+Kj|pdc4wU<~?tAHg}+#C;@cCw+U%x+&-@rp}-ETB`7$UgI**t zODnRTCQlfurXGFwo^FP+JmsKLs>!X*t(jYmVQ^1iaRzhB3Td}R_8Ui=`b=MgX ztmqZ&2(t%!H+qBl!Wvm_ed<34$pQp<({IHFpqU5`aWY9!$W-XBVIjeiFp|#5Sy3b$ z(-~5_EkCkpEr0ar(Q-&8h<5swM7-cpb0(?^Xlr`xPATe1Ior&|ZU3OUFNNyr&ru12 ztE8loH|;EJ=g5XV`tgppK5Y%^)S_TAGVutLMKnOYGqtbtyV>J2SX`HH)ka&3AFeV0 z>RYv|SgWABRBv&Ey%QSZKw&?#@z|jnmw$sxG2Rc9}E^>r^1%h*q__6V*3Om3l*N`NfKB z;wvyoAyU$IHsL0*Qg0>0w~MGY>%uXu2N9y5*IoJLnCp^~M$(U%KawQKM!O-Y#T)H* zZ52y{uZ2&PxngHMGF#{jnGiKweZbV$zxECpgNOTg%t)g5-}aC>A$LDvB2Djb37C#) zwbJ6$J4xX^HYCGhwmk^k2;;_hbpCCFw!I3ryDh1Nlu|_yE=1ojx~ll;`N<~e+5iuU zgQ@8c;`sc;@w??C_S@ef)c`b8lASKT9vb<&7%OTBQn#q%h)?=u@rmjhfTg9c81011 zEf2A3k*Z}&QdZquo#nl(6ZNwGdk(-IvK`dvJA(+2w=qr^+s|QUGM~(7Y6|@Gor*+z zdBKokgn3MKTCE!Uy$Z{;9JDoz)H|QlY`=G?lVnC^sW}Pd=7kirG_+~UQL%4`km~PQ z)f;7c0Hc?5W)i;=LN*MGoigd>&b(O`EQ~ke^{UGy^~bV&re&G1kCbJ!T4hnU zVmsCzP`MzQ@y6)o?fY7jikncPY*>R{GD62`wy_9HmSpmA0}fc=ZkXY{mo`{C9XI|V zD1h6Z1!JC>(nC54zIKk$?2#R}lQTG9#+YTBDho=UIMoR=*LZ}fXGUs9$W#p|FXI$K z?ZcFk9;Ng~l9WEE`x&jKh`+}?@#Wf1Vd;o&ctVYL#c)FMht!JlsH$a^D1FH{+(~59(n-fvZRk7%!1r+L;6}2_$B`6zv>jN) zSNhQOXn3xrGkqtlI==ugk`Vz#5Mi`m-x$B;X7JjcN${pPuhnz&MzjT zFR)GPHbhUY>rm-_HRs)Gj(gQ2^f>2{LW9>czMZ2I1zAox91wYZbr=-l5#F`I)CtHi z9T!fmN>+M7W0=Q*v)SW$;jYBWWKkZAOCR!$$enc9m~hbYP^}Xjx{Z*9DhE}Io4SO1Tc&m|b0{xGpXQmq zs3~GM`gr?QD?A6c2R1zayJfGXU@Bb9#Zvc8C)m%+hwgw(-SIPDF2-ulSGwC1uEp$n zCBNHbdmOupa6x_?j(avOfrar+^cRlqkn6t0NAs-kARl1#0M~yeU(|Gv;{gpFwW9br zu)erpwXA^%pQb~gP`Rpdg{sE-#{JC)4PEbu>|=fAy*`$k8{J^-x%i&_tHqwUXdibuJ-NKcXE}WDXj41~VFiw}zGZf!anf@Y zd2%bMvEIaTxFQ7^Wt4RaQGcQ11c=K$Qh@X+1uCin%=kkpJHTTQ+e#FY5Q?`zuTNfl zD+|tHixS%47?P&h-;*JLkTjR--?JL{8IQl2MeFbIZZZXtE2;^3fsT>)BajP>jUgQ> zkU@6VafN)(3y;g7meqj8xJ@kR&hku*t}mS!PsDtPfjH-qK2Q1g=aiDD9sP)XxN>rs zsoi0Ua{$1ac{DWl#oJn#2#d3sFo=+ULlXw~FE&@27g1Q!&-8Go$NovqQWci2ouj&VQxFOU#04m}?x!yDz-081ioohE_82Vq_pX&*ykNs2N+ zIq4Z4E+EegL2}BkbReZDh*aV;gEKf_K`zTa#_j0&*d;>x##&CWnlcC0!YX7KJ(=KH z9*u@@@h4-(&#~?b-54#%V_R3*0W3(7o}5W$`)9|`;R&9RLdC8qS>;?>I{ye~xK3vo z3^U{sxZm4hKAS)2)%z}z)#9lI1ORQ2_CNBh-^`2l=xRWrDJ=k)=l2>bOLy(`t^s~b z3=PLt8)G3v@&=MvXlVtV#nYabV@FYh%?)C7riMJEq!K0D%_z>hleR=Ru3V1dRlq`Q z<9ajleaX1As*Xsn*wxV~Czm}nFi>zc-4kQQ$w=&xq3Ce;+_R-!iDwrnvf7ao@S3sM zCYudx&{%0hlXz-4Z%wSM5V_6>XWV9445L99*V^>j26c5S*;+L>wzNj5ut`cklepu> zp-o`P=Gz~I{TB7C_AC|3L>`^Oilft-EQ@2f9=XiW@t1z6PFcpK$UT27*5_HQyA*(a ztJ)QJRJY;_safG4old~u1x0G$47wa%$w;H1Qm;UDRanbRS{VtMAlP_T zR2&<8|DaqF=PoN*U~ei(ZQFgFo^kf77;e6mN&lSyGJiFUS(E-3>1fm|E0vBpc%B6n zFFsxhv>h?^O>`7L2r6{S2wf02SGZbY7BCvT(EEjMAo(29Y|)-r1!0IC`d+K=}hL zvJuNp0vE+6m|GvSynaYIZyVhsP$M%o`3)+I6_6X&Yy}O1_0ze5a0OA;rWzH;K>SIM zxj2rjN3Uwu*D~=PYMPi0^z|9$LQ2nJdZVv7dkoeZjuKKnA!jyaK2br8V(3WuaPexJ z6wfnB@pe!%CP$Pc_@=QR3o<$W3njc^-s{2VkICPF(6(crHp8q}*k3_dh5jC^?@R3n zDGb!5+c?r@j@vt=HuVkQmPdqr|#5_n-ZEj6f>aNZFn8KY^* z2?}R;F_P4X-p1rD>GF?6YI^MiAv7zX^TkPEOurbxV8|mdu_M7{>D=l-X$X|i03-_3#!Ch+cNG!QU%o7WBaA?_vcbHDaR{d{ zJ6*9S!+K_ORiv}uWgQ!O?0u6q&qoqQ~w7cOZwN?fa zINMRRz)AWZYyP;cG*v48^||G#6X%zNnOjjzvC>r%=8$7~B1pJtAW;T(tDS6)OPP&i zNHZoJBYlHr20EM9Qkek{nz(_lCH9#>xcP5aQ)|vTTJ`ikd%1f}q)V%BZuQbtM!}%W z`NZ1hOTUo3F>WiBiFJ5DIuT`+=*@YOYc+Fiv~!YIRm+$=QC5^#0zVrq7O_w@6?R4+d)`_u|(ZgtC8!eB-H46 zTVt}yi0<^`PUMM0=Z^aP2aD#?y>kKB39pubaQ|WE$v*_vFIQl7^d8Eq^J^XaYVY%& zakC4&Rq?o**H;92`SR|hqi(urIVm{-=iQpo>2r^)JUI9* zrN8Zw_E<`N0g6vyTbzkktT7D681}48ePQ%*T)|qJ~95E-Xy)u zNR8pd>?w;=;ao%*8X-ROMP`1})E~6?d!ogeFWVJlXX&WsDn2J^5_v8uU&rjm9LZbl zOx}3?%h;sx0pt{{e?nIFFgzuv8zQFpm@Pi#{;GV@zQ0JKaqEO*b8ewyJV${_g6;^5 zES`^tBqkX8;POy%nvP1Y?Oe z@EpELDLp*tbd|1&#JYDR8;QSur~V`w`!vpb!VO`Dyo}2m=zB5p~Q9zg*i7Mx$0_GXy6$(X)Bu;Sg3y* zRj5oi+VKDBNzi`bL42B!>U?r`LS#CX369}mReBg425m4OCCt&UaS2l1O&tl0K-XO( z_0n!kO{sT!0$g1j`4byvHzAdwN3G_*M%~hN%{s|wdM(|N_`9St^-5TAAxt{aTUjewUxS}g&rQY}H&;X&Y$3CW7@xS2=(pzSsli+24U_&`+EnQW z*;4||+gJY1qNW;L?XHSYql!;y8%B>GKaLvig4hW9VCwaTNkI;HyVSkejk%&0p}aX! z50m2!+_@gY;ZJyB4~g^&&2f}Kv=4JKv_(Tj1z<8Pl%cGq7|uge^{czmt4` zqlRnOu^ogKXeEa8rO2_9vWeF;DR1@%Sd_NKIljLw?|N7}NgL^|gQfDFC94PZW`zMW z|2cBfHQykJ$(DraIqFK%N| z!~3OF-NKSmD2;m|!grWgwF~*o;Pt z=YFUOrO_P&`Df<-ATm0qW~ugK;@EB5=?s849a|L`KgIZDD4f20icb}9q>BBcPEl{C zgaY|A8kalcA2j|4jeoH;ULtWO+F41vWci+z%~zK;REiT-#~1L`0qRbr61!jiP~`jN%ij~+dW{uV40 z|7mUg;e(9_@P26{nD7I~Wio`J+!hW^W-YS+egQukr}}sOLo8o3XdxNIW?Re2&(_Gp zJx^)ZqiAzD@Us43JmUSGP&!*uzH0Rz^woj+G_L`H10GTDVhKUq~ z8lEW%=fcIo9fynk4WIJx8V=gC8{^=OqNT`v`FI2? z-6B71Ryk2AXI^NSL3|0a{?(Lt=^= zV#y;DN7z>IbyqAxPkFZdIz@{ zRKHd{$hZ_6;n3sqYd&G>qzOe086{a1b)s_? zkxfw7fm3ZK7wJ|_Bc&wd2cq!n7uTuNO6z54ypc>?H^2a*^W;NLj`8Pt-hCQb1)>9H z6lU?kWeY2)mp?;b|NR&4@>A?Xuo|t>$X^>59OZ$dz1uBj>+n-Ebx{>Q)^OV+QC_aE zohn^r2_%2pPP*M)-25-)y47ruuCvkdwVC`)RlQ?GiX{x}yNl!(Aomk0HuJu#0a!b% zTdrx90`>0KH#`p18y3iUvu#uIK}zO@`;i~IaE;vZzQHh+7&l>xxP1m58(Ou$Tg(u= zEq8^hG+x(#p)Q5aN?rrylRhYpgfrD23g-60+;2NNIr*#nQ9UIh0=)L+!zQ=eGQQLp zSb`%H2Wq9P`Grh0a5P?Jn6mOL&(Xl=kwL{-6%+4DlOZ0sDqI$W6|2zZLP03q>BGRsi2P8M-6xGg7(0NG%tvmyQ% zj;^%-9Ftuw6a97QwplsN`V4Z6dUBqbsDnXmm`m35MWI`xYgRPd0Sk5u66X@JdidzH zXs<$^v6~Bir>sm-x4U^bl}^%=ra=pHk}ro$xT32pwt#TE&=Q51jw+Dxr4fh0&PSIY z?nakCo{3ZtD?0>fnOIiaYDgh^A5soNEXup^Gax*~_af+4i0UegcW>s!I9jLicB1e- z#}2b$tA#vw7pW;2bW?F7&_k9ZUY88lw|ILE;fsg8jOb~2DUr)x+HYc;!ea)%fDnv! z5Ad$O6`leHL{GfCCr(6}#p&|4MTyN&4O)x<)h+j$#WwFfJTmV;O}2S=#FjD(dg$WC z7d^HJki8st0IFdVDwTuF&$biikklYmK+HY^6Fr51AW_Dq_HYHje?zARPmn%JJ1Oku z?iNVR*x1R;Qznk~4$dZsk-oNSuuK1D=RC48AdKhO$dPo##wz9<1;UsZ0Czc~TH7W# zjPAVbJjMWkW%R~Z7@1=7`Pj9@^9{WWC=jLr*Z1t77H=kU+zf-V%D`x^&G-atM6L;J z+KZa8PZTkG!qW`>IuX|r7(*d0ARw=Vd*R>y4epUvl8ie>2jmhb1|OW%G>b;bd&iWW zjEXsihb(N8gD9$9xU8ztgBX*V^%jaLc1p4}Z6JhUR!;GG4_!pJrGO?hyh583o9(E* zB~%%#&fj;Brh!g!Y(Ef(BsP254-Lc+XF5I5RusQ|%YfEf0&$}iwcG7?Xk*00@=4Ej z^sW@l=j{_`{4n^Hy;2dXV&;Ubs?okodxMDG*5IFyu;OsHrT;eC#Q+Gm*@znD@Rds> z%Eua7`#kGmzs(Nq&<>W=7>bRYzD1PtZssIWRn&;FndDvL)JCx|K`!!gCXRYyFPzA~*b%E{bq)bP zS<+i6C(y#o0Hj%clMml}!9xZUZ!v*v;~h^}08N~CXe0|x7km23*&^3lquDOS2NTbE zT6YcBvNcbbjBE0{G1EG=v2AZyu)8qxI}iozSihe<6RR}{)Yd+T8e?9qmOL=&mD~Mc z*!vy)kXeO~>s91qn3;LW=D*4IzqR%I8)f_7=Gvn_?0>iYnZ^DW?)i`uN;a`)z5EP? z4rFumyO^oICT_tlhF=FZEo%+*Oj_JkBVb+(Ayg{*To>4-1*sie;4b(>(!Y697o+Cn ztMub&X<%rXOY6t1ZP>{_3b=YKtCMm6eLuhM*SnF_kz#Q0 zl$!lA@r z9g_!#`}<^=^a~6UaF3olZ!`B$*nxXsTpedPE6!ywQ+ZOQOzxgzdzBAO+pL25R;$FF z+k(vDhi&VU;p2yxU@Ll7daZEt!#3XHZ=O7{PJ7#dr`|I?!T@h8TOn$Hc(&*;Pu5HC z?XsFtPMgfhx|xl=(zt24TaE#{z6HIiR8ao3-EFIG`sQx*nQ?HkF`<<~!BkXj+y+(l z`35}S_^c?jFel^EHk%2juJuf~bX0|HE<)uqRVSIl~F2SP+3+pQ-@k zb{ktYW2&2k1JG`_Emlg{m;n+z59a#Bva*@{)@x*+>ifpOh?+~w|JUi+vPFOTnJE9? z-*~iMlK&s9KlnrbzxB^8~A8bWFPx|4g z-c{w$y0W{3&Z8C@1A)h*)&h$?q7^?IurZ4gs(H@r8XQJbk1wRa1Rop5_{nMM0T{(8 zarR+^(sJ-VX;1^0?n)a|#}$aW8)C(51T;>`eQ_Kxpdw8FEcQkX$^@kmOy4AE9F^VY zXrVKCImY!4z=w>G#Ix=8@(z}mv{t_EcNa#=1cI^u@37h%i@7M@lk8a;tQfmhZ#&oWZ)PK}cq@c4g|}h)%A9 z;?|L0DN)07r9sOa(q-1S#g9`%p<=z}(6+STtU=L-WSC)HtJI~9V^DzWZpO1WRr-Jf z!cq25n=nw^V`vw!%Z&-l1me`NoH@{@U`N~UxeZk_cK2YY#spUQG)oa|@Nw^kjEd}; zP6kjU6`Bda#K2n&3LUd8{0k>n4PlpOz#e*eF&?Hir<_C#;wv2#DB=)#K_nN+$lK(J zsoh!Bx#Mq3zDxGl!jMPqCZtHN{X=R0RPSEMhWKUaZ9<+b!|~|yrp+-WCI#i>T$~Kg zrc>Y{HH1=W;U&e2EIHFu-a+p)T(EFiOiDuzzpdOqbvV(erooE0{{&o3KnnAQ|)Cea8*j})yk&TJ~ONvOdFGh;^hhmV?^9gR5J-RC0CYtXK3p;-jy zdGas=ODmRX|2V}zVlwg$C(=fR#v9}sjGFu92^%>WOmRk;KnmsC6U zER`iro#SK`Ev7!cJ(;71DE)l7lnk`PiM@?ngohZ9zhZdjNk)U3g<^d&^?*&JSaLez zI1ecDQYQrKkL5!Y$M)b22~*XgmEN{h!Vcs8>6XTDwan!U z=2Si^>m1QB83^)}cbzFp+Xy8fP6_mkt|oj_Nad}Mr~=dv zC;EZ`g97oA5;?g3sSfp4bTVfr&jA+qQR)EqXaFDP6{I5Mjz%|wun$LvIQYlaBk&r1 zUk6GJ*P){ZVg=%Uon`jl*C6cK&8Re?9TOMoFxGULn71Z=3p7D>HGegvfoU}+k;iMB zZu25VjVrZ>2Jc^zJk`|qKz zRy1GN3(uZ7EpxxSTs-RL5UwhA-bYWS5ou|+9zD7B5WJOMcnq}*ZPoGV@I`N2T-u%v zYJ0Mu)Uls~`Dd+$;ZOLs!P6h9V?3T82J{n`Q`g(z{n)FtN;(j%2sX&WiIZp>BG zXr)_JKcRG6lBZ`DY4PVG9kBq7VnVIJMZ8@RI9zK^SXT{_TGJ}4x2m=7C#~qnGa{CB zr=`BFTxq+@o1W=3(9%waUo-zvn&QmgmURBDvKio=`;5fuqN$_NYm~atr!c#kbz#&f zeS3U!b(Z(qiFR^)*PQw-QzXZX_ygYZ6w>)9XLjf}as$Aaz2-RJKwFh(L<@--4uuPh zH~nAZbd2rg$q%l?(v$M4s+WGxmeNZ@sNjpVIunL)RME4=SKW=FlIG3!Grj_|UqE%Z z^R#Qx(G!J@Aza?!vi~yY08J#vVG|z7GGYhZcys-^|*gm>`3zkpeIFyrGnahZ76D~^X{4|aH4{Gi?zF=2BjM^KN z@SsW9u;f*1&=1i;t!oXydle^bFrFGR30ehwwloJPM^QMRxB7^@mL219{n@wo#CZfv zXhyfi5?0+3)zf0_{qvR^J>1a;H9NXO>7u1M3U3^x^+)HliOjZ^Gwk`^if+bQt&`k6KY2d;y*mKvcBFLo~}y+;7Vt4PE7 zaS;<(Q6Tj^{;mKmbxsuf`AD4hY5>vK?5TiRXwOpAqh(z>F_Oy^tD&81fRx!e+5@_R zcP&ZqgDGs&3rZ^1iuRLzatxtTvoM|-d>eH1Pr5wTb6Jv-N<;T?KB)NEJQU+Jtrb7hOU7y2t75C-pCY3mUo>IHA=lwZc zaw|RRvx|N{OrIUR3STNuC}t*N2Y(zYZZQLedop2E6Dh$gHi(N{01yOB^a4*XBm5Nd z(2EelHD!j*#WnH@E6@UG`I<2DHG2b^DnfL*y2kwMl|9lY)lmr*{V`@EK&>tCTco48 zI<$*Z(dqOpP*2OX{lEk0yPY_r4$18Gp{P8z4A5_AQVzoHy~ zt|Dy9KG?guO1qd{S3N@J4;L7EV)BcGoqhk6$r9)l3azUm6Mh~hOu=ytD|4FgmyMEq zSy>p`{2k1dA5NGGH8AZ=e%`{?ZBV6j*Voosn8pt;Vb!I3O-@;8v+_N~bshrS8x{5| zH3Rc&h(USENs_g$p~of~y@&0AtlCTP_XtEIr3lOQJ(maTry$#6l)- zk7!%|rK_@voRg>rpgZu%KFgCI64EoqL>O^&RjOn-!xB5z zw8#qEVLZkH*rrXnCN)`#5hpla)os%NXhqLa_t?*`n=307$#UTZ^x@ik?>8_s1Ml=J ztXYlEqI+%xE721w*6o$7J_B*)z5Vc06*;Q$eLtB3zq1rrK|nI!TW)K=xaLWHZi$*> z;{Rvw&6eA^wgtiS?5{|>92cMrf&e(vmVG2y_Tjm*ekg25wWl@jH8|>A{;=0wTY~k!Y^Qy& zg}J`7`PS;kDA)g3UDEnV5A?sC9jyPbyZWi*fBqEuU(fp8{K=jF8Y+O4oqxBxz1{2N z>VNb;*Z;Ww&$9YIBY>ytqg3|!0g79Y3O|XMH_?pSJdC)GixxT)gHb@Dtmhwz>1e}X*X2Y`xV;pF~gNXD` z&Sv(@7@k^FWDAO7r>)=|44&{b`oUb+gMR&By2=x zzo7in{4b-C9sGpD`2u}fV&}fKzQhL1n5SIuHRtc9v%CWif21Zi`i0NJMxE8Yk-(?YlpzR&-E}-T?)`I{WlXpIly83&$zD#Gn;8>>bNj=Bfj&9}?g7_2)eKHp^0M z(xiI0wz$KN=MiGf#K^6320RtFDg}M&KIHT*W%UG=rEe63r=~T45}5?V&Cx(RbTNTX z%>!1FwR1`ZOGl6yjs=UCuh3^r{4lp}ySFKSR82qPIpJ*^CwCk704X=qsakpCWzo~L z*t^~Q_rkSnY*~Mt^xb9J+>BR7AkB_<+`-lkZc~qchn!342+el89nMZO3TArol3t{+ zv$14ytsn;P8kn0Vdc5XF4ll*< zvk1{7e?~ac3(se+g3BK&%@lQJB}WD78#_*tHF_5f7x+MrwzZjU1cL>24fBIm&v)eW z?MBQ0sI(h81>bAap;z#PwjLTd?V^E5%{nr*Jl}IJUgC#2mU;wnX06T6O^qq^#pbA&%RAH8{G2N zQiO!6&xI{bzUvPDnGHK|K2dF|4qG)CWsOq+Q$Vc0`OSlGOtA(W>Vn8=3B2MovFe#I zG@lh1p17PaKaL*cKE+y`#xWbw99kK5}Q7zYDBxm8abr!LM zkm`Azf`ktK2$~$phpIFK*}xB*>={&^7y4ef$nXJ?ZzLR-R^S#I~@QB4C2Fo{|=L&=(){1F~GGpJJTx<*Z1oU_WSI43E~d3D&6dD4e1(2e218 zI*Y>T9rj{~k~aO|A@Y;gATx2bB9n<08k zQxSQDisuNkiI6(1dcwg;gl&tlYNS~tdlZ3sHOaiLtWLYz?sctiggGsc^lpO>$F#c* zvep6^mr-(AkYEpEJJ9p5dKH0`4;{Qo2{tjPoI%QYfB_9l;+#E+o=R5|=-)1$nU_1u zOO675>ixQCiS|=D$E^MJ@_y0+AE|oAyTcZDi!!cF-6vOl->hzXOi}=Y+2A{D-aJnw zcEX3@r1|BS^iqo|KdL*SjY7V1Yz>17D-YH3a@Sbh?TC8bia{!uI9@f-RAhE0UwWm5 z3^mVeEneGKp5=b42J0sFoM9DFl#->8%ein`KmIB;Te1-w}lh6V=r%&8Z%-V8aA zx~GW*G9LB&LE~{MHc`SeZ5DC*>1*Ij4Pa$O2Yo-naGjaR$%+%%cz!zRd+v+j*4@MJiP zr}M3+5lQV~wDm;5%C;VgiEgxm{^Rg5DRWrlJ%$xs1YpRFoW2M+_qizH5oRJV2~6r_ z4%Yqz71RMJ`PAu$6&wP)0uf&&+ga1?wgR8fhEGxEbj#jrbo25;y$N3yzDpVA@W;~1 zf*QJ4$vkKhy+Ro8gAfZ$4)DRt;Ib7sA5_A3p2yLgkLvMZp<9cPbv%Ex9%z!c#&}S+ z!$)K~EW^(kC0rxfV;GmQdD~^XdhQNraq@u}yfgGwc|2f{toiwPp9 z5f=KJUj1mUND2#dvF@xw`$!tmIJ z3PcCSuqx|M#KUuIJ(}fW64i9}dvIOt#%)J-Aj%&j3TG$#j}# zSb)$b=<=nlLZ)&=0$?5(3FcinW;ljN?k53h^!8_#a)0@)7kIBW@ZR#kx7RuI9RU7> z=(5elC!4re8`UbxkBXM?g;tPzt&SyS!YQ$-YR}+G>XHY}_6J|dPK6(S8HEZd4cTga zy~Ul1I0cQee{4D~d3L~}$;j96c9sm2cbT%1%xqKAL6}BMwMn=U*=A$R)(D z-;3Wa`%CY=0Nk|zE{98CuD1dwMCh1LQu-;CYot72sOYV$3NHj=qtUGtVK&P&yabmI+_+A${dag+(IC zu|hg7J6Hd8)m2&0XZG{K*^hI?>(`;L?YuKVeudiqR~pm`oo9Z(8M)M!aGrHBbD`RI zcJjf5fI5zxG$`~f)p4G!h4(tHGroWBs*7jfO`bdFYg_k-iAymm6RLZga!saXf-Xr4 zD85=L;#xHU-!uoSK|UV5SSJ%>(d*>hU}m@~x35yAO5&X9(sUf-0rewMRfg-LhoCt< zz*-M0(U}NRlx?)k@n7^gHRc*4{Ja431I9UBOv2f#hbq1dMuHWH<_Ts6C2IoK6C%&% z?OB93l;QA9lZe74;8da{k>FC60I^_`pWH%H#{1>rTRt->U;r&Ai;;|xO44N0kTIHQ zNP1!RRNoLe+=0ae%U4dJ+=P~BBSAt&Wo`goVO|5a?4|8C!ueWMRl|fRHx|L3Vvhfu zdU6ql%XPP%!06~*cs_LmSP8!7BE>NcEE#b~A?}J~F)Hne3Pym$LwTQ=bCGE} zqB=HIf!v4+*O+5YaaA*w+EWisV(pC-B=Wg(D&v;Aq(J zcpIxU!8<#ho!nRBG=*;(=(fpyhl$boJC20V{fN^t?5_slKS7Spqjz)5$#a>547dn@ zx5B}2E3OdSbeLJw9*EQNa#t;U@G!u)_BWT#JaaE1t-;LIhBjL66FP6--0Iw8xMiL@ zpwe9nigylwF5M4ME5UqOQyWdB4&d^|9FJ;yz;Wm>Pf=yai$c>GC3qNPv8^Z?OM#Xr zYv6m}I&;DnP$@CLlt|8*inY+fn=UooJU^qk$<{l9;Pu2UQ}#x%3LS9Bp_r2sQ+E}) z*f3?2(~KTkn9K9PG#5+vN zW$eo8iGiENT3i0)9=f58OK+HM!SkN2)tDjp4=Czl#e#J-JK=;};b|C}@W`LfK!YX-rcs(ioHlN!A_&;RpTXUq z!x1GRoG(DHK8q&P@nRB;qQTpMJg#ZoUy1wB!tTXtda6(0|LS~vXl^3_myQKwP~U( zRO;vm+o@F&6*Em$b14k6Bra}vnQRqxGpM8uCCx}JLpbd1}>-bmFb zSa7inO|?-PF@IzmeoP&89G%SpYuBc?XJnbPw*0aVwiWodRF_l0A~6c5P5&&{ZU!_@ zqA@HWeG|>B?+NQ1vsSqo=vIs_X<}u&vt$r%U0??@QW>Ocm~Ul(j%b4%pr*^i+Ok&g zI2}dp--TC$D{Yk%boI{hj+Jbka*>GGi`-Z*D=<*8Uvdu+YedN@<8VUR<~BC4WDegWo-v()nF-7up1{zt)yD1q*ZN#E|5^*A89h?kap)&vCa2?BNerH`(!Tx8Hy0g7J8ySsk(Ah^(G4jIv(pi)G=tdBo=s5 zOXc#Dp}-GyQK~x5ur{rtD1?$-8bH#vc~MNkN_Hfgu7w4ox9F;LY>rnL4`PBfA)?O^ zgfQg>Qf*GbL2x_&oRJJ%pR?e;SrseAt8@_?#a!u<QVO_KO;L&-iC>#X|>z!#wUFk>b0vJ1@qvNkYMugh{!q9*CAEV ze1(9P9cxz|&5|2kUXgyvr?zE0?A`%4emhIkX;$L5A|nWS;ZZKT(@zCQ0mCfDisiD= z%?(?X&RGNKsx?nhTUr%G&DBRW3X-C<>L-iIq%YiUDE3)hhOvYozLR8YM5V~nP$2)MWnhxkHT8E(*(R^c` zMU(N(-4n>6aXaf(?UZj+)#J+>;o{BUw16-=C8IUifxPlD8+pgHyEDq6mrq%{?&z+x zaKLk?h#*Tr^_~I$R~KH4JC=z$iRQVmpQf%@g|GdDZ{_`#ksF18L=*V-`*NdM=vB~T ziA5KT=Ik!s@sy6Sifz^lascBGmgO~O?0+KieqX}35BJOYwp_nm7t*c%NX!o?)8FaO zHQuo;cqURyu#5FiNnbT#PeB_%rmDV(&Hf%O({?mratAES6F_>19!fQuks|>M1WS4f z_!za-{pj4`%M_lW-3&&n_*wKjdFaY2XZsf+4OZZCGBY*CsRH5 z#I;taCJ^*RYk8&YN<7GS3cTZSY$||aajl^C(9X!x4Sf9gANL*||M=?Z!)MQ*K7IxN zc>Yk`>>MXtY7AYinHEgu9Jy#2S;^V!m>OCXZ1R0^TgrwM>|c;@n@IF+Q}=mxxzRD> zs;NOFyr81ICKvduZ7u#OP3u}o0!yX_w8}&OEgw`>7C`+d|9p^tz4OeO9VLPD9s_9X za5NP;&(v}gsuE$mL%gn3Ln2w1iL$Z~aA%mS*r}h=zE;JqSOpF+6#)0WW$t@XAWQB| zb;VaY!P4l84}Dr?=OhG{__kRTOSDlLC)h?!q3Jzv(8k(rOXt1(lgE%a(Hs`v7nk5* z<2o+ee2~Wyw_k4cY#k_pwV|i9sVAhQ@Nj&`WWQH=xg}iJ`+vkHv>3z||%eukqf=iiOLg71y%#5#7pi7|fdQW_iH1T+V*dM$6jo16OQdnhxt5 zsncL;t~Mpzr2cx%+rPD4--xa7D1}7}-Po{KR-y*_6v3ce6lJRI%+1|q&@7sbV;0BgDQL8UExemqHvWve3Gwnq@yLjFHP>jP zVc~?jz3ppF<160oue2I28!ux*0tP(@V`iD%!RZw5&eclEj8Zdz(1_HL_+rK>Q&AP} zS4nHYuAcJ2Wh?i4YRy>c(p9VYTd_qZ#O2G*lmK>eoUc>Tzh-u;q1 zN5%B5knwzGI-eBNvG8YAyoYn%nc$CtC+G3}JJC&&v9=X7=olLSp&^@^&_7h80r}OB z)(7cp`pfY8s<%#@&&18I@qFX^;9pEF7k*aIFA#sYVsaqXXw1%jOs-TtX;(_LA67e| zo_1E5gZ*RfjeH?9`z7E5zhH3Mh+g1IBf2$(&g#T!B!FCCCW4s?#`+H~lxHWs{rz1d zHcOR?2{7>Sf^Je|$SB851Gk9gE*$pgj-nxmAFL`MJUGC!C-E?zi@@karW>@a_tV#E z;puC8p~jI^ACt4s_4Z$&n|fIM+cyno2Ko_E6NzsiV9h8=?}`KY_KV9e#J*t9ki{fI z@)$)&qNj#HY+L@`m8Z~@tv7@m@BshI=bxp1aPzn3*-rali@Xo7&eHUC)*iLz*~-S~ zbUOR{`@vtj@aO)X{=0)eyPf?Gez&vT-S6ynJG2&wDJ3H|G%4SgV1KLVBgQ;8> z4lSk=sK0N)kGZGj@8%Eb*Bo)*HxQsNsZ(5Vk&pe}ug9dO%rNXRG<@wC{hcmmL%d}= zo_|3X3hdb&!e@AMMK?!BUj#ImP`3>=TaBx9ZS@Ii+CsAfTFHofratEXB%IjYT2FdmsMF?4*@8e|U!A%Gk5MddFubZj+o#GT_G^$n3IER=)Z z=YXw=Y_hDL21j06z-37m|Ir9l zE}CH~FNQD5-a{w!Q4{MMCGKXyRy?IevAqdv6bdZEq4~;>&|QfzB5~1XT!dHvWe72s zgAuBP-id4o8*dNO$UwV!9X${)Hf2?JSmYi7hd%NcBtHuiSLdK;#V1RCVhD=bG);jyF` zZ5RWyWcktxR5z^lH^eV<2n#%La3Sp`H6y&m5SQLu{|SsAd97(6G_puE64iUstT||R zr7Z&=iYq|PeUC9-olk$bm{A^^hAQTd)gb7yP4QwXTZM7IT-StdbLGfvEa}kR+#VhU z$>Mwv2_4ViZBGSLH_9do3P%F80m)~P%9(p&)w1y%%|THdM}n1E>wFcdfRmC8CTlt* z>l;P^aic0a6TDK(ADB_l>5jVfg`+s10(%qlGW8*9N;Ebm%@f4f#72a7-( z5>ghyxWhsWIrHnAB2t_z7;Psh)9QYLqQ+xV=7yPZ^@9#c{mE^VX4?u zCu|B!b&9BN<*`9;VGb>dzLL9VJir6~4KPG)UkUC=`F?Q@!u{mpe2`9>4N&aocq@v> z@#`#pL&*{J9o-vKhW|93OcwgiS|gzvzG*BdPU3kplsL`_#(xvBk4uev?I^(@-Mm)ds7AJ01l)&~!u(psKFp4aBYwkfWe{E+O3ZiVQOz-ozXz33ys z?{k8CC7Q3bN{W;rC2tfoF@uzmJ_4>eKNGbDWODpK*6L6$1ULK!J2&T}45D_=Xy?q>Ixt%JsXll50Vg4n^8T&gz46kFgJl zS?z^=j;U=OsL^s8ejb9V6`Z8`jeRS%9-m>ePrs9nnw}f>i#oM4- zy-Vg3S!BjFA!QdU@vh>K{>v^~MjJX{|L$JIKcL%8mS*_t-##beAJMKSY0 zp^lxf2xiG^O_`vIxEH zJsO@}?r^F$S&*w)W+xoaMI|}4N?jHwPUJoiQS+9sa_Q_xI}7!`)>u4E`KoIdtV*(J z92#dcd4rk0i~u5iK?;R|x?ZCSLYk~&JHa5cVr@TFU&7@3M?N4ELaoZZO38{&nh z{Mc2uMWcZ_n_)U*Ni-5=I_1P+Zv@-$@~kVdX}ul+x_lv*j<_QBgEFgFR6QhH!$L1^ zP7nsCF)C0RhKwYj_=6-ho=4qD<=2q)B9d-Ei%Qd}|AeHKb3_85@FaeWv!!RKi#VK8 z!%YydU`m2u(vNCTECCb)3!Wf=FhEU;=wN_-{YE^CkqVg*Bp`Sr#k|A8&f|$#R{>fI zIQFV9^ZvY3R1{~K;Yl;~b?$hl>Ss;jaWs$5Bi0cp7KYM82~`Xa%gnsPwk`$qZuH4= z-so@jnZ?nsL;t( zfJy3kfC3yPqw)y~O7v}~5c~eEt~`3vW;D zUJNIsLkWtM(Bv_*SmfL0^9YVQiL-MqekIvdE6{ujv$zDKqV5bPv(i}gilQEYeZQis z1RBDjTVaRF#Z=r3v3S=5JoAw>rL{9tcg@{nDYRtbs1Ope(zBAMv=M&$)i^vgkt5q$ z-8joLCRAD!>= z;(}8dhm*{&jfyC*UuePtEF8xG)GQFY`SZwWIK=6RBla!i>kBnn*+rz9iR#Rvltct) z4!j8+YL%+tp$)#hVzIvX08NK*AB%(-rJ1oT~-DP_((_-NspB)9Sf% zUTwkJaG}J^3=k+{Trku!M{FPaH8|4Qb~a(Gw@AR(Im}#tUCr7Pe;{hfsr@#kp}O?E z>zS99w5%Dt&-r$IcaA;+Ibwp+0y^i_#;A@(VrEb0!cHWUb-bg(I5)4a0oa`YMn>t8 zor%0l@5|O3CUq!*k-2`M%z8%^CDz3&t@_fcsA#spOZ`aqHOT6W%~rU7Xjp@~C{5w@ z7@Pa#woATZ9d~=SNRIi?PB56KIZj%{Gw#h!TbP^ylgxZ)gfi8fpU^XmqJ#eN3?7`n z(NGaRjyu(L64}@E$|m=Z7#7{1*rUmPH(U}+4O4jEpfyF79nA7=*oAt=_1Fx9T~yG02` z>X5veaGLG-rRTKbnPmsHWey{CTQgR^?s zDnHwDSYqzcBk^E4ZsY&jx6aN+#z7I$OCEU4+A}UVQo3ilC#yxdeO8Tx)v@ShB3?Xa ztU;?eQOJJh4m$nr(0kI!qHZ zeBlYaXU8)*47%VJ&9o^huF}i^8)0B*k5bWPbirk_KT;+?Xwmp|Y3zm*sqh_rW#W@M zh9>EsU3oZ<#~FqAL#7F9&l!jR$$mKV5Syr3??ZauLQ@_AoR_^KFYZ1?=ZzorQmPRp8YB#^EuyGG-W2m z>m0eitQ98V5%iG^`=pyx0iceT4MVL~zD8q@QEh#ohcs?bB$EzuMu?X6$|c>-X^Lmv`@K?{Dw}LOTi?n~lq(ek;HMbugkc zL9BEik4~chfZ;ppDcr<%y-?@;oIw;e3FJ55cw$5YV=FKQU8gGtsvy6eC{<`rY(xh3~ z!pAnw;jl!b5A>ssBI=2g%vC;ytwi1legRb`=Gv+ZnQsk{QKEu^F}}!v;HfZ)sBWc7 z>6pdYYn%sPsYNqoI^AI6YNTvW>Xi6it)UQw7J1OU-DmKUfB!@#A=Br zYD*TV7ZfWgqk=s!RqPF34`X17up?ExGnO1wT89Z)?Vb!t0AwhshWen+9QX>4ZV5)x zo`PZX@2KLF`P)d=T-4PgX3Slv?WV$#kX&`}R>;J_4Bp>-9wVNlrXu=dY_T zyrEpBp@e3huACMfkTt2}u`+!YbF85$>h)M^rnF2s=64eRlMd7bQ-c1r=?xoCnlNW# z0R~Yoy`Os9G|K?1vewQ0Q_R0M?!=585iFSUHRR@?jwh!a&$IkWII%)DhDv9u$}!hK zpacWs5Ue0zpXF@>GJv3e6x4u0B;89T2hGUSC#vRD6=Sg97YT3LFT_q2Fv;hE+a%@EL58byEjaJ*p0vt!Hg-D z;gR$z5MN%c%p$b+N72kF%3=btauL*ZkLqFo>&+;SS0ko!_F_>J>9Mp7AWJaa!5FV3{N(YN+oP+L6<5(^-mUDJgd=rK zkg_F+;iutf9`QvcC1gf?S_{)qIXOgNv2`3Gi-j)5=-!?U7cQo&3*(61CeEchtdp;7 z-kx1Z6To*LfibKg`b@Wuj&a6hff>~wMt1^e4jCZ7<9(8e^^fdThf6`A`{m<=gr`yZb|J?0ucRttu zyzb8u^*{Uf>G1oOlUCNDQdJMoa*W?aqs>W_oC4=&dBOhw!NnYNBz^&<1_8<{Z&<{Q z0<;l(HWjQ6mdp^q+&Wc5rVt3olmEE$L@U<$cBF4YMr` zeM8KL;)w1jO*9rlizS6j$s{?1?Wcr6h+>7haJB7?K#O=v1yVu30wH>n%gMOiD@jaw z4lE$~bohGzZA39dbUGYmF!!I)n=qb)j%hFQqA7;3B_ai~ImN7?vw+)jjb!ytE`~k1 zFyd3-6-?6$6M3&K3gE>g$HDX$7ysTevhM?)rMmcLhDHTszX*&L>4;(fjArTPI40k? zcnxq(;58U9UnuboP`V)9`Jp!GGwHC|C1+M1ss~a_JS4^<OBx!|W!ljFr%VRUjS$D-Mwm_Z{GAW5%G z=9#^H+s^hqPw@7&>JY^;WTh8Avlrb~&}#+TFYOU_^azN0P4(E-MiBqK4F30j`+wNs zlVDb!TqUK!Qc@V~3i-o$`}*7mAo!R6@~*e{ZP44@C4W%B-S%VzR+yYdK?fki_x37w z-Bt8<_hB8o`|aIUunCX1f=0Ko)S8|@`)TuF6KFf-YeIZhnmwX5L1X^E{(ClW90`ao zI`8&(T0!UCa2x*&5An}^`h9=rWzYn~Is2e->}|-`yWKt5x3{*ORay;S-+UsGV6VW*&>@=d6sf5k-Z9g+xPv$!e&npT9+rFN?>2B;{US~ke;v@qHaw+w1zzQ|F~7iWdZ{d`#cR$mR1lW6m z3L!dJ=J8yFgUg+v4V6V_kZnkKO1U=LP>--h3zd>mIyqO4qI^5*MWS|^YnjNytXJlh zQJ|&P5qWee3k*{npbxwWG@!TIVrc*S|Neg)SZ|lMx+N(^$9$RbehjNUPnqDG@?l?u zSkU;PVJyg*+kK;O;={!(4VrzJNPmN3PjwGsv5%z7!cIOv*}Ql1;P_bTuQPUqsxlI! z!1aI7b)V&uM~Z@SVOaZ~(hedR{9ZL#x1BcyiEy^N%(s$tc~Yn#<+^WG?h1;B~# z`6k@Q!q`#|GpoBVIVC?9iDGK{1$2+{V0Z>FnS7v*fT2yf+!6TJX^pQ7kl+xNbw^ZP z3g%7)emutFA0&P#v0o?B2S(opSk2nPb9$aRv>Xaf4n(grhqp3aQno2bL3; z@6<&d#apooS1Fo1YdF?q=$6fxQNf}4^WO!aqkz``onf{8LAd*UON6XsKOC9Nu{if# zTL@OE%<*D^9+*ts-@PzSVGV9f1Nw%GIMWNj7x&-c)UK^7sZhx)) zaXNU)q5^9bboHuJLoGtFE*xn=9D5|wS0#fHAy<=JtWKRpE2R{(DP+jdj0#_1_`^G2 zR%w)Q?TCouvJ0P6)B=w zBOgVq>xY?L5`-LGo?f@hp&VX{o4CgCiqXum;GY6_MrjF*B?`|);v=fZZ!>dE&XQ!Y z>aYN93^mg|9U2EGEINYaz5KZ0k@zwNpK{6lWwCu0hR|JM1wxMsjpsbR$; z+=o01I&Dc{jk%>3!rW8$0hr!-9%JuqayKz2m6=Rb9|tcKbY2JD3xuTNi9AxW>4Y{Q zf>Lqpe;fp7Q8;Y}dNA!B0bqFLVa@3uw;#r={)vf=x={>6?Be zKE@XUvuL-U$xK&5PDo*e}-NyJdO_hIJ3F?Q25leXTU zkil$zRsQ1KyFf zfIouVHho6*GE{#moC9orV)di?`}F{AUeVQoQz+gKgt1OKNt%#~fWs*(-f@suZP!5K zsrZ#VZPRPwBg0y1zXk%^u8UOa>R=(7WMU=?-5tn)EO|@8xBmT3pF#@yz1`h@Zq;;b zGSt9OyRddOy)Lr@blia%TwvAv^`3(hKg%Ch2k(@^wC?0_PfFqt#FofjS0emC43ygr zbwBS$MReZn_2?ph7ysPbGybGc_Iock+-chZrrwp@3;O81qV$ly-fLBmNFJ@U^f78$ z9QI5FR--B50uHBGgl$Ik^vKO@t_JY-O$gs5)m+ERBkRCAECBzqc?Jgzb~Hn6Y~=3(?4Qe4?u$Yb z%zE-h$%-5&*;QyN9b-ybJde&Z$q=ZPUCp^mM_wOfD;A^xcApM@?{hS?WSFg>Pqn`L z92EIB&MH-(b%OV}4 zqZJ#2mGyQuN?y-PcqOVj?JfwbZYct(Vd31V6e9O`MGUw)4oMR0%TB3OVVBaob*NOH zo3&ifs5RUM)H4Hx)Nx6+(PUn_kypNqh#?PZEjbAK_SQWHEM%){B|aova+oWOP>$w@ zZ5PRN?!tQ>d{c#=hi8#hn}k5PbfV@jUpMZ46huWf^6A>-BSW!ez&uk6>kw2$NJcY@ zpld~AIUPU-*rOt#-8PuS!rs=liaToaSnEgu;i0y80F13CkBqMFG$fy+J9T+Ir=7bZ zAyeiAap30Mw4}%ibfX*yoC_TT6Z_JgPC=I1qpspCkL*z6t1;A$&x?L`(7J{@0{! z9|iQc!0t;U=oQX9_{N1`{s08Qun?m-<{NEG8AZBr$*9&Z z>sY7hfrZg>7J7cn+(K5sNOR8MR!&w>3t1xq-9X-coT(7YLZ1dIiifUG!?>nn0m|%$ zD~%5+QqJZ&MOSt&BsagyH1ra!R11%F^9&)n;(1nVM1MRN`1cN9EVmmZMgluLJ; z*bUhZCMsr9{{5tFoB-lJ_VXzB-;`hWxq)=}Q=%O>j#rkZvFfRYmz}T&Mm!t(Wks@@ zd`n-c%U+#WWEBH3P9w_9sNg@MSP;HMy<`(~zJlS|;@k=bNuh`W^>Bh6(V3JNKte#R%$|L2dxs-J!~-GlFWdm(MfFi?c-T2!F-9=#h<%A+-tmWe2F{=&}mtXnUBP~SS$$WBft z#^Dj5ka3VUVHWw0wrbi{DYgYq=M!RgN}hJ}KbzfyqNj~5hnH|(LU{o_0>`!fwJrX& zjAmpEP^!7?^y=>1J-s?+JIxn3?-tFM{@i}q3d+VUn=cMfI??Y0Zgo2PzjnL*eHBo# zcgt-;4dtwF??u@~M6jZph)#RI-7PYFi9#L;GBI;~-v1RV0~;QuOC#2bEi55JJomXW zyGLW|GYUQTv!%e2ID$WsEo%%?ad9d36W?`jdi4^%w-D_rS0m{;EDcNcBMx&GAmVYK z!aPMeA!(dW7qcl979Iy#%F(KH*@IVn9#*96aV#hRI#k3>-&Ap1qV^$A08zBJ@jY1HG2{6YubD0~673Z6H3#mi;*0=(VEO>Zi4qkSuPD7{eJV!IP;cZ2O- zu)Pg9qdpZM1=~B{2QNKtJrzec9fqW*er;-EDWbi*(zEG2N^7 zH@oPk==4d)>f=AS^gCisnmFno$J*kC#95lOgAl&F3Ble?Aj@K zxL7B&XtN8tZwLPGUOkKeITS{A^<^~|RHQI2nlvb*DkiBhS_u|+)kaN?4@x+$xZhn? z;w>%kI-Q)ntCm#9YPYc?5awqJ7m|<+Dv!Oblh-d1{jzhc=`9`xy}tkO>C;!okN<4z1h8Q~UWJ+2H4c(^2p6 zV(|0-aTgQGg$sE-$9WL!?FM^8`fnWcI>G)v{<7brPj;?wz^a9V8=5Q98PB6ITg<`% zX8BFhx28*(5_`~}@TO2l#hCgi0RXbal*q5au4KaZoYRUt8^u{Kgh$+7OuEl?_jmG` z)6uH>pgLebYl&t^?oEDh$4KC0=Q;WesQA$!Lf3>sXCq9hUui>D22Lp^OBWtOCtWVC z$coZNe;0O>pXK}jrZg?|!Xc^M?YuM{d9aO}s-}_cU;_PPIe(sF+R{dIhNY$_4z& z;M%X+W)59uAe@i9sd^u$WRVzobxzIZd~^(eOS1*2?U|g0XF(L^jhbJzv*#vdhE?OM z5<)%M5H!{H<9@ygXQ+5fc@cJkgF(k|tT`+ZeuCQ>&P;z*c^DWX)mKiF+iBZJ5RW<}sz$;RhUKP6;acvZU zG4bngxe2{OxOsrK+tMO8y9~EDVe|O$ywAdk=S)e!N@+NDn%)POR zCm|l@dQLI!G!zwJsB~xMLu;d2s%j-V6zK*93a+@qSu!Mi1*)4zH!_aw`gw4-LdyZB zZrlnQ>{ao(oaim$R$Ca!yFGE`XY*@CBIHf?!NzVing?(WE7m;c;C#F9A4ykWnrEnK;=MVZ z5Mc+Ek#^86A*sWCwmq&7*V9jVFVxfX961MUJ$hGMs3!9<8W}IJc`u5$XcC{t;v%0> zNwoKwVV@o<4Ks=G26^g9z{F)3^A4;)8Cl??3Jd};I`uAMsCC}q?uI!AXVMRinTjWtJWDq^x zuWurF-*FWqxUA+zCAb~ne0en`R+6gf#FOX^%A!GBBb#YG7v_(}3A~OXK!_PNz6gUc zkfw1I#Fq+kVeOt0FDfr(vUK=5np3BTnJE9^>-4}62h8Z!actu_$=XHUHUxNv7=-Yg460#A3l+ zho~vv)`An?j7e>fG2ce{UG{Wy2^sn7EplWvd%JtJd_r?1RSsHea{>M0SZ-i)OZl1l zU%v<7BIFvQx(8N?UQyS#LpiY`JS5@K^?4mGV1)F#6E+UXPkIjI`dl~!^zKhQn=Y@PFXv%&OqJxGcU5>S6 z>&$_gFK1JHee%rD5)GbH7z6EYQ~@Wkr2`|N9q7D#w6Y%xul}gk<;>NgPOM`5D~YuJ zG2+7aEI+8~hrr{U_)^#5)q<=~sH!g2M|~;fb;DLJ?Z>jltjXx56?fLhZnmW?EKehb zoF$-2x(iE=@|UFE#wkrys3K>xlerU-Eh{SP6Fj3lxh`BNKEVRX#Oh7XSWwa-O8q|CnX-#hbV9F8;afIHWP`))=ks@#O*_ zbpw}WHl$}vv^v{&e`mNI9`0}N?<@gUuYbEDm-v7E_xfN}fZi1$UscbjElIgVV4*-J z9*t_pGnrS#@`ejrq54lenq)yf?^91^WT+Pfz|yG+D`-+vYz$k;;x|!61w6Iih0?AS zl$ES4D3(#0b@ca>Cy$M074lw^WmE8?kKeZ$YCOJZZmc5>569S2V{9PTl`Y(;NpW6k znW?*UL8RWMeJ|`eqhRDP)FkhXzG$eIskVheuyUz;-O@lLA5rgIr^745Jx| zK^aRzD5Z?&{a2Xs{?*Y}JlU^WU!e=`tD_g)RM+i7fvsWXzW(d zd>vi1Sd13AL9Ik??w2OIrqM@jD#?5I?%klllWYV(_#A-dc8l?je9zH$c{#n*zT#@@ z1$%UZPA}+e2c4auvs)v&!z$q5rrfx!kLlpZQ!t2I0>}-^7XspHQL;9U{rzQaR;a6+ zaI7plxlpU8$|RDZP*h>`4&=|osF_K&Su0=4BzS10gpeI6qwfu{8-x;_Tb34b@BV|O zvO;#cJH4H444)oHUOC-lB!ca*0%Z(Y1=3K=s|O1nj!NYsw+tbAqVmtQUM2 zW{+2=6n+r}fHX3S&nFfwm=iIt=y2TJgCwknN;1zGoE3wU_<52#8Zsm6+U07P z9~a;8GLO}B8#8OFoI&KwnKD=vtZOru|5*mCf^$^@>n*X$rC?P|tQ1y0?f5zwf;-({ zrx)y)>4Ea2U}wktRDN`Yj6t66w#a|1lQ-z|m&t?*P;$9`t<@iZY z?qG#CEeEtlK0O8wK6(D^)svrIJ-zq%XESEd5MYGY!FNH&L3RE}Q$p~)Xhmt3#^Iz| zMGf!_|8720ehXiywu!!%tJK((qsdsgbXo})lS7T@VN$RM(P^BR>A~gTVL$GQ9WxzT zH3q^4O$O7baB*oToIbpQRmr%5<(H(6IOm|N8e+M{`17cFlk7}t;|$G~QgZ8!&y0P^ zefrS$?k$mvE$ZIujJlBegc{yG(Hn<9G|sveL|Eup)%)R3MM$57@g|y0!l?*4t#y%Q zRuVG`6vE-G$Em1C+k!DRWIU#!q~j>$@MNi3cEv=|i<3#9ftuNfR6(l!d!|zhTbNgQ zMjQvE`W=pfZhTp-p?^$QV=|IZ zlpkUHv%5#~4zZ+r$gzc7ltjlr0IQ-ah672qy}Z~ELVJ24BsPYHfXME73LU{Tyv0g# z&P8~TRCpv$f}br0A(ty=(96cPIQLZCCW~~IUWIP)rTD@7z%R|8E9e|+E@q_@07$C9 zd29ZgCXwWxTpCR9&}mFPlJN@xW{7jFMVZ7{9dCig_DUeddEbMrekLUS~vei7rO~6*8hiV7<Drt!BUQa z>h99ZcX0VQ7(8dTUx)?<@Sat}-iV_XTPwt`n!RwS`&v$h95hQ%Rm!;uaY^A5CvfDk zDj{6tpOALX+MN_)pvsyDzaU4t&}pLvQV`zp#uDG+!xR`H%m|~wJHIsm8kCg)a=kxA zdKS6_WGIxdTRwE*V5^c5O_Gg`a56m$2hqGmZWmMuSlm+%E^i8&VyNPIz^iJ~xox^~ z#o^m(a$P^xS9x-54*`XUuEsYo(4~7d8qsM3*%LMV;p^dzYJGZ>bqBKf#^rOmKIp2`)dsu6KTAn&o!8 zxG>A@R}+LJwyxv%%*)8k~mw{!ntv-7Ug?esd^ot@5ZXRov0 zIY^dGfAyN)m65kWXD{gN2c3guLU1uPzYX+{4X1m>G{bs>NIGPxA`f?s*`4j+mjzaA z0GXAIFOGtKC;0BJG*7-`gIc9u9uy}_D#V@w{dqIV>!(i|Crz7jgrow;B6Ah5;H$e5 zflgq;ljt*zE>EM6Zk9$5h$#1nKzE2(fn@8HYyM25*QL=%ADBk#3(;p*>JqxF(YdDL z4n*NBa>2+IqW>1z5R5d5!`oO4bvfF6t_3LAtl=0S48vhG4oA`2h;xM1t%5NYOu}D= zSc?-r{7js32J0ct=c|^WehtAyz`O0;)$=vMhOWoc%2`@zvH;IQKjNE7(TL`2FzDXRuug$Bg7HX~qg#MUPi-ZP zlm{*0p@++{P^RK_E@E{I)vyjfNp5HQnzrrjPgQDCLOP=T$6gU{UbBju*| zKLj@|HFvMTP1n1KPeeVv{eJQ#7~aRFJz_HEXO4FZINsXT$6Ka(5of4k4DK2}F+TAT z=|!LU#O>h|>(wc+S$t+1IW2?WgT0+iAaF^6Ogny#As4+u+Xy>a+}f)q{wmo9qImRq21`^tmGc6x_9hkN_I!`)mO+QnBYfBFI zXxGh(KOgRrhkJdxwd`hBeXm2XR18O+N+xAhNsejD$2 zRq1Rlo6RM&_wdjC1N`%lM0z;5ngEwq!Dy80{EY5iRo2vDXa8V#Z+oZfmS?`Yk-fa7 zoF}L?8_ER(R@%vVvK9NjK7YR+WF_u?O&u$p^9^$zQzN-uT<5mh`s?F5_m}26rXO*M zQM&a;d4?4vv%sw`nPU{6`CDE7cK;^$+lsC;H64C@{LNOUT7^kEr2D!v)a>u-{O*(B zNmo*YHg|XS#s~Z1;cyTwU)ujOr%?O;@e!R?B|cN!l__rhO2ArlfYO0FpOuZ9XCZ5m z+ot7kuyX(96|97V+h`5y999b zXf6f3cT=*yIBNT5I7YsFxSwOtuB@18Ak3BWjq6RaJbdVu@QshdpLiX-$e!WSSi|t!N7`;bb4(Cd@NXTfuQ+NjRm%3U!O=mbNN+K$*0EaYvb@L zcs(Pm%j?IJ6!3Kw*n88_AiY+w-3oTDhE6}>vTLZ-?cMFe!-K=U?#|Bk;qLB1w7H$T zf+>T)P7Yian00&bSMJ2h@YmqMe`e&Z=7qiX_QC$)_F-?YvwPUt+uH`@UCy`p5n+ByKbU+2@Zg&rMfPZ#!(H)-*!qw)W zv*-;NDNz%?o}a~8B{m-G>;{2xbU{kJ#c<6k_}O-xWz-iadmBzOUz0%GsUV%% zoKo+D;(ph2Gm4j?d^?JN@C_;c!MCLN$MVF`U1fK#-1$(`O*p;oUcS%tY9`jBxp6Zi zZft~2j;bbRwFWKT=IY%<5QQsrWR?dNYltrQi6=>f(|;2sFFAez68q9l0!?5EA{o}&aIDT*(&FgdzK0-`~I5V2E$ zRm{233L1;~xVtxr@+~?8bNjxfCcd;s-2YKaPO$QjMJ4x1yrmJ>4X` zu*RR$l~K&JcHhO??AP{aeMt7Z^O^mwjQwu+*2R8x7df-L+|9FJ-wId4e%DIFIO~T~u4I59Io(*0;jdQte)Qd(}jXlU`rLRuRSZ_PnS-PLnZSE7dY;@h)x^o=(Yf!JILEP$+VKud` zY`!b#Hx2wIk^mIXbeW{>R;tM*-N{xpFmeW21Dm{kS-RKYlpNFeZWM*1YJMpm9z@aD z#|>A(<-!qm;*5ZVm+HE^ranhE#O3m#W^3bebcAbWbSq2XwMg#6vOBXy$a;8PVRJTj z{x{0%Zd-=ZwOHN#Wmw()b+bC)bHMEe$n8F}y0x&nqP`-lWOb|VueQ=z-;`!&d#u-_ z**Sx(f!*D{tm|vAJC0?3H;$swI2=an>YF~KUg>Z=<3EwYmXC&78yBNvTr(G2S?ab$ zNgtQOwmb`4USYcl4)zHtY#e94b`CatQQPfVU{=!*MXr4FoeR z7xF6Z9}Mo5)5-h;RIwI4hLtFjj1(DAP2HljncLeAv)U3=9E>yH%PmcMX0zwJf>;G- z>-4Umm3_V}Fd_IGR^Be(dzpT-cGr8s2$i}`^qETtWD;KW&UR;KT`CR*82ovZn;UX6 zt=gS_Z9C^PBPbi{BVYt%?{vByuiCH@Mu6c^pBceA7{SNmwq3i^wqS%mH7i)c_o1D) zo!!n}XTNi>Hg-@PF8t{-g&T5xtlD?GPA}+Zj_?t11f?9T)l$&$(w{lPIyk~DQxgml zcfl{^I0Op(d-x_i8P4LV%zyZ}X--upc{hYN2jO6C7Z8I1-a+hy!OoI_AZ1z2pQ%nz zojk`|BZoheoCClnx%)Rkayw(BH=w$~;4{gshvaUVpz~_KdHPvl>dr?&od@-)Q&)!R zZMS!*Ec{w%bAKNX=WrZ!!=N_~Mx$UCq+{pLM5p;;A#0&ib)vUMHh!kk)lljEwNvR% z2gwqMvqyw_h#4C|x}T|ZO;oxBc5poA=rTpC3495Z$|X=S z@BB1=6D2JdKE4zs^B5kIgG?rPeq;DM8hwarC4j)VYO{>1TKT<`2gk?3@C;CAI0w*; zvqlvQ5ajA7*4@rV8&}!{K+BPy?vPSm59@5{pK7YiJ)zm?FpXwIKn$P}*uMn@NA(4L z#^V6}d9n;aM$>PpT?Q{G2J~cbllkne;q-4J*PX=WkQ7 zyqL@NR92)g$-qZalA``?(dqSijdJo(q3H)f*i(PjkW3z2kYoT8oQH9OD`Jze=N4y*up_|Jc0U8%F^UCm*_(EP9FFja$yavA1XuBwp@^DtD6`8T4yw`cM2 z3|TTE)Ed;G8gM}uxT`gym%(qKR#O#^Y@SXD0K#Gx)l!lEGn8S1guieE$ zVF!(uv~Kxf0JGGRX>95GLiQA@WXl&Cp@SDn7XuIe2q^Xb9@YE#qevBN!GuTFzj*pT z$dV-w#Rs)3H=0YWVhndoIb3jiHXNq2kvM1+Mw*kWt&Wqv{5_8WcT8CTXY!)2_oe@` zc{ZOI7pulXOr~icA4BP4KbSp|WpPy`v(qXpsTQu0x2H4h9c|u!1Ptrj+ zdG%!Qdo-M9TN?U?UX)ZT7a8620UOSQ-Z{U>msU#Yau6kH7)%k(LB4A>1xxsG{l3M3 zsyX@BEKk&(g3}M6uxyJ9lL=Z@{Ofmwl3hnpxzVD2b5YbU3)2fsnM0XRJ1r&oDy#{gHsYKIFIIM>4@1MsjETQe|9mA z9?oXzj9mwoY?hFK6H1n8S(U6)ll?@me9B`4>u8uCZTu8wkru{Rec#`F6@y+-(_aL~MS022&HrTyvR?0kAUVs;|9ZdhPw? za?dA=$z-`VUcB@?zbx}a+wXijzmUcPY%Bj;w~j*P&S6E9D9aHId%d)2)ofU;Sca3~VuHRH<~GcMN3uwFnMLbZpROR2qERZubJIE{ zLj)#00y|)K4tUOvzBmbI7qFdRA7sEX*m;<;OcAI;ROw0uVkc_BMRqOP$ArrgxY$2BiB zjz=h7;n1aFZ-~W~@W;^BOv2)w$zZ#IKe@1Hp}s8i?e6U}(}a$3Eo%)o>UfnFn*~rA zS7ji(`^&(zwxOQ!w%h6CRVG~FvM$m|dVSN)cM`2&_nN)F{ZMz7oa}A1`mB{H zqfBWsSGUcU8*p>?>bB-*D{vK7;JpM?s@drRvkQD0n^dbw2%!~-4a{CgLI3?F8-xmH z;2RoAs6~|;HC2MCV-1?9vrdc980WK9xKgXo5;=7&L-U2TScmH}3~h5gt&Qb(J2|iIXPA+e#*0oC!#hVNTw~Yc9fEU0_W^t4? zH#UOz?kj=CLh-FU!@MkJ@t$vj0K29i9=!B_2O^={-7okOYddv%1z&ELeTj`JI^BXV zcX7;}+?OQ*Cf#C)T4k@rcueNAMJ{r&7~pEbUFoiSsS&EYB?xSFSKejIs(a@>4ky_)ckn9r-pio@ z;Z>zu#k-W!u4=yiOn)vvKF1F6OT|(Bcv@EA+1pUKjSbzYPy65JER(l!mNOe&54t$r zLIsJD?F!1#AO$oEliRHwk$U+$y2yei2nZmX>_fT~R-&rFYNV!u3#*}~z+>0fQgSp* zpXMCG^l2_Giay=;ewy@U@f=-Y1Xd!FXP+Z+tKurjS%ZVj^HbV+yU^Xy*zz z=TI)BM1^oMPtQZTznWZd4x15Ni3x5Zz7dlUfb+If7%Kxik?Nd$?6krHMoJ_2TuY<7d@@yV0TgM;0}&8{gjt!Yt0Ee_ld&ch4Jr%f)5oYzh5{sw-On3o^c z&_(d?+{u-xrwk`xkZ`#SfF{ZGf8xno%?iF@hU3t_up~=1G%3S2@;P(8BRXr-H-4WAHmW zMU);qMIW;<|D5*(rVA}=z6D@cY1+ztx=tFx9AGLqaXpt?^{hd-RgAPvrq|E(dW-0_0Cpv*-b;kbrb!gi-Ka;SgLxX3(dgwD zmtTyc;RLgF&f#1qQP4{cY2-fZnp=Y?QD1VJG)6PFWN#tFZ$DT8YRtb88LITwFMCN$t^I6 zlf^sy=jJp#jWYagdyAfLZ@16p=M!n?55uXL9L@ngn9kz!a2A`gb-A2G7wO&Bg?M#V;D0lQRs2+gfC^ z#!Gq@AD?9HY(7dC^L7f4A}@xAh$n9ZcfUsl>)Mume*P%<`aM2&+2?UD9gxv%Rtsc= zL1F|Hek%ov(1sIGun-(d+rk;rz64@lKs>~ASqOq8{MYaCFMABOFlng!AfuykxR}ga z!8D#m8T)o%hH-*^U0#2mH9s+NuFVhu5f3JDhPU!UKR|$Z*qCve%#}JJ=Y}A->5sbnP$kgHgrZiRq&5vUVk zTy&-@P|ygpS@=DIfWJ}e9z>{~zyR~b4C5W)D*~hk7);XPYZxbt=Q7@jmJTbBS0kvJ z4k-@%923p)tOeo3gzT{y!cAcjGTaU3$6FC|05)v$WYQ+Jg{srM$0fz-QP7A_6M)?a zF8isdr7$+vLGcqv{-iS}+2WicSrq>Pt@j*vcao;B7gHi(M@8dmI0QRuN6DM^ulJt) ztq(@Pn|PKc=#4{IZ-DBlK^xu^z;`11+IqVmq!dxt4xY$c0zfc{0U9)K4l2+bO=%2H zVDX+r9$BAWY03G+`kyE9J8K;XjOvvLJeLl*D~K!uVqA!Lr`EhL3fRkEXIqawxmBICEyFg^mGFsCOgK}tsQ8s89K1DPkj{W_Y|w4{g)U)phXTnsKFB6t zK_=(%=@}*O&?9k{p{v>0T=E->U^F^rj@Xp&cwvGrh~AO2aNU~eB;x%O@f|dNcpl+C zv|uKH6k#TggIM3MfG&NLbZm(x!h-2v;?ym^9A+2E@C;5aU1XDs76OqtOq@iLn&g>a zN5TmMT2I@#(M|xAmZ4f%FoN{tmmz5m);0#=1V&Bh7M0H2 zJ`sF8w`=X-VaW78CxK&uKq`u5Ep=FK$^s3x0-m>l!`kw&#lr8%uaF;H9!Z=CnTzvf z&4NCV+!rw+P86BZb1fBRN&6<`uq}qk_krX*2#2pVLLgbNc7%(e5MF0iKgE*>XU0mR zv3E3Okv+sHf$HSk!fP?<5ol$@`Q$?3F%v&M$pNRl-T^6xg8AB00p|JI+#qz8_>_h? zd6Qz9rI2<<6>Ss9L%L3w1joNVpvf%~U~#k&!!yM5iKVL0im<@XTSBS~t1!ZB&tWW7 zc9p9`=rA}u;cR{r>ClfH%6b#cGU1Q0w$zAbM0zWtb?-?nF%TW>5`!s1jb;?#h<+*L z@|og+>Z%UqA022$KBY_$v^l3?x}cgMA&3^`%Ol-KF#?eO#|iSE3pvhN`WBsLEy;l_ zK1EzLBd;IvZmchY${(<8B-L<;0!qsI5S>6H^b`uMFXUo84qtl<$C=}4QD&3NUs3$O z$Uy!NBYll}3aGXiwBgAuG~$2H=&vo<<-yjQ?g2&ugY`6U%=+K6jW5t8T3;@(KjxP=T9Hmk1b{s@eH~!gOdov@+AHz zP5iEo4PohS28oDR5Bx1Yjgz?rBpLk;h?hXXLfR)l2ob%F|A=O9WCX49i{Amv1e{5R zkFn69EM7?ekp;N#*c%hf4=Yp>mtK33uJ1Ox}3ZN3GQ!1ZMoY8qF% z&b7q7pf7PuAXcB*nc91gcGbwF#aeU)aEuYWwnm1Qn{d8^ehI7s7mOd#y-Uj&MHx{T z5F96F@Y)@vC81$L^94qQQUpW@+3%y^O&n4Q(dI_k^o-%)eTiRO(2R8w3H3XUfA48DjKDlWS+fB4ZTbxLJD2u9tq77Tx}tN+5f+{F z2caqQw<=0mBT=CZbuFUm-8@l|-B(Riy_;dlG@Dz5I^jf-Rq+JA`U{D(|zoV0nZX7XYitrYRfFL=V#x9fE1X*HIR-3tCZrIPLPYJu2Ei zN4gV`l?8}r!hs-?uG)TGq~#YfbcNxi6jH^*Nd{E>CX6S9J7MNgKUyBnDQ`w{bkVX& z4c!*(Gc9B}qS#7`&I#OFky_Ex^|K}FjbX$t`lx9R8(gqF8ONu1TR}#<2^e<^?D+Q{&J=JJyG9C<$$F7b|#~Uo0a=fMsaNWd6h!tK#8tWtOnjZ2LN#NgJ_RDk)Pxe&hmI!Tdjn2$*;ioGi(YZ2XbRsPr0Csz7G42R{@s_g zRh-w)ggf2hWhnae-0{%u!4q*uHzBKBdpRRk z2=e%+yerm?lLllKm#;!Io{%SJ%-P1LBDaP_rrp=uoA~)M;&E~Oq?G#KcZ4KkUC5KtR_cTHXToM^pGPPG#LSI25l$N)pB6vJ9tbIyK9LH!=i zE9i^+W@K|T{y=TcVx)4su+V_8IB?l$7B@`H2~d3TYna^L}uZSs;_p%t$vS8l%uer}0q zhe*15y*9aLk#eR6)+}XkGS@6!t6;2()ebDC=~>$tJrS)Snq)N>p(k-fcZ7dGX`j$X z+0x5FDh_9-nXwwj3xk3qn8X-XGL{#~n_vZ69(7f3%(Fi9#7x3PLbYJf^sHK)oRf^T zeoizrY0>3`?1sW<8lj>{wI($6 zL_-;>;)Nyei}Jv5ss$@>7Fq-#9t``Psv#zcl({q;_zE*Uo+ZS98B+ zbngC^czvJ4bIGI(6`^Ub20xZLX}Y$ff>j-z_Wy$Pwq~#9TzXshc)KTNLKp#vA?;giaVd|n9;kE%DtR$Wn#dCig3v7xTO8 zaF{Wvt-?oNG>jQS`@)Get2DW{W9a2Q+mA9tnegJ%044(YF$tX@~l(l5q?LP#vzBW6GmB8jvN+ zeuNv?asyRJ|8hPuW5qRpGQn}32Cyv8r?O+(Yp#PE#WU%Plo9S!2zEkgD`(+!8gX2r z$~d$<)EM}uQC)=&rZe5K6vJL*R1STsZWMBHDo1sNN<*e$4(APz*jUSTu`L)HAc9)< zM>)rFV{_;}1M&nTr-IEW_$rI$#~5`73Rkn~6HEAGm4_1)2?lQ~XrQkjN!_eD#czQo zx7+D#eEU`38U1C>=dHcojW_}FipksT`Sqp!-lh4^;!E^s{wzL^(#71rz?>fUE%~^m zN6F?#ZhWbgVPT2cR?zEoI@k3t(2SUu{NS~)L?7cSGntHh8RaVO6_wQSl#I4X!W zu+T4VM{OobPW3RYjSa~K4SR@Vn52#jLdX$cveqX#6O_-wuRQ-IJzF_l-(n2%v}9CT zOT=v}=)!HS3}g(pV%=IiBGr(xTW#@ZaGFNkiF9#_sUac^ku&Tu1u2~2KCw4bb?~)h zp#a2*3zC=0+w~B=Ky3V_GYnYdM2wQj{glr1EnsY&DM#VfW_99TY`UD{oZ!XRw2c_i z?0^0K)vHlFLo@Dj3-AKYrC&(138~KV3_y84uhN(szutTL@bNP^gt^?uBY5$A3FY@e zsFGJ0tw;lollf8b;BUwOKYQ=e+(wcl41VYN6*-!o0jU8&0(?lKN~LB|l*B2C~NN>wFVcZmcd zJUk*iJUsmQ>X`*wuy;7~5JYvIOa{H0&5cGx@7YFGh2=dG2}~-dJ*x}iq~#N|$ssOD z@}3f>gJVGDO_ir+^c<7WrwVp(dR+H$l;@S2BpPA|Cgb8qYhO01|4v2h%gCqNpC zEim50lW20q`7l5uwBDC zqk>nywxN(DJ<)NEfov$4YUf6xYTfC3Jwy=Z(lv~3K6-5jed z@Mrrc0dDgI=9iLJe4>!{T-9fmBebn7B5MH#oDztT_12Ntm7d1k4)n`}EZIOWV9_TS zfR%HXV_gbN#v!$-QUI{@agc`uLvb}x@`O#YO__bEsaM-0ISF=`QO|0L5d|%YHRw;- ztSY4gdwX#B4#pf~J!-uJN?)O*n|Mmw;d#ST6qE&6Y&du_@gD3-$Gl`D?YI~g02&)A zULyBUGyt>YY?4c@sQNUQz(i;)L;vNYSk7DPdtlD+Xm(XaO0UgafRhJ!bxtY=fki#^ z)U0!!cqueq`=!mS3aOG8CZ94yR%S_M#inwZ&;mL~0l-_9v9QEuv3%l6hAU?_LQ+ud z2cqyIR6`4qG!oou(33m>g5d6bX)zietf-HH5yXD2HYhZRqNN;5J9QxiIT?Ee&4Bbt9M=0z$8XSTUn5lTgtI$b zp+h^5M%VF5b93{77^y@TfakPEJ!^FaaSOM3z5`KcK*8R;{+w06y$r7q_DoW6nU!Ji zJx2d(y^g59zZN1|I4MzSfMe@03iK51 zLq}Y~n1}-dJ9lo%FMq8-m&ZTsBv%ooOHj;AM(-K9Ge%HNhC)8Y%ddAa35RWt0Hsct z>;a%+G_}$ei1+4uWUopEN@3Y3yNc^Vi>9{x6lUcmWj+8^sYwlO&iH`2*qC5CF$=C?UP8pU8wKXk-Ub#JDFu?V+j2ufe!L>SoF_%U2=8Uxz~p&y5{sfCG|QObEfu9 zGVxy}{=37Gt7zbSVcEJLROtM5LTx7z%ZO3fy|hIa9L}I*+WLDVh;1I+0}_9|)0;W(pO2{Co7aF!7>GW;iwR7r)WET(%FBgcw)wreMS(Haf5)lIjkbiMS@96F zpS9T154r!DZ1F|w z#Y}8G^KM>-l#we9m{JBUq-U=+t$4n~ecQi`Fa?G5<{iYSzNY1%c&JSL0+B2}qm`GU z%&?`|FGS1Jo$$lmZ5Z(=p!@K z$Z2a8iW!jKn@yy2CJA7QPim>jb>8R(ygW6L<#zta`hqgYauPFQ7Ahf{JoxBq!k&_K z4)5frgqBJK7$~9_|3ga3Bng2fpR>0><_nY!X-S1RqK9H3jQucGjF}D(HF=25*^zNqU#{LMqGcgz*# zb=2{Dy`!X`$^2ya@kF_=5s`@x=vcxQD~27YoS}yo_M)?1wPrLNfPCV_%S(q`*+0vCfO5(70%*Q2BhX z0xt%JV*yNz_2(uoDowm$40EPr&6{N6KR&Fo#iTJF&~Dphn^tav+h)z=+v^0?7mN_>_iH z+u6m#Fl|mHQB)3kh4$FbnK#6e4k5brodyX?B6u8UJ*^}e(KFF;%yN>#=F5=Q!zV*1 z)jXbZqc|B#$-&w8FeD~ZvX~9S_oV0n*5z6{6-j4JlIc`h(ctlVg|4v{U8*DL2B)|0|VMrZSfZZb^bw2#_rI4Kpp7`E|2FSBm*rt6^LX z<`{^qAUd}DfN683tpP$dyfRuE$u+EQl)FjQ<>X*3!X z-u+|>pCGF}E`p}Q8w_yWY*3qwd&mhAn{P-%Y_i6k4+@!%EdZGR1?BKLL4Am)pLYqg z62=&`^m$^wPUagADXi*hgY0Tko0wyIGwdW{5gc0cyl>3zio6zB&@#{l8I`t`#9~lL zX%`}jJ3w4-{(L)L2DfCBGo6#s5_pORa@VZH7-@bEVsu`RahMS9lwTMF-6fkahM9{y zfHq+%bfdxCJ>?iPn15WpNTNNLoZC6UTC)?P(R4eL8RW1KLeq9 z$E{4PWEosvm!7AnjAvUBg$=;-T*gL1B^i}CDw&{pP!&)>Na)hu55bVlq#Se>O6m zjdwx-?X)Bgy3(AWevE(>lk*fA&WGWLcsLsd;Se?aU_%1W4l^YK2D%TDYjUTU%troX zLQ{$~FGvOFo(Uo3Vja2yr_LJc-8M!B< zXj;yWC<*{;fp=A}Df!0BxEB?1qaxUTP5=DcMYF|}gYJ~Ag{WtkN8QUcz_PMoZjfhA zcs;=(Hd&;4xm-UBe(h+=NxF<8Gm2-T(9tA65eWhnCtwW2B!onpkh8i(v zENkT;3Gz`0p`O3!58nM$c&lMMkYnM(khhk7nbA$;-eh{PC&m?MT#ddCqOHEs)s1Gu zbMGj3X|VMfh-=@RVuEP3L~1GqNT|Pr*`Ui?L5}CbR^L|I4IySBUUFm!+m=mrRi$j5 zV@{uKYOwg8)7fzi&lfD|M#0_&a z1(46?hO(Hu6`bzhKlCP@iJ^!mZ~_6FlLw(U(QK54qj(zs1N~nhk_D;>k>6mP-Z$V% zA6^P(rDjIlHf6vW;!z7HVRs51k{tajeFE9{$AlVAI@|_BP)4Psky_MU2fShDmKJK+RGgEK@*BM2b~7?Id?Bv1UFCx- z{*d2%dTfm0j0&FrZ2_@u&H#200%~Aosj^lgmWW(yRN6r^L8z6$ngd>^W>!CWEyd`4 z#EgYJ1GwC4W;~=w0wLjcxa=?%qg6SOjWkqFb>|`Y*{A54*87Jd1yxkX*ernCMEab zESt`IKCyiKG&#lRz{+ZsAr{yGBI7x>z@H{{@l8Mk7Tbm@rx8{?zIJPwMK#>vU}>d=1?(!t`&WBT(}A0L8cxii8?}mjZ=a({RAg?j zG7P)Nr*+CD$?o^kXPDGV5E;xahHd2{X(bC4vUWU$YRwo&jqwKpuu95#IvX9I8laW5 z@7~=i1Cfp~7Tg)xQflBpW!f@Xu`&4xEX-^Sp>J)+J+e*NC)F5s?s1tj25a8aqW~ZO zZ55ki<>f(wA{kS=lq$(@5{ZKxT}2eIK(e%j&W4qC9AmLFRHWU_S6*8g(LM`y zup0AV2O6$B#Ow&|{Bx`uIR@O-nmOoHz|6+yv+SmUWVPKS9PeT${p(ePmAhVdj8#SY z(kt{?XshB5npoX-otz;6RY0o02$HxFP~V+|J&Z}DI~VVu8gTAfrSYKUQ}XfvTRoYB z>C10FBikm2tzs;`P@aC5sNW&OUpm^K=Qdal+MoTZxXabPqkH5oSNe`FnWdwA_czd8 zqI?I})BNaq?=Ed$JrIxoLQB7C;AHcAp)p@NvEb8-D|2{T4#N-MVgA_?50AxMV_Xxv zF;Ch+n8LxRoAjudG|k*x4L$FOo9zaKu%N7b4mfNW637w*Ld*mn_(b7mDX>v`C@KKvf6T55Ty*$84$uLwXSo9 zW6}oPC>;a%5Mw4nAu5e$Q<>#e!r>Khl1zy)-Aumdy`~L=Xv(Dg+UPlk2xA&HnZ8^b zt5>eT4BZJ+O8oZ@8&id!ba#C{8a1xt_k!j1;t)&yz+da23ph{u=caZ49Cv*@0S#Na zx+;+wMT9yQP6`LCMhm;$WC8>=xT&N^!bw+ABgu}?VWoC&9Za_C(`0=LnV+EO9RAiw zFYf^hYr=n8h7t-ZlFY#V`S)2eki&FO%RN5XImA_NSM}uMd>f7DmKR?%CKw+ic4y?S^BW zHLD*_(y5V(w?m1~Rca@6*=raZ;vjeb{t={*tl~=%RB@m%T_Y;_QUr53P#pFl-DYtb zY*~2K)Zn2%rQD!4B@n8!&vTv4FOXXE*htkaEB!hpN}&z)cN+*^rV_J&ex8)8$O+U2 zV3$VME=mLI#Js^Yeq%PCQb}o0@NTqq@l08ktsyax8f>#( zq^$pjXG7P^GYs!`rZU^%h|Tttg@`TphMQ24Mw*Gp9EqS2rz1xy;;T7TpUtc=(wKmt zdl9UQxv~r=OoO*)&(|Jup&7`1hAcXDQDjaouTiP=S8UDBWor7rDB4$duxdtV(WX;h~#cjPT^DVHE@7&Vr;#1dtiswYEEFcXG@ix8v)~ z5Cvfd_hFxgF_ua=$BM4M1lQeQZNN%;&mr~LIU|aD@|rl=%8JNw+OR);#9wTirjr%Z zu{P(pZP0Hvpj`J0`mM4v1nfHd+Tx~PU=CA#wzJufRMv5`@Z)`5I#Fl$*W$0igjQT% zAYCkV)vC;RpAX+eTo*FQ7h$FFHQmKC-b^E|y90FykrXy7)*;+nhvtnSeh)+ncPL1yG}& zQ`14+RN$jF@Ah z_Zh6UKU0}aTCj*RhSE&5FC-=ImiI8nV^Oj$`#O;vjRYj>ew~MK&MTeMKiTLoqWX(?5 zDrR*x$%XS7U5y!CO)+ZC=HxF1p2dvs4{Kwueuv(viJj*Egb74C+SN?!dR<++`3_Xn z02K_D-MpH4e0er-<`?+XTT3Hoj;}iR!KNU|t#n@yEIOhWZ>F$xp7k6TF{53p0oNw=@gA5Xo0DylJc!oQK@F1f`2o$TpHxu%SjW^%SnH$AhSuU;Ut(@ii1dk5wNBnO?P9{}C`LH~ zUg_$IGjSG}R4SC!a+CxYGjZ5Q(}<)x`-L?d(SC-;;8ZklCWHjYf(!3^dx3xJ+bBME z4~6r^A{$Fj+a(^1eCxWo7@v*5_SI7v16D3kA3uPCx!|)1GWd@PXy{N*#&D49@J3OU zTH4zZ&k8*ZB$Y@jfJGszR`fg1|BIj+E3_A+eK2xhvv1CHh#Y?h9~t%rXyt=RQYX~T zB^57GN|Xg`c0h)FrUZU}T?Ddo>=r-x&*HoZN38m*HW-$=&_}{$cZw+zS=a zvB^YzSAFud(f-N1-+lhc=P}Ub%>CEj_}@1EPpdO8Al-#$sQ6LQR6UL4oPFld=kXva zG<5p|*zeX#4L^&7spD$Q6%1d^E?=^6C6;q@iEm>)cSbC*pqGv4<)syd#M+=so+C=g z5`@00pEy_dze(y5&+k#9K4&4OFmOC#;Gi8bjctY+h3gGK%TKHb;9LP@q*o?f2tu%q5;j z)&zW}EmShfdNN`xYrkn@a{hDWUd=&w4_Wq1_}xsd8#3y_EF$H63` z3Bd}3@&fH47lWkJAt(Jv*9Ew53|UpL1iLtwZplyrAqCV%f`}*@c8%565OHxkJI(ZR zl3bHQt=#nDDj^FEC|`||e=MWqR|Cvf158x|4D!PHj4;qegK{h|7t!fou?r$P>Xw}Dv8S0=h_d&WhlXyz2u(@?_a|>T6D%rwG@jjO^Kni;+AT) zpNYKsbk03i{pOgw>T?H+fUti>Yww(7VXMo2&6EBskcBh(Tam?A`*n%^dQQT$RGhb= z%Q>uyUoNHEtFZ(^{cTw2=b)KC5bOH&7}XtmC{$UF8znAsNo8xbWi0@*9e>0O`ihTGRrrxD&{%>;aT>rD@$>e=$eW9ua zcVsf(lEg01Y;SULrJDH)#o(;OB95k|zKE4e_*5y613!xw?x;!UYO9c}5oQ8y)-QX2=LtZ-IA_taO=`7?HGrJ$Wg3xITRvr99Y|j#Q!!R5+tQ-{b zL$@0mpfAHKG(j7V8DM*#jkq=*IP#1}k%}(w%;LdxO=if!dS9uo%0|gz*x-#y2y|={ zBzCDPwi#jUhPx52a3eU4!0e?{YNwd&ovbpj?eQQJU;cd*jlub37-KkmsQm8yS*9s5 zjO;A>V9C&Eq@21`h&?0%R?lMo^6+H8czwtb64JK7sftr@@-b&Vy-pgzfgoRH-@Rma zCD7jvqhT_+A$J=MF^VVn?GF!?6A^fuMcr_gs(c~F22P?hnN7egQEU&PnQCG{XMtXw zRte42!9Xz5NIDo}{&rZf3{`Tf91RLq0v0dhn`L^!J$PpnPJOeA(A490+bY63caE6dqys6Y>bqwf*vvrt7sDgyL$ul*auq z=+4qpk#Yl&K<(KX3xa+Ky(sNY;_(z*!1}#aGw*|HspjD+9uu^Wj-MTz z@4wtTIy!iD{`{HWt)(!X18!!kVmgP`Iy7&zDyMUhq@tXPyMtsDSzcyb38*knjph0j zUI`vTxs^r^ljcNF%F{OJ+~gnxOwFl)1KQR!%9Qf?BRVO8>#vpezx7k_y z!<<;MGfE<|vf}y!IcZp4ifv3N+y9?FI`BXJvt6*F9yHH4HZ}~;IZ}apT=ig2tGQ7H z^E*-n6waOY&Fkw6)!E z!~cg#Z#Ia4lj1R_KV{LN*dYC7WW>k)&?EYC;u{ipvC$wGR@F4lWg|I-4^MAKIoUaL zY7n9~rz!h$FbN_=50W2ZLH4)G$SJLlPd#ZWors(A5F>Y<1u;gMC0R7c$TwzAlu?B- zpJw8W=9u*xa$~mxWyf((?tor(@-N)wiqU60)VJ0n3}2~d)<^gzwLS``v((sNJIIvy zlQ)FTY=(?VOq`g^LNBpYE`j|VqvV|M%p#$v8xD-XCBE*J)1?;jRhCF~SXD_HdPGT7 zW+U)C&)%*e%lBt6FcxbP51Jprl{1u8bg@AP-U6`kGuTQU`-IN#W~wf@;Gv=o4#cy& zPDV9}je&-NfRc?8NWFvBd#du(kkW`M!wBQU+$jl`c*yhyG9fDG0&6?T#h@LCV}Jxe zt$W09S~PTfFIXonV#l7Srr)LKy6J@6Y&2WW#q=49y5LdC#=K`Z2{AHnK4~8aH*Itw zEB1}Yx7?D(v)S-6=l3)_VE%NJ`fiSK3N)Hana3Qtzwdq%7f0p}c6hEL8Vl{eTOoa( zwCT5!$*OBs7mq;yRpdTc!F=)7pB}v|0e#6BCE@GKkSskT7KE=aORg*r3!hicqIl^d zF-yuczegd<#<_~9#n1ZXh*%OqSPQ?1&

    !_@3LR522Qtfq<^M*~mM=lVW2!sTLD{OnrIU%)69$$e z-A=DKzy9vObW;I*TTF6#DK#=8BrIiq zDZY);>FuBW%e<4&X2DkxZascQ$r2*g@(c#@8e)SY9NNj?1`a@lJL!+7qxgK0(zm(? z74L9d#d9wdZwF5x%fh$ef&)~)5{n0T>K!5PUaSJRSW~e?XrEyhZZ-O?x2US-q2dO9 z`lnvh9YFjR+r%&-!>(=BX5pj@Ed^7~4mDR=| z8eL2;Wg~EGk^Cf1PbTqD2vg|JlBpTQUmBh&lr{`mKQR|5xf-Pk|rF@5|=!Ixj7cZd+1!8wG+sEG4;fREKicv*} zO404*+1Uxx5w!#oXdoFzr}*&-ejCHfbM z`3-u18`bo58Uu0GqtVJkb||{<+3p|Z@>uHvOn9o6=F>k(=N5$UhEJ-MC~zd6EwngD zvoNIPJ<1fatIrRk0e}4|fP0S@h#8io!_DnSI|lW^SB&%4W@}4gYJR-k+VFh5v$4J7 z`FMM0%L1aOc{~b!BsXkXrVsesjUelBlBRKoo(YhlU^a&5op@FVJ`#`RJTQM9&l?ZM zpVKG`-jRc=u621KSlX=95HEvuScIQb{Aay0NIL6R&4-PR#>V;}?kI8K=XCX-;N{?o zN|NWWe8jv1^1m^QBlh8us2-ag4xn7$!7!dq(Me3XmSMjLzEqB7<`AQ3Y7QX&WUwr! z85ShM^E8@5lE2h(-Y@dXhvUV*xx0a>Z-Gu0loI!U7F(C;`Y$*_9-vv=E3qtHl(rD} z+gLD~6S0(LOZGgZzgP1#cbP5N>-8pZq3ER#>62{45A@7B<8bq{n{i}dQ=9e1TQ&Y= zr-u8rRS$OR!CJE(+=FlL(Z4(Q{Q9)LfccS9!L#ll#T$7%>j;TJOhnukL%P607r^?H zu!H#_^ob*whwQh{>?EE_@hRy5WaV?*mIsVERU1-QDsU27)$VPr4p3T&2g(z0-P{*( zjKy9sJ5st!^BC%VQfo!9(HkH9IQfzTEhA;LWUu_$DE|9Q+(SK9HN~ijOsC}cORnW{ zPa=yzP53`vf-)pDz=s0?Ujicq-23Q;V+REBeE?s3_%*wnCSbiN59Oj53xgEz@d0yY zzXwV?zMFv)(simg#ODA_NV-ZM8PdG=!qG6{+{rR$v6ea!U!^mrz;z)ZRz&ft_fkEWt3VwK<*tR-R^9Xnh?bl z6~?6QZIF(0uP-+6nF7(4cVK%unMGJFmTK8fF&A!l0SDDu%&^-g!5 zfMB3}di)Pgs2yR{2EL7>3E95IMUM&vHoP>9p*ZM-?t*>-uk4s=lyZ*bUGJHurJ=Qy z2V1;^VsXLz1N89zx=8GAi>WG&EJ`e*J)Q$Pw0McL(cjBYe%-OP+LXSd$k%Klszq>f znBzOh87|xiO&{tX_t}*>CT59j}=L2wOJ>?GcO)oq!k1 z$RmYbECSL);CUh&i!+F9M>1N3P!*OsWF@d69h~!6T)~HdKX+wgh1V&4gB** zT*3OM@{h}U3MfiA8VSawkS7~~yMs7PStemXy-0}f$&HLU1tPf)Cp|K{3VFE`58~-f zrTeArAVtN8Q_6|1U&EH5Wbrg=)Ar2CU}=w(na<*A?`Y?qsItyK1xIMKBe4caR91jb zxR`X}*|Ub1^B_v9AdE7w!I3cowP`8K+BpX*dq>-+3+?ZuT|^y$SWq-O!*-FxhApJ9 z=16H%%+;uRhEzm*WDuN=^rhI|s$xtyqURwjsgx$z&hIQOMDE5^u!KYR+6_HE2k(jJ zM>Oc?4Za^@(dt|&lVVkMNMZ&6_5cx!^(-m-HQ;e$ZImqcEksbL@&b<}Eq@w0?t=SB z(#Chv9!))|7C9*VsQdt_)R0FpgFN7}+$Km9oC-vQtC8+pCIbkJorMF|t_z%@@{83M zPo0HqiecuYC_^ynQDbbovu8Hx(fu4-#04ca;z)6`K`xU3rYRoUSFD~F+jtI^zjHc> zxEkyFyQi%wiH<4w9}?x0Cd3UAJ{-W3_LE*jB|Y)ssQU zB8g>aQLmQJJ`B_FJt%S$i^!3pVCC_t5e@{b%y=<8AuxJdxf|(gUTYTm7B%L*UEwN) zWhWO|)Q*VBAU8-8aY4WUd5ioRULaud;5p{KI@B`-o)U_ez+-}SYW@d>^|nbbXVYGC zJ*v6mt9B;UW!gxmuP3=7%(|_DNcVUK)~9;VGNP5`7oT!pUDo`K9Tp4V$Dk_&*onlF zQLjGSJdZp!q(xIp?Hx@s%S;XVfI=Mg)Uo8G;*3U9|9sZhgMH&nkI*+bk}hji7Lb|0 zW82ATJnzdDR!V$HQSX}2e3XI4F2PkH|AV|Zm?vP7pBsyLsrw;ALQ8oXKd`=F53D`0 zkNs#8K`YR<*s57fW@oQh2jPgNXWUqj1{Qqv)hZp-md7&mtmYf1MB|kJoo6lt`T>Kmy@Ez*s>~~6AjB{qVDyX zaJIXG^MpNHuMwzGXLU5U{)yKK3)cEyXXh{MuWRb;L@zf{h} zMQ`(0bwk^7L5p6_-){b0ThZ{(&*7Rp^rAlzFD_yk4uQ)cZ#Wu7$DOLbU|dVw9m zdh}|a#VO{QXI~W)=2bG7jiz{`!kbCkvW#c~=4tTk>0Txv`{1)M0ea#(vZeu<0C!Mv zmoV91g@al3SIcdVJuvN}wLz&5h{4A%O@?uNNvamHTR#hQjFtND|NP%UkpbR-unJvlWlbR|rq=Oq_!DP-G@31AuAjm=hQs69X0;6zN`2S4m&8)j7&xn@@OS0Oe1! zXT0hw1Jw^T1EjJjiA|}qA#N8RpQrfT1oIF4ffr(CJUC3iu&5s;{xtdu`AK(X3n3QA zRh+j`h%u2|)g6adgiU@BeRwnMB;wWM5TEBLn%zx$D{U*O$|9xGPDDM0BvS^%q>>D2 zly%nBFdqq&!R0;kwG)@i?YV;nvH(*sIxox%Oc+aI0S3rhpL_$>mwn(3MCUu_VBlQ} zA!#rRk&@B<7Q|#iSsFPRK$k#J2DC4oqzqK&BdYNP(;hETjLCtx0IB6cTA1o`0WOIE z^Wfi_7V`jq*<_iA^+FVSENFcBRO*AeIHh`_-IiMYK$lCg-Z7R%wO-)A3Ci_iUY&Y# z;srQlqs%$oP!X9vYUWV3Sp{{k(ddfeC&bsJFSH)r!Jm7Pm|Pci`uv)2;&VP&!(c&*KlWrO&{keUc2~?oHNnT|r4X>}A)DgPCvA z0?cgen>T(zGhUHnJVo`4ITR-#J-G60YXm@qoSnJO9;F=X zBVA$GBNZYLq&`cw@f+t%eCC;#T6fYIJ(VQpkFs%Er#h3|v$#9`hPr-R()V=#<-xP_ zqvNB40y3aRZ{C!~INVmxl+h?{Ht^Wpg_=qH|3QPc>I+joUGvHPQCn(mp*^ypm8b^h z8jCGTOTs+oI&{&$16`Fn#20f-R@GhIX4&xo*x+)x{%6;bNzlgWHe zOiXevrQzyIwcF8ZMJ3zZla)l2PdUG$+OF#9C{(~Lhl?6REY3X3wR(&5%rY(C7t1P3 zw0;Y$?Q$67=Ts_IpJbtOa9N~o400P{FV{KVhTO|^kY6ytm*^xHTH)mo{jaa|tUCGX z8q4LJioEd_KOl4JL>E6Rcdxfx_y9hwegYR#p5AsZmU^nb07dPb>rqj|y3`Zq9rMP%Jle^5=ff)AKByXGv|NY+}ZTxe{Ai1&Hs4YpE>eBQetr;0F^p%JV~zN zUW7H9F|1CIZ)bJ^MX{xOW+03B8s#<7)AoMwAK_Jaie*<-<6#8q{5Ty-&=hnTb%M?$ zxlTEupTvi;pktImIbaR*h?Se*gZDVw$4W{rl&;CTO{H zbV=1xwVD`IOA#;F2wC)WaD(|PZ${nANis@iX`m|L@(u@kCx@7x;08RFqao&}7(sr5 zNkkvJ(83Hj2xli>Z+p#CDvFKqM59EkW};Gv28Zj%n4|z8V$`#d)JrbI0q395)q~vy zHnIs)(m=~g*+`4XNfCt{a3X{qL8XE5WgUalaCdWH{A((%z1qT%h>#%!9S!I!wI45& zWSrJ9Xmv{N=OJXZAB(#;5<@s+aG_fnm=6RfXtw)4m_pbcj|r6yxmQ5rh}*t!9Mw7q z#94Y5U4?_6cDHw%+x8d4G#ZoH=x_wF15hqD`Y;Vv@CLpb?lw1DyUmBIcCTZk(1Ko@ z8;^E3-Cp>m%tWxx#ImlEz3)DFu-km(!+Y&|0<)Uz?(DW&b_4jH8Q)4N{GHvMjY6D; zVLVy~kmn>f@3uB~H|S_nCX148 zo3)gY%*|TLm!F-rw5v$R&OfTIN=u@DBHQOb6TG8*3=S!+rYsKg$xLA?7{Y*G4t(u= zG~bgLMFn9lDd#KUMj(B_yC*n1ZEbCAqKgBh0v3zW=p{px<^v4CQZ5iWInXQ~=s<9@ z=pHSH5tJi-_|skYXu&_z$*em~47UQr+H@^|pZi+Yf*R^n!5sx3Gpk(O584=`gpMHZ zAcpHk6GBhC4hIlR))*%L5HuAwlF7w-G+KLmy538=>H3R7BH&DJ)}KSiRd`n?97PN< z$lwm)VwFKb78b+cDisbLg#A85E$LbyC@N8L$b^O zdetZg$9#xX8pg9q?ng%aWuv*#%zRB*t8j0T0_itF!ays16=F_1?(UMR3eU6-Sxr?@ z8PPMvC!eGoU~Mx_`(;UmF4%SJZ(a}t!m20k_f+dT8;yochj{`h8U6*fR~7ttmn!+;%*Xm`>S{~ z`;diE&kjs&BK4>r+{pY+ZEVu!vP!bJkd?VS1C5hG!9t@e+ElYlx{ET0iUXq6Os?YS z8ZS_pwM>$kF0u>+L3TQs2i%&m)NjIy*oa3JIoh*6HAQ>Xt z>&5AK5Z>@7@+|XtDZWl>gwCBWjMG*GqwRNMk$kzLLy2fCQqVnB(B+> zf0Z1$5Z-saS(lR0{N?p4`LOedi}TP=JozvjfR{iooQ8AK3F~=zzrmtF^1~>)23u|; zc&(~psX4Q80rws1X|cTFg6_wYbgJGAR?-sVbqzZFu-A);)>ZR#)=8)FbVenPY{2-K zuq;jQ+DOd(mCe;QJ#59hR*0kz@F_b0ffxQ<8$;@N_-%8YItY$*IUNpGgB5#QF=G%E z{=hln^4M?g)rH@@RDm^k5^QI9udTMHaJb-K{ih5KM;?Tbk=8z1UEZOX@1LCKViu)Hm<4GU4Urdq8 z5W;%A!O}+QVIu}}FlJJ~FSkqhB~B37C89XzvhI2Ae*{=00aU_hKN$?dvEVj~qV_Dh z+Z~^GLIw7wVl~s6y^9yiw6Chs|~azE8#P zg|{BJ-nLBZrO=lJy8K4{ELRiEY{>`YY=T@7~cqzGpOOar3<4`~`cHNqF-OJ>tHt zdgGju>7B|zOuP=9;6@6C$uYgeOxxn1YMHdnH3FyxFv%L*;J(FDcm0@)w#f3AQk4wq zIPGmAtw7h8Y_x&ZVwo0D6oT_7k_?hDts>&BjYjxkM6U(>Qr!10R_QFJYZbp2_}D@z z*#o)IUR|c(Wtc838X^rgAMQM|426s>h#suAO@n)z4bd#US0Z<86%&O3yr2&EbPA?> zYqKF;?06Dg#mOv%R47z*8FtFE`k!E-U7#6VskxTBCCsqU{Q+lM6LQ#^REl_%^1d|V zqKiy1{;3E!>`xhd!C82QW<$Z4TicDT&4*b7bE&UF`St={i|z1pEP%G~{?>V}87g-V z6&^TrFK+ipd{obw;It=E^F@p}yft0b3bMp*hYg zc%{gp>IAglnG)Pn)lWBfwi~V1gCUHNJ=eYDz`?7vk^?+Lm-#a|H?$CE+I6l&NyLYa64@6TyK)scRpTQ_W`j@Cn3NzRejN2O7wUW@ z2cxXiPA`*dfrFnJ$cO5Ri5U8Cpc{%xBYq8)PWfx4hRqnA!K0a%h)4CcK$qu9G#>1> zb|2+7cyn;_ibB*HY|B0nv=*#D$Hvd;Zfon|ZtH;;1?=BJ1|0e5Qb@bJNIb1T1t zG2mo2`VPCl10N`G{x$(^Zfxu}Ta^HP6ONM6%}{WwZ#Cvy%~oN5$kK5o+%p|%z zZ0)u-Dvb!8&7RGjN4o{9Wb{0g&Y+F+Wb`Tq1R$9d>at+@nqt<~a4;YZGH|xH9_>Dy z7tC~e^CL#fSfC!Zc6>W}+bau?&9ZeNrrJ{m7?r6#(Ohsl#U~DRtGTQPYin!L+=^PK zUPNwP;`8!pdu*f9?k@%<=hE3|00BEFqBHZ0<#?IdYa!nVH`_mX3(tstEVWB0&a+|^ zuZH5M3HM#tncyyF3Bs*;KX|80b^Ov4sfY|S%1ca2M;R9Y^sM9C=Y(c1#HtXgIkH?HiKkQWLx^Ncx1tf8y&=sop?v8!&= zf*4k}={&KlUTjNZTfGbI4NWZpxe!mv1-vYlv_K53cNHs>_&l+(UVJOY$XeuR{<%oZ z>`r5=(aOfmDxg}tg;}8EkP;>Az|c(Ks1Xq=LtX72@IzOV%6JVgdN5qj>3HmGF4o{_ zPJ4fjY=z*3kV+z?39u^3x_yOxy2&7!ycT0w9coZHzE(1t<&2#1PA=}8c^1(IpGH&i zt}>mxd=39BGYqvn->zpqbA7;`%5+`%SbnO!_nu7`x6?F%$h2MAKDz|K09FdAqh3M{ z^_(4FEgO|R%6Ib#IS+(h75&>)IFTpD>1EYDc*3G5NE!_zvi!5;2y*g2iC4}vU3Lbj z!u(Gg&F0p2CjZle2OD4WKi&4HV*V#z@rNCV+2Ps`iY{~!SD@TfTRSGvKuC?FsZDb7lUq-zKK0ZHKQc>H^mh^O~#Wr5e)3cXyr~h)8Cy}rh$RDlf6Rx0{kUE zb%k$#^r9F^GIV2Kh72D2SITVn^{2{@$^Vg}mY@EwkpFLQZ8e)48UDYy@s*@+iTru`c_|Vb~S?`AHC7hfu^D znU-Ks#NbuZC+d_!$OLdH2!<6x?uE{lHAMu0fhn*nwe&JrrRB*WC})@bmX~RX*hOxl zC0cp=61k5d3G`w!u2TBMy@pSsXtEEkfc+R`6Z`g^4&=43UQFVZbn^Y)J|zM%JHlNG zZ~r$C4Fl>GW%>}e?ggZnfO1=)7XmLI6l)~JqiC9T!!hYK!QY6j9F%8eh&{mzDVzY= z2k%~jX*$N~p=Uzo9R_#Zb762#2Ty z+l`hU`uh61alMJ-oxNFyc#ZAWIu+PTF?{1+`hwuL8}!gZH$x{!fdkJKEG(dgcM&e+F{Fyqn!63!>JZral4F#uxUIu*)NC}x*%4eZUFWaY(((JS%b_z;4Lgu2Of2Jmv+ws7IYf%l^pri&j3-(WsmBfUc0Fd2j+B}YB zUHtO|efF@UMon2vT?jzm0cjw_v8)Hz;sU-juiNpgGZ1&OAYcjt(?E0T+5xS01Mk}J z2H#--P%^#r?WOMf3h%Oxs6PC-U1eqEcWAX~&A@^#NoBoUVZ<{s)q3!*MJhg7|=- z-_PYg61)OVto8Wh;7G{R=RX|0IXyf+IzM{*`nv;vZQ5XOJRU%t*-*yMcV-v(A_yno zlueFf@knYI$X%#h65nXF*2SmmfX4pWU(VBLdd}7#oC!WWdeJnD2UfjfngH}VJ~`ie z^(qHxhz3Z5L39yzZ$KR$bz#pZ;{9=vOk;{O>qOIQ@XTb)k=|#caX5wQ&O*MAG2}#` zk)j85x~!=c&gb~Y^S4K*d(RKfUmd*I+yCqNn}ef+7sqFZduL*&a%M{jH8E0RCL`Vu z=Nbm+2x1gx5EE3OT|n{&nxbff5pk(_d{G2p$cmx6pYZbdjMYt&_c8cn(v!YmtmEVF4-d`{{<8ma@94!mlMQ=4-q|(s z>c9%^I8zkLz|j`-g&On6oko5j9{WLW685JBsJ;2?$=UJAo8xn_Y6pKgJOA$Oi#hNU zTnd99Lx2}-ir2OP69@_ku4V&x`*&j0T5A3QQzA!V31*}5sIk+_NAcP5(b@Uok)WBg z^MltXXMa6^{$}sR>w}}S(|J}Bvqh`pG98Z3CuxZH9-fAAGyw$@s;y4szQp=T(R27`?PKPqA~q|)srsM|?rW0bz%9OjS9jDinQF8x}4 zULWqiIX*ppE;jh^#ku(KhfT57&!78lft-$~2dAg!htC$I5Lk4B3i=pZ2&qlt(VF;f zZ5a1@q@S85-DI#P3EHM3_CE*MEkR_of{tD&f8k!Aic<)4Z^4e8pX@z*c6j8OjMeGr z;OumN@8sZofA9R+k$?6%9bO9lejpC~Je{5$ygrs}lGw#Oz26+XJw2$>y>!1MA;Lz9 zukc)hz&W9Chx|o866hbl7OegB)O&%sjsK^&2XFp*{`&0g{D&DsEU?tuwF<*<53?l# z6k>f!7>hMLeJj`u{EB}SUdI_Ar?0MB)tYUVH#{iLXD zR2=_T;>^7~7suxAu{zkF4=-r%$INbh`s!fsujd;NH_rE89g2GqCRENe#6Lp*YDt~} z*X!9|PpYsR6tG?$i>+i9TCvZw?FE^UybLDEV1Su~!YR7Ei}wOur};|>DID2{g%zvT#8a}Js@MXo3_l}-bYk9C=tsUJ49$CqY=HZKjQ=eev zYkczk!C&$BdD`!t9yRCbdlRAzythu?9KNpFp{(uOqrLCM zfjv9sUN6M0@n-MrI9Iw7eGrkihiBNcw8P%3lcVzk9441OP^dvhTO!&(LzIIytF#ms zLWNc|@bTWkNtM=rd9+yxOP-F9JaZcZ_c)aq$J1~y4JfZ7iY{IlGX9Xf0)jODN5oHJ zHe8F2r1Ak(T$Z&UPyz0A@70+Q@c7Uy6SHCXAs)_#Ajk}3A=n@j#OxFno@9OLhUumB&_}ICPlbn`O~O$M0(>@@!Os6bTu*3$dQlof5Gp%1@EM6AFZ(n~{aRylhyp)_o7A?(F^3^Bo50I3R`u7>GZo1Nv~0Y9%GCEck-JklWDmmX=R(OOX6m1-f= z9;s$*uXe|P!=a&_N`VAR9*N4YSc z+9t41YG?JQ%D8Xmb9vNKpOWQ~85-oH!g){S%_JF*BwymsDy59E%j)Fl>{z;vhH(k5 z(qGm1x!}OyDQh!yCB|iVG^Iy)AKkPy>!{AOHMjoCBo}0oxKgnGutw+z`Fd|3RYsZX zSDSC7130!tiihm~z?c-%6c_vV(G7*qi)mx>$(ylwKg?20ZrmmZ>h_#W8%O-|x%N7Om9->c@*EziwvVZy?m4l1rSe%1H=R4rwTg&C(u;U&ME>5oL^CExIL{eDjWr00U4pLZ|C1iRunbuJxlXe!762)DE3Ogya)q@&T3 zpav-gceWs)ntz>52KX0j0e*@d`RpO6eL0Q^2R(tIz4&EK{np%p8qDJN0kD*&3FQ^K zW_V$RX*Z6|!4XacrgAYZ+sK({@)e4#;PCA_rt{BpUG57#>fU2vrzEev7EY3i(j8)ezQ2$NvO$e z!&@X%O{ER~ghZ-T)kz}0N}YO81x$Q9xG^)DjH2r{u!QSm(#ySRX&tP0c&ejwGJ9#= zvUl)ond3Qvi~Z|gO^8PR&6I!J;Gxn%40zd?AOb7w%lb43cEVOKY;8Q++I+Oxj2=DQ z-0F9mt!_Ws?sT>ubUM99VYIcm_3%-+x$&U2^Ju5l*?zFo--CkLPbSW0&D2YU=AZJkBUD9od z5LN@<%Er%W&6UDnnJ6Z(kw)rXVZxzrX`*xN!kql?OXmhM__Byt-3Uut+SBc_hi|C| zuk5LBMt31a<|(5ME%bO2U%?fEi%027%rFHpomg?SuTa-#NS>)w!>1j=f3#)7$U9AaoF~z$HVQ<7~^6B?z zFca(Oq})TC+%{gb@?NzPtb&5e2%d^nIbW`8DGQBqp$L3f$v1g8G69*`wCTBu?ITE4 z+J%~_q{ zB*v*KTu3*m;3P4n7skD_fqL&Si*793@}kjb-q~0qO-F`a$BB%x3CC(Dx5C0)=ThsGt+)eSpDpW=^|S+1Z(JbJa5&{S4tNl{dYp%byzJ?cHyVL~P( zO*#NZHZHn>?P~_e0;pWxh2e#e1?ciAyKO9nMHi2*dr1|xaS~l{@xWjKycB8O=w6(U zxJsfNIg$~51pH(rr;?2b<8LBGH9qCes?Vn&qk2KhNSW%zqhn`9j8wo#pmJlr7zK=h z?3@Z1Lu0ERAci8gx&p>Pp%{7U^VQYE^VH&~9#>3{u~hq?7pqX!>^g8Zpf6lrxoi<8O&Y z%&n-&nB__pHOo4UWfnb4Q3Fe|bVZH%>XA~!*LTks`0m-VzWH459%Zu4w5#y$u{syO zdo1xT_whq=kHfYKY0CUA``R(yF2+MA=XH~(_b}w|O0OH6zs~Wjff_JQZ+z)+)zEmP zUpt+Mczp3|$463Mcq=6``f(?||P1z~oBGsC+cJ;PO25P!yVpziVI zBupc-A*UkB@txKa`;Y7Q?%a%NNStavU%#*A07#S3k5LB_UFm+^$yEu~y|VAeWexsb z(jY4N{s2}$slR>M_tTq_7NfGADfzx^27ixB8hj}EzH9>T&?|>p{In}tydQ}p@89RW z^kyi;xd|q*d4_363c?J4956}<><(ZBSb1~0R}Y?@?ydR{K4x2-rKP_Ap0Oyk4(8dx z+&(Z=&M0)!54a_y-G}U&(@Mh}f%6+PGFeNA?;IF$?d0?{XH<|L_oPcy$(B?fR7Rt` ze(}6nhQaWn-+Z|^7O&$`JOqoH5$z-mN@YVspG9`{6sSkc{O_8C@~Nj6U&U!MS!5h@ zg}bxKRTQio?B@&vj&{9$XjHI%85NtAsnha5W!YR@%@c@YNij8Ppbi>D)rI;maaijT zCWyCD*u4zi$0N*E1D>&z^F9@;(Z_@~QzJKVR>^dV7ob4qQ{DbTrK-Y$^3prpkdkAiM^9UBl(Yn z2zM*=5Cck;7kCZA#z-MgEcXm;qT*>ffsC{Prcy%fDd(!q z3&kp5#e#Ii{!U*L8_=>V36bEj9Yb!9q$5q^-9ZAuhL*##dKVcus7jWj$gnJ<8W&u= zbrs7tnbas)O&h^8$zYq!#*Q@6S+7tv=)x~frHI&1Mpux{5CbOL`=}529{t66MKSGw zInOx@XMKcHlcZ;;8;H-9F!W=P&N|ZprFc}}iml4;F=Z$XLA@K&)g98uITmeTNkTq@ z7f`Kke+Ac$`0DiK-WsYt>~D#U?*`&4^9#WYAVXX|cvpicR8W{uWNPiF5^MN-wM0+! za#2dj_ip-9Q-PxTHB1Qu*ne&c%FR}=V(~>SYrvJX>g=xX3Dewm(o$wpKT6DZ^~N<6 znTdynnqw}lKF{#)v`%@bRhbgS_vs;vPZhq5MDs>)s^UJxpC)W*iEJ~!f@!-pNyAz@ zSUEm?7Bm~J#=|Yh(!9C7^$034H=3)S_G{xbE$Xw8>D2QKvauolyX6@n>iXJli{GDn~!w+P0?0h;6dTT*4D#pJJ0C79FQ$fQ!mWT?DQ{lmuu6WR7TCCs6hPQR#F5O z3>89!VCc!kNYJ&#!R5w75lcx~CSV{k@0;D^$@q;X_|QCf@IHQu)QvCYDk9YUbe^(s zhuT0Ps$qsRILEQ2${>%W^2M^p_RDUe%U$LZ6Kx!#4>9_mldZ^|d?R>hlsL1COJ_Hnpx@aj{`)L~3Ih;_ z27Y9e=8X*B=)<239UDGnP-H>J;8;2I{+x0nz&nBIBUXI^fxoz7DBGKqUD~4cDRo#w z-BQ{X;|VkcG1py0+SUsT6tkHJ4~sr+{Tyk_^@yWXdM=oN(J&a&dl-0GcTtHRn96u!v!UKU*}cNZuaO#;#ff< zK0sUR$5}mOP*2|F15kCI+~t8}QE^!?Np42{Cmv9W#Z2X)rF@@aGZkz)Y;|&tJUMvn z=17prRMXmkZJ!;y0bRXxkO>2dOOg~XUnQWfHsRsGpaV_;0>gUuA3uJtOF2xFWRN!E zXxhgxD2RPppY*#Awwn)DtszGxo~}R63ENo|sy)IhRyV3;XEsI%E#|l-1`)`n@-NML zaC)%cq%(}4Jft1NhZ*m*7zo5O(u(kr1MUSeQp6zp8OA{xRyJPJM3lE6y_tEmHVl_7 zg$|WOR6i(!N;qH%cgzqi`420=4)(!L6g+#m3P`fsE@CQCY4D5@C73jhi8qbSpRDPc zkkqV@T40($sR~Q>Cm{!AnKlQQyjUbk8d=ArpFDA=dbu9eJd8q6Mb5>2i0P#0{+nF8 z);8!5+o6iw)B(Y@0hFCFzh|4C4t>V?$Od+Kj8G0uQZrNydh>ig*luk+w5y&7@?DDr zA5JDn(&A6}KeTI1KTKCqoM2D}DzFy_u({Q0Rsjg@6u>Mw>&?}J%qz7~UU6LzG-INu zjiX`h+trLw;BgL!r#=|HXo4_GyLt=>qMNo36yHEp?rKiSkpxClN;KgX35>45Hs{jc zPLwPV4gpnDTQhYf-zWy2+LqQU7Jq5=^pkj%SF$ZlThxwkhHW10eX@0A$2OKhY=EpDaH! zK9!g8hgG{KOtrG}=a33#)628);uWim%&cCnnMf`0Ek`L$|KtuSw&D&ZR-PtmpCyRu zc}3cw;syP6CdmX^&8x>4Au8~8l<`T?hi)W<4+`9oKske%V3cC-;e3mg0&|-<&{5-} zA&$Fw!rH4^KsX%9yjN+2;&$6wFBO-BZVp&)wMU8xE1??Oi->1SqyP}SHAzt)Ov4Ms z$)ScJR9X|r0+wyW;|2f4;ZZgoi6t*6RK)u#lin(tW^rfXLCbyPIJdjl7*LCJHwgU-s#9?Edpp!OhG~!m9!NeTo<=D&hYG6PdOKgVZb#xhj*(nz z90Z4)VO7VT1T;!UYgW7hCfej8C+McFXNVZ8p;H;`5uxSlDw?QLn*vhY)3p!f$AUc# z#O*|Ds0%TI{#J-fqh2V>7hp(90EH)!mrX_n5=P;XJK11z6jV6Dp%T1J9amZMGnEG| zROjpPhrnQpmr*={Hysly8;4UIn(W0qQOj&h#2#OLGHk@i`Rv=X5xh+S2d8u=9eDPB z#H|)b7gkVWMHkur*_%3C6nH$v^|6XBr2a$K2=;>Oa57>)zGw(RB=o{Grh21o+Yrh! z0TVJ<6|a(*tf-SXMM@WIG>NEE2Huw-07y7yJ%$(_DsUGd9}|p~?rPB;H%E?ylfcrq zM~M)s*Pg|xcms{O_{?4pvVMgV0W7B`F7)ZCKA8_zjnYAB#(3)_1u`;ho?00;*I={q zwwcLU17AjNA>KVByO8}_sH;P4m)BBHWLE@UH9k^FX$q2x!Vb6XsR9F^58D^juzk9l zk)>CSk3Ivs@*XThGe2UMU{*`e=kkJj#)CXG75tbQ&S3aCQb0StYG>*ae-*R8irHVq zY%{syB)rzS6*-BB=MY>B}e@HLm0L5T_MW@o@NS{m|-kPMua8!FLer zDNkXlGcn3o43^6!^6Z0EXW=~c#9WEC&LX(JZAY0-CuP(-IlYz24xSx|;rZgd%dso|bXqYqQ*AS?LlNSP@x zG#M5@#VT6J<3pH5GP$utV2JmEGL4u@gi*4oA6E#M=kN zSDvPEK^PA~LWHgoBHe{TVB}>k6W^96cM0L4K=MLIDW#OG2l3Uy zGFau&rS^61(Y3B{)%a-6(O=9v_ev67h2gD~nz_RUzXZT*ZY8K4D(6%g4kl$Za_2NX zf2HM<5;9`VVr=u7^D>I-P=GfWfVwK}d;w;-zP4#%qq!0Ua2-%543;SX}pWs@^d3_n4+1A1v4%%`fP4{eD0MBvC)}qJl(g|b+TQH#jsUGV31G-+G z3-)MyXs?j`eBQWXt*&`u*r7UIH#S_Uu|%^I`FkdBwOFW{JI?xg@I0QR@cM~rg27u! zu9fl&L^T;&n5bATM%rDL_sG@!cu~5<+O9k*z==BqlP-Of%%|^UG4cOL@K^=aVo;fY=wCs1ZTL8_;Tk($Cuz0V2ylDma`l6RGCyh`HhANj;MmA$0xb0 z9hVW&_Te-Tk1EY61ZCA8TVv3`+5C$>Slk%WVF1g4R2bdM+2}p4mmcKb1+Mt9ZzSj} z=uV~4Fnzieh}ELu&0G;(A=(Nt3B)+W$UCH+G$JswTYD2-m+_v((n+{nMQ2>dFq|J@ zhR%1M+!OgD0Cu2Ub~_Wk8313o<5%t&+&On#3Ok!WcZu%BsV$#mPZ{?U{KwDuK4*)EF_EzFhX7bm|8N?%#Q?|~J#l8t=`{PIDaD=O3jTgt)z+7gU; zcsz~$a?2d&xjgv}Ey&%b-{Cz#qX}hgQEE#!3yrdP$Xq+wfC>a)wo_S8^m9+zAGCjb z-iRh3cu>-yGP#UY_*ToTlb?>qoJ4^}m{RjBl9@;4W!Bwn8w}q|><};Gn?|%Xc3=+I zt>EQyz(PtNxw!ReOK)Y;1h}IlgRGIWv!0Wtrf~9^%ZW1-I_ZjJ-WgxYqSDx93jggZz^7tzGDe%hMQ zJ<6U=W*CTy$&L>WLDNe+D_Mf-hovWIx)n_Zf97xYM&Oq}1RVByLQd}CesQsDdNs-9geb|5AxdBpgX}=VL!g8Zf)lV2lYz+&Rg(pdC1{H_ zQ#89LC-mJ)KOCfyohvOfb+E3>4!B=!?8UZs+Ygy zkBzzk{HdzHERGVquZn#6!6`)w%Pc#8w8q$bwxY)uKNL-wduv&3l`Zh2^)dXQ@d(}+ zzJLJv^GW?>%>;f-Zxx%*%5h)h~DZt6%?Dzy3dfU%w=Gk7vKj_m=5rZVr1Vp62QpFV)vvLY?2+Tu(UP zfjb}PTX~#Iu=D$zFN*Z-{mv!Ss-EZb-qGxTUJ!lu)$jb*@H?MGKs(?;*@cw?d^3nB z0~x-YlQhzIq}Hm^q`tb9e|0PW>Q?^Mt^9ZFR!(=D+N{s&R&K}#cjQ=}5xC~SU^&j^ za)dnh@*)hDQd!o`Tnl7bNAq6v1v#3}<7RHKj|Cjfdy(HaNPX^c zHdoJYU6(F{MX9^F+>5Nkx%mvM;Bu}v)pR;{W$!z7JNFD%&GB572jj{b(i4+3l?Bzo z=nZ{(GwNpCtn>oPZ@wHyEATw}zN-6FiPMw;vdDc(eEpW)sKZpOm(s1VU)5?m^V&C4 zX6uFadSF>)xq!+k>VB5aPzvC@>mk^4^^-u00nU)|6(nB5y>Eb`sk_qLsRtXYkI9A1 zBlNhG$z=f}$9c-fj`Q88z;%ilqU#i{7(-dn!|TgfFrO7*V$e+=_hW~CqyCJ@}g2CzUoKO^d&catj!vTk;gsD$P4cC6w3~4kimgsg}CFWinLdq zUH+ZjH@wv}BDH9{|KL$~`%!bdyU}VsXhucCwxdC&c`unTwg z&hj~N`))jPlB8GZHfCMKweDY7&OP^U-v3zL_!@*3_EPt?TWcd{me zkWSlK2W2woT)~~{p)-5|bT6as`k_*h#-n=wUeu zAwa*EWqhgdMm)E@h(V12H!aStU$8)(z8%8Z9St?QUqcaeCt`|%f*%G=8MG4hv;{E8Fw#1LWz4^&R3=g9gDRQa}qqBEl~V^?i)|IXY8qX>CGlkX<86~^0`BqQo5?)%CMRf)PXg%M~+X3 zxt_YN|CV{gHL z;P;FV!|CtnFu+{qKM)d7}sK>W(N3M3yre56T!s~P=9=^U5lj%ZyHYi>CpU75>! zvG@vi(VZf2{Q3HQZLTONI0H!aR+UqHUzl~|=t(I(NR`r+FFB*=dfh5#C+^qTkY48K z;0bll+K;LH;B^en%?MLz8)YR#t;RPhf%c-bJBd4>>hC01QO2LK&m9!fSU*6kszWMZ zLKnVPajHi#hq>UsNuW%5x*xzC#KU+>vubWgw}~pH)*b&YEfrBUYgbD8#UqnA#F3?= z+wHij47%J6k4;#n>n-gw`rhi=W~2bpxR8qr1j+R18Lj!VvD=DexzrUble|~~4N=rI zIo4Lyz#c|kzu_QFc(}hbwl^LHT^OMcp6(f_-$huG!Ys)uHNMu2?fRFk&(NekNO}}e-Q5x0o zFrG=mF=r`Og}i4aMDa42gjfVt(S&ahD1bSP2jK+#mE*qS`K{>BEUl+ZFnn6P9ZaO% z1o;w0G~Vg_`EXCCY0S>QjDKdL+1ccTX;ok_@`b|u#eT5(*o&I!owFK4;<5^btL@cE z8i3op6qj$icnPEo5t;f`o}&5;9p?>RWSJEFt9Xi-s#VN=nmemg3`J_+qkNU;ysO^27AtQHG!;}Zu69Y^|k5H_Wj{neB_H-u1_Yn9wltDjzx!2m> z0k&>&P8}#hHJoy40Oev zLlLJP7!PV8Q9v);E`&q|C~dDlprGX(DmS1&?^}g<0@yI03wy>lT|(8a>ClzvADQm6 z(>-NAc@kg^T#(4)D2mp`&CQ+7nk!8M0MR;IVbZZ6{259U%ZTv=X=|D`1WBAjmXPN8 z$=#;yCBy&^Mg8I2*toXF1vZOLyZT z=O-pQ`^dANV#JaeFG;}><`bkiMnVQas9*^h2_f?k!7E1$7xm2e2a>d)llZCu|1k_U zMtw(}*izj#P3--fy3s-_UlPgz?1da|pv`J|qMd z)k1xgvM$CfjpboSI3AQ%#AOHCDUAedOmBZSxdN4p5F)3o%}4K>wXAN{9v6s7dFtVP zRO7o->$;FO&D7`e{JW4}ug6j6)H+Ibna|cj|qG3#*W%b@rf1?W!QkEwiXf zjUG3ke^%6P)Xl>!^?S0v;g1JK*Q|ywhlq1o0wdviKK)MVd6I@UK@SDv8_ZH^WovD0 zJ*+Q{nypN|%O>aL&~X(Mmq5t#P_SPVHa$pT&0X(NDZDPlc~r^~#mbdeA&Y5uc@}D^yfky_IfK z;+o{@F_9E$%bg6bT;`PYy^yO4RaWAS$I1;uYs|z&qwN+4>x^euNfvP^wsb+1 z8<%w87g&W0118Ab*C+lMy=$ zu*daq2~eeH>~l82(TP1v&cxl2G+&U%6*W1xWT< z$yZsscN^uNoc34s-fu>|#}eLR3O?%W*QH2W$kC>dw0GCa6xO9kwTVn4A$1Jw_`#et zomv`<*?2sNF%w&vt|apaGM`2)*4i4AE9>22UEHM#6I$3Jm5F-{(?(YF;L8Rvx2glw zu6$d;p2~b$#bj%W;)K@S3ge0pKchIF6?VVM@vT=Eqj&<+wvX$8D;G=sb-=D$mn+=L?b3&z^;7v7z`Sj zkbLmK-kGqc7VO-k8~PeK@i$WkO*oDp#Me{hJYz*@umEYi2}(NaGhC1>ukZzNWy_z& z8-iXB_>kZ?MCP8F^8u0Re~Z#F=C@07uQ5R?0?c)>ne%PKlcr@h-ymMg)-PV`nW5(@ za8TeFmdAHDv}AeeqjTl$p7S!YaLRug38Ibr;^e%H1_Ng+h}dGNvgxV3t$ZN6L7R28;)e6)&eUHUFCHSKkZrkjE%i>UsA;n^^IC@ypucL+ zZnaekSofLK=b7ZO6FE;GC&=&)^-?If=nXDm0`(!Lrk9JHy#RR#s@*a49&%|HM$|lk z%|_FG_gIUXCn50K+O9$>3QbM!N$V%)yUfbujbJQL1&1W-D6AlMc8pG4kE~n`AkClI z&!2HH3wbv%7>VEkc>&7V5k=!FT|XOQnmuLqC6_%dh?z>1ZIYLNkY8ox7Q=5z3+TS` z9nPNf*vHwx5u)a6+#W6h2~FMyne@k=G?uIw4=|2>A5;I9qC z=$Wn*;_+S5$-|(D5=Sy>P8r zW+QkE(#_tU+m5R-XVNh@XJK8-3l)?l`(f%k5~;K2o#T7zrpDZTrkT+LBPX$ozJOU> z3$0Y%YYP%41QJgVl2$Mg4O+Xz{XV_PsBEG;vhMh{fxqy$JTH>?#6A;QQ;GF`RL1m6 zk~QoTnX|R=GMwm$E-uuDi=*BdZCSVmKQg#*0TqqSReUJFhO#> z2|5^#MN8`s#1wrs6Hjun$l zQN=`FB`H!Vm6xgWFm;Ku2zQ<`$mZGh@DT5=9_ zDoQ;Y(>H^=7t0o-=`_nG{x|Zyg+3z;2ncEfX4{_AjJVfYwV+WsB*}h{@WysB=`8R&Y2%GJ&31W_2Sk z3c4+^v72ZItn4?zN(h+{Fv1X>R8%Nr8{-tB)jYfVeSz7_^Zl0x``@3RoF5&ZouBSK zKR7>mbNKq8UEDCQ&D*2B?_M38pB;1S7Y9cNZ}!fP-+0>MfNu}au!p~)*AnE=99cv$ z>5!eeC1aY*s;*y5lG#}5lBeN&v|C<_@7CUrpnj`Zz;SQ^jmWPhRqQ~i6A#H_&?vtP z9)b3b+vyf!qbwPf)kWPU($ADD9Fvir6zEz}4ZfG8%)%nPbqkcLrVKUlOsR$)yX{L> z`K47!Y~)kx;?jB4*&}h#cU_&f%)fr=R}mwul^U#ev*uN5o=N9XS%;I_QUy-fxDg%F zcW<8W2d%AU%Pt2z>37$nUJQxhq12)H6aEkF8q*Kc)nEm|p+cy&ivJ*>&F$7s6+qAq z0qq*7cfwTVr1=xDib1e8iULSlA@=CrpPGLg-Gl5F>-TW!hJx%j+u|FjifMhg zWBv8O`s-n#Li#~t+g3;;Rb)wF*YnxFR!h6_;)RV34fiOzUI8MKmx*iZ!mj!PnWrrj z^}#%@f-6rG%089X-UwRuoTw+k@i3l#V|@da6^tXzITDTYT>CaZ;RKc}^sn2scCcbxNsFCIs^CZkZmEW5dzEv75!vbin_|Q| z|GHy*{6PG!D3U&U=)-O9gT895kdyW$7{zCx@i5~p&2g*23dKys zl&;3K9<0tAnmS$3eCrrxT|g_6c0Gp0O3l^66qs%+*i7fJf;Ma=Nu71VPVubD=Fv*v zB-HhF3rC;^J%p}%D`hVe85w74&GE?--M_?o>Rwhx(m`jBkhG7gT^44}SBM6RL#iUI zBY13kkVfkNXYXCN+Q!la!1KGGLaWZ{!PFRo2~Y`jYYIq(t^^oNs=7~3 zEhKCKYHZ6b*<3nd*1W^K;XKLg@3L>wmMj@NP<=wLu7I?)uitHdSMj@GBr<20FUuDJ z*MNL4vXb@~(|$n2l*_$PyDQ4{r@lT3RlI|v4sK&zJ6mv0algbte0FGsYqd<|Pd>A8 zw>wEvE+&Yrq&X976HyN`M_FnVGd7%!tu|cK+WYBV)>3b>*JT&z?Zu>TBwDp5rcJ3WcceT8G(y;%XtL4|L{&6cQ+dM?_JPfLW|ZI>54q; zBbEXQOTDY;663~XYB`G$!^@ET+4-v&-0)@hbZk%o0~i~4zoX|ndq!XD+TLnSN{E1K zl9&ru;0OlsWH?q8tRapl1{}>NJS6vg#0*VwgOuxR+Y31ulNuRVHYJ0ls@j-I$-rLD z;fp@LV-I$H?6tSJnkme%g;7Qy4i7q~Ugy|*xwf{_eqqRu!<+tSa-Oz^Q95p2#y6|* z3p`nU8(s$8`_;}dKEk66`lLt1E#$6Rqu#|blHOh@WQKkYx{3?FD~drEYuK5^)_pIR zRYvF6y$j_fTiwBozH2OzfV8B`x3$;cr|E5Nz_Y7hv%S6~^KWa)FmoDi-9lpV~QfXZF*PnZFmEoymlnT*9M`X`t(3yG$Mi4GVi7B@xPtTu(#QEQx9Jp`hrhCf7(It;??wS9hX>DXNzO z93dJ~?1rf_G*$lv0xiRWBx`2CToVbm{X{b(?YvH6mHwNKL2K>HbHrdj`_eCiCB9wg*%G^TPZd*%irD7HN=Tl+sW?oit?}l_gnCIWbGRDm=3364GZAi>fG~ zjFm4=mdLmV86trWNwBaN3r>q~q15y!4JW;r=^PcD{ImuTa`HrEk&K04qJnKD7*sm^&Z5tr4H=UQ@kIs> z+=N<>JD)QyXS?QtaSjDotfp-z!dIK@MpaNo7dX%b}ikgBDD?3GrD|6r$0D{oag(|+{wstN) zrb?!mh)a$rgn}rB>^7^JipLavvWyQhA0uqMNKyXv@ z{WwUkF%@6-%@TVrMu|Pf`;GVF3LNDu+Y&8UR6o6-VaBsskb&YUsAU;p~+7j19FYa7K+*aAbyeea3?2tsrx7#b1*w|0nb8L9UHy%}QfJPJ~M2@Z#?+vqwPg}o?1-x2t0 z^>rk~>EzG*>wkW^_UBhG{tj~LS$ZYb&=3Ff9rkku{VcnXH^KW;!xu9Xa3!YdFDpGp zKTJ~symfIyz=g1Q2kXFQO6ef(?rCrl$~`b9-4oQk50|diApV!YCYpITTzTJF6$B?; z{VhCS{i|RVoo*71#;Yfx*!xf*)9TOt_&n&JQP!Ds^$-tmHA*{TpaU8wx272d6?t^} zT#WL9rlc}Q0rEgole*%g__XmtijKqC1xLaXNte1;aVotX8{#I}ZhGs>AXN-2%Zam# zR5R@c^)*!D6z+>#l$vR+(--&~x<(OZWbSy2UZ|MzHw9}2%|(z`e^hE212ZcigyKu4X7GLnTR!!1?Dy+(i0tRbtDpiptn7ox)7BaBA}IJ>LkJ$;A6) z6KToh%dC85qjiw_=WavIQ$j`{+C#?B_kyLrSjY7gf(FA6%qI&b!E%cxXjBMs{{$@% z=8rBe(okFu=`TvaH66|vn0d-_#~bj6aXK*n+6y?Zynu6S0p~L;pvw!$%(?EAyUWD` zx>(jXl4EVP+Anepi&pQwlZAcRtB!Mhz?Dpv^Odo!5}fPZznDG7xPO8}W?#Ti-&4=5 zz7ZWzYu%PFaj4!PM{k8>dRo~4AtwWryZPOzN`mYTko%!Q{cd}wO`gw>n!~`X&1`X} zj%;0KN?1^TP-Rsk@2hb|d_cP-+?u0=bG=+diIJyVYIC!Zh;)gPsz11nV~XN27S=Uy zP=AC&;1U2LM9?xN0BA#m#;7ex5x%?@?X#77>laxUdJ`8q|}32Z*W93IDnH3R;P zQ?Jjtb2%{UvhLr|FBs!9P^1Sx7?t%MwR*4naUeM>s{`=S)`pzI*idgMlu}CHv1z|m zAsu`*xPYF-rmT!&2xTMklV&1fFb^>6bg_6~FCah`M)y~YKX7`7!6E+|Vzzaz zaRIY6&hEpOYKO;SvCPW!{5zGT0OrZd9gC!Rae>a5_{+q=U zQ?jW;3T6?zOj7WNUGg+R%~)i20gEgV@1}U){x3C};7L3Sn+eQhK_-)bBQd^QeTA4b zO@Rd)T~BteV9+?Nq;sl2G_AjuZRK-KrMA(hU}8oAY(&j`_2_P#j;GY{MuT(5yi&Q_ z0sM#yj?D5grS;*I_sO);ro0~ncY|&6Gu3yqt5HrswS8A^ot= z!4F%G41RJw?T)SMGhRvHgk*H>YYzS(7a~DRS&mq z`Qh`$Eq!6VUs&%Gv)(d>G>uPY!<~#Xs1!8z?3iJ_z@2KG&>m83Q(JVbhbv$jg~1{1 z`fToTyiLt}y~?~TW>>g~_4*uZCN@f?gZ-s?FPE zPo;4$yTIAqtIS^&`cKo*RU*j7k1~YDeUZ%M%lr$2uSbEK#w(qAF%H5J#0gF58JfKf z&cptXDi5f(h7{egtL=)xS@(x{II@HURec3zozyf@f~@P14I;X3Hz-?`B@04sj3pnwn%@qt}k17+DJ5OCE~I}uejA7^_uhNf$-XEzJ1gz0g9hJs{W^4 z`_tz`%BNPKzFXdrt|ehl3{=GaNoVKm_?O*I`|N0E|M={9XAi>&vn!SbAw~1~6osr_ z5Hg#9bi++z=sSkL2BM)w0zPF>_LIcYrYCh{h3Rn%V%-=#QWtc$^fM5fbn#RT)$@c@ zUibeFNPX5oDj>9o3({8%HBSqoMlR`=_jpiM+ffFoCW1NvHIse2CcK(oPX$}m_Q@%1 zMe1fTBr7NP++jxX@G_X011GKyG-Z7F-yLWQ;iZhwSWIED&@wfJ=Wa9-E1fY0RNhi_ zKTxC)E+-$Bf-qfaufJUBo_FEWqyFp;#Gm5M^1Cs`JhJHkdgW87qV`F>&DpM1@k<@Z z-^HouJTz&6ozk4Ol+Hi=KEoDHlABqhXw4nOZuABo1=s!Xer11m{cz<4Y@zvJWBMkp zw@f2+-AxSp{Yc#5y5bfL(<<3Qo_5I&8h6mO{FMB*PdN{J6cG!*d#?|UI~1rJ1w)mH zf=%O?1xL&)5x0&$7K51pqWWvT*0(@>-N%ca1$mggWw;6jwK=KhtTaxC*9z= zV8&_O3wG2Hg9hG5F6aGFybG_R5$-`-AnlriW<&5WUAv~OY{;u$3Gt&IqI~NgsUQJS zAKe9#_%_v!oMOAM%YkU7NNg@%x!?%cH37US{Bbe~eONFJta~k3b;_%TuT{nKBAxD3 zB%)jzk47TuMkCQ)X9rM6{Ik+|WB%HHEEQsmDL|hqF%N?RH7Sk~oS>IZXaeh-TT6md zzp)#lcOG~IOIzMol-lE~O5{wgz62LhiM+qN_hx!Y;(bX15XG}KVH(hha^o@+q*o|Z zY)+tBePa0Hvy~-=!RmwJjMa!?Fie9p+FWlZZFidNh1MdTHiLh!I>QSnEo_x8c2bi3 z<$-`7wtnUU!@KcNFg8}_?eCTpt+O-nDgB<0%-y$)^VBu@{AIqQhkU(|f9Z$^*%<6l z5oXVzvO{LSn5&);-d}Z^^ey+gcVB#`;-G+m6k9 z64%J(%C=_T&i+aY-J0LNPeUVR6iG`Du;Y}6A2N4DDQaOA*Cv^ZSc_Go>SzciJ=p7` zQ8?^$-b!%>5)s89Rc{jXTX5EDH*7^qOe&z?0ONkgH=rhJ!LW- zL1MC^l2Qh*q6ZceqDLkpYT7R}Z=xqt`BQEJG+x*>N)2faAjFdEw*4(Ob<_QVzV-PL z-{206ng&Qgg*0ZI^prkLsGwe9(t_wC4TL_e_nBR*_G9e8Y~SOmKJ%9rx)g3AM-B0I zF}0H<(Coru8wJ%Ps7q7y&YjNpg{Qu31D9f#^r!2h!f&dT%SLi=y}%;b%9ENX)A#lP z{BE=~ivEFjNY^ufRX6k4ENPfmt(Qn>RhnSyRkq%?vo5stMXoURQXhom+XFM?eM*|diW&sCo^#MwbE6Ims6^c>THElE&_mM_{_^Y0I}rW&@`== zSw>e{%U20CL#w7NMQ&IqVRf4X!&EFO(J9cW1|38b+!t|=dQw!e=p=YmmT9(1IdHR_ z1?L2@sVsPUvFXPb)-@z(e)Xu*y0c)h%>rFDc#ZevC3u?}gMf{RFJ9x{(@XR2(k+LJ zDVp`0SWNZpBJw_H9TY^GJt1(4`=NmlrqQ2l0ytRD9>|u(%`RDl&dcI;#9g*92!tcN-lk408&-H-W3Kz_5q z(BD5fIomz?`|;_~835$j!QrnvZx8m)j^F?E_F(tym;Jx{GIAU|&azw72ZAM*1U`2X z^)goluY;)U*j)RnHKA;@@}|cDs!2GA#~5#$crm0|6qGO;aw_p*IEDhFmi&YJ6pewO|Fnk1)^2$Egqf}{~moow}oJ$yyO(e!R)u>xxg3agCQ>)SoW zW@djXmo%T-LS~*phH~c^rNNMEu}ZVk&&@TB1Rr?`EH6)mE}HygW$m9#;##c0^@MQr zK~CiNg~?x2V6If0H)_-mwRB$$i|VE-KSb|Jh+`-e*IW>r>t^0UU?(ir`f69HtQ_PP z)0;Uj4JqqbR~#05cw%M%Si#qG(XbWxkeGGerMgrfyGm@#b|x9l7T9VxGB_DIagc}3#ZD%Z29|P+Kn`gyHSwYCWb~rb*xW-1~$;U8VT!%JuImbIc7OuI&SS-vk zSGh8Dt4W>68)-5L!Qa6Td`^56^kL`yb3snPp#^eEh&{YUq>Tp12X*=i41tn;-l7_Z z3PwYaH-=wPY}Vxj@&(63b&(;Z5-Wj#-%g@2ZsLV5!VJtSK+bE_!os?od^zVro&5-k z8BIjD!?7&a+>PVwh>CcA=mw+UoQ(04q@UUqw{KryoZIQis&2Ld%~o^ygJF-Tf(7S~ zz}nFu$uKoe?Tc%gA;_t^m@98v?1oBNvo_c)%w^O!(9ubJSaKrpvFr`1a6^9NvDt~M zeyNH};}bDEq>>qC#z*vP!o($*A_Km`{zsuYD#&PmZ+K)ta-jB>PWlwe)J#%TQ(6$M zd=OYS2EdYi;usj+mt6tS3nL#2fhA;qM$w{}xf#AzSmtfhW(INJS!^=)#77?WT?@a^^Ue_DV`i<5p!kk=UczYDwMdZ^h`Ui`jx2M5vaO@VC|j9G%4(A3 zP>1O9B^VU|5!5b9(g5|=;@_1~n&R(0einA=pWgcBX8RTYzOnHVf4kEU@8Fr;JxO*j zz$hG0rz+Q#j$49~e435QiE=QNkw-*z_=90LBtoZB9O6cxf8&(cqe|gV*$68!gX17d zlqc^Ap^V|mpzqqMkujzrAY@)=N7~=Rjm-|I@|Wb>i`}o>`fv3*|685D_je1M776yi zN+sJNsX-vID&u7!8T^#$s zF6mkX_X9zdhnDVDMbfR^LHVz?b2JW7;Lqzs19oltOnfQEEP zKb9lQ-t$0~4rc`WXKA0k=q5_z#MNgp5s>Ue0ORXCM`?P%fE+J=`1i#W#jCW6*Ko)2 zh>LFv)_vVg$yA<>uA`-Itu~VV!nW!+4=$c(Xp&1AKAyx6-v2ReHt^farQD#Ubnpul ze4&@K&`Z6o)A8lGU`Yks*!yFV$49e=f74@BBKQ1Hu}Cy`D^!bQ^E&(fyx2_|c587P z``$K(^Z0iJSL3ewWrtil^tUfSG3V@ROZ&A_Vx1tp9}J+%IGM3WVy=?WkV}{k>-Ae8z&GJPD?*HKg2>Vo z3{Ta?*(bH6cm_JjCZkRh;e)jKdv7qlP>0T{fJJvj?i?&oP)`0BDLIAZU}~6qWT#ee zKRRjC{kjG6eKLjw;VR0X!ymy`G)`F|Z-(W|K3QE4CTGlu&gr}1F*_q>(yOUky`yAA zIMfDJBSlG*lL=Vq^pN*^KH-5l8|!P?rJcv5q!)r@HeUp)7Q52Ss`a8#CKerrBQiv& zCZP4che#Kx)m3UUKR8hm76r^G|dql6KJ3&zG-%t5s^36UTrlU z!{rFq*Cx%t^RjA5NwS5SdHv$SIqmY!=@^T9x89I)ew%V5tZ!~nssyuzK3vgi9FN$R zXiie?;6_VSe^F(x$(gZ2a^XP1yXJck~Xz0ggM@Sr;!G!K-fqBk7gD( z;d^OP3zS=cawL(xMq{HDXU*rbCer$b8BL@|uo!Z0|HKvP-d@jzx}!NpCh_wT#4z+w zT6^%1o_rd1`Cm5p@E>5^!C&u;$9Mb`qZWHtOGVl7U7*g;LjbSxtmZX#1VaQ$KP+!M z7@OQx`uB%#=RY=>t;)w{W;xHXVbIcbOXj_Rb@SN8>y~5BZ{1nVvmQ2MZ>u#H0=PY1 zULCkt5UVwX#XwrMDJ&G=YE5A=a928o1%O}A2KBtQZGmuCdF%xM-1M;*2WgeZUI2&{ zj=ccb3cKb|ISt?fA*BQFlBDvrDWm?{`~5fH`lo;jRTo4H8Xsyl~8Kw0HE zED+x6&S4Rdmz~3p*-0z}2;oLyEjzF1TPOh57=IzaS7rP~0$z>r7XozF_&;u!dbZ60 z;O=sW=2X5f5aepkU;#i^bq0$AyP7jt0N`b3@Z)y5m*hM^FN10hlg1*!uKMVU0J#dI zFA&_SkG=>{%aXVf|Jo^F_Qk&P-0drlnnW>cajk^#m?e|UDwOcWFrq-kZ`)YHY0x9C zSqn9bR>om65U3C*!DYCenMEy2NPR0vrh_k5jCxiKS@O+koyb;yTV3_uP-+K^J4z8+ zCR}T&#BNb)D>)iccHR&`s%chQRN+8Il|`z42*I2Xho+ng5pXqn``)S@im7ZY(xOp3 zTZ3XC(hEX%756C1%1wMtcn3J_LlW24D2WGA8eQB2wu_fsk{OMURzjq&0a=f+b%+t? z5C-Qn>dKt*MiLo_xH6Z(nbTb%L4Od_%WP(sX$9{L#{el3Ctl4{IRecE(~W6eC%`i7>bMXLH%si(!Q`X;QW zMX~z!uBXMcTE?*_N4R>XwI{^1dUm)cM6r5CyC=l0dKSJXM5@Z>z$eG1I>y8&0C7N$ zzr>|Fmd7W=q&jBGC&Z&VHq9r*qKXF4r^lh0%%@L@O*7eApAxTTGR!_DhRtNfeM(%L zHsLJRnK7l$00ZmVj-M3!>KdA#6!Yp@rJoe*>YA{h6yr)J`>e5T7Q^`y;@d1%_9w)+ zSxoXzh;y^p@1GFsrcC#F<6TX!fv3c|nl1)UiElOi5uOs)YC11GC7u;e^+|CIlah`g zN;WfbGqIdp+u4~iFP@#*C2UMPh4rGUT}^!?rpIQ<@9d!89L(F%$9bSK0)v0}_Oq=9 zA#JX!$)=e8EUPh5yw+;6vwaq4V^V>+u4aa_nIZa1PBYtr9H3_2Kr(a`ZsHW9-8045 znHTk(5x4%L{s8zp^P-*^8rKb`TLd=uipk*=i{Nua5m9GY%do)d~z5A|FKf=b&@!46KhWj;$(eaxz! zFVfDms%MYBk6G2TLgZN@XBUIhsDLZl&ncSY=ZViVuIL%#a@`d@e>|RXMb8U|YX%}O z0)OvH3F35n>vP25N37}D;_xhMdhS^Kh&4SYJf0!0dm)%yLK3H0aGxa>&$gcDi@`P5 z^X##Aw)H$K%&iwDUkPjTH8z8OchaY@`C(56i&E9N=yDj0p^zNJiTaR!(>IFYQ4qZm zrVSm)Zgn|FEas~I#NvHESg|SSUB}L1;!rA$s#>dR#b0~9a0Jog!?8CR#X}W|j^U*Z zj8u=Xf;@-o<6J*yE>}$XWo9hB_>xiX5D;?au(fQ(On|nq3y&LYd4@UPtt+ zj^qGJwev&0rT8>chuNN&Lb6H|RIN)Vs#?uBVcmi4-x23LJZKsj*ONanP11fG1|t6& zCREN`<7OoUX2i8I_7Mo{z*ITK=Z>(Fs4o~_v1qe88>1wBlycGO@Ft2Uso0#Zq|Uv} zVIsogfo6B>r?4A9HiVIpTZ5+~n438Ao_8TQMJ7pkU=eai3&0(iXEzA$^{NP_V1J!C z3!Z`=-2e*QFM=W=a^2@poE|HSO8(s}nlPL8CUL8m-%< z(!7K&nOfjnc-bg4Z6&ZkQfKD4P!RSLluAZ)ag;pvbvB`2sA?<}pT3H^S6pW~RE3H$ z7excG!=Bl)OmN}hOQ@H0p&R_HxsxGWOzT}=P-4s!T>?=3;@7bp?b?NW`~?!`I%J5IQOF8zJU?_>Tu=5_+M z!+>7hCc%h`>5kJ}om?9AV0aNrpUJ|qO*`HgimCzC;zHHN+f@@8RJpSnMdG;kgI`NK zk8Y;+ovm4-S6IBXQ?B~1s#4)M#r3GBR*Az7qh6){qTbXZWzgMuKki;r^)stiRei2y ze?fc!xF;r;5*L{<@Vr|PFa`i+;-Lf+_snoasE=0fBw@1Q-3Ut;00zqPg3&O7f*R4k z0w&DeF{GKYOXyWwL}YD%D*O#RT97N}Kr_QrjTLItaIVLJBb82`mkEdF?hf8;8w8}_ zUV6e8(P&6Xs9j;N1MQ z<^6Oox5>(gCabw$hGUJWka3B#GhwPIuDF2(D|oB1`bH|{HeK_Ar`hsOVY{Bu{`qJpbn;OzsQQI+=%{I<+JvfL2q1l4Bst=CeFH z8Swb#m%Z1x`GTrJo-jNh6sQSyG}EOH0I5!1?|Pdrw_g2E3zy1S2czqO-}IrB_bqf&! z0;M;DTxNV@KsgDs7Y=38wYb}zh<}6#)aQ$ZyjEUA`Znr90!SLlBJf}9$}gEVbjNJ* z+y%s?>BR&th&oA{IUW2?_Ngx=Vyh5@c*&TZaOiz7#M9p!SL5+0-CkYog*Raz=yhul z|4Z~1wBqD)H5{(I@2vLXZo2wgc)t4A;3nvFlV~(vJqg9Q0RrSvM;Y_EgrRGd5f1AqD&Q zKYe)FjDBKgpvf}r6ztx&`X$U(Tn$?N__9F@Yr(P_Mt7}o+(D#oEM0|nOUujOVwS+A z^^NxCR=D13wKiY8YHw}6P{{|Kxd6+_7MJM-@Z?{$*25|Zs=g42j?L+e#r6P(2v#O0 z9`sv~7*k#y0;tX#h~ME30T>O`!xAl3r&!7taU_tOrKR%gsk`;L7?3ah{|b|M#oZSi zk+-8282ER+E-3@5cn%_scr}O<0C>@^y|%t#QztnrkuF?>MC)G5>zu9@C}irB{2%l2iDY^bgA4j-tf3~l{{EQ zCL3YvvgP>%;|fgV{89njD|lK^1v*TdVoukR3d-pr-w*_zYbxzHEZ^M&<1FV=&Ikz+sCb7eov7FWsY z_&TAuSA=iEVDvr>F2iy)*f<^w*nwl{l8ppE_O8U&qN0Se(@ z1nKw#4x3j%z9C-v;;TlJmUM3G#_;)e3AoLm?3-ONI17^$g(R>{Vby zuNx%2G-F7esWT{UA*7<;X6O?E)lG!O>*#H89?rR60H=P49d{<@;!uNVnC&?S^!vkZ zFiMq|7ap?L1y_ZOsH>=myuE?xeI*_O2f&+7x*;1^FAOs?e|~Pdt2Z_a-HH=(EM3IZYFkwLs8m8T?bBC}0tt0j1rdrr1@Sh)b@7W#UdAu7b*t6fNXcn4_#ws$`WAHTBW#Q^c=di@|EnZzA@n z|Jf#Z8t12ncYwTH8zlH`@iY+lPJ|*t<3=Xyw##)V=;Lt9Jrx9PjWC%eCaZ+L(S7 z3uuCkn{wtAdug%_hT%}262i27y;W{=NM)5R8Cwpb%PX?a3HZMYL2*N(Xhi5f~}rn>mr?x3YE@@gqIbPh&A5~ZLM#A|kthARRR0Y?G! znp`uM7hx@%W)k$%7+unBuvf+fHuJ+5aN`yujH0n}&ir3Sg7*$PjLhU%jA2a?94u2Q z)c2Fi11hlBU$$RXQD8$mQeZc}dUJYu>>UX*B6BK-!9j7Gj%4RVM6Jy-EA z8_ps@w_(2zmmw2P#r3DJy|B%@nV6}#w8a^$sUuv#l;MS@vyCjh%!Tt;J!$f+(II8t zPEjwJt%MCijh;8dJ!*d*Ks_DW|2Gd~V3 zo!rzV@J_CnM!T7}k6rGjZ=ew$A2>D*@LemW41`dKWzB6*iX`m3L0*=Kj;On!1L_i@ za=wb%>r}WU)rf#v&iUva;Sge%<}r&;WGBXW&bL8w8IsBhUA(?8i0g&423LX`^o-}? znf=#!bQulDSV;mQi(a+Egx20!xJ%igND&Mw+`<;2hMwaeXGjV=I? z-OA+?0cXC47#NO0d(AGW(ykl=B^LXxGeF3GlklIDNPG=G)vldKJewB6-i(6j zfFyPff$HKSlG~tEP@VMR-b}e67#Pitw#uj0e}+j5B!@0r*7$hUwI{*19&0Y@sDK2z zk4tuIOlrz(+K-%zyqjgGBRj=CV(os7X}$3I4vsfEusa5c3geRQ47sIHdJJRo-VX?t z@kEH&AXX$nFY1o%@nx?JTF8p*bs9Tl0|v~GBy`MslHD~pCuC^3bRhst)1Xc|i%X6z zc%>i{f`RuU%((E+3B)UCNB;|Eo)i}08&n7)IC2~W9zse5dIo=~=W*ii1>*pCPd?L$ z=}xI&Pb}7$X5gAA(4@FK4##@N!_OWjDAf!^Z%rM80l-7;I{1MaE?{27h?dRdEH3B6 zm$|qEbg@SJApFvRFmgfSm*owT&cpPo|C7mWbG5UOAvK_{s*y@KLWLluN<*pq7{$!G z;(X|&7Bv-Pwa;gN>d!<8ic{mtz6cm!1dJ~N#uowOi-7S(z<9iXfgx@tXLH4)Rs6J) z(6GF1X+-AJwRzMFoBy(#Vdv6vu`<`CO>m`}QeI^51W<*^%1Lk@f#zAj%z4z0(lLa_ zi0*Xr1&089)QK9 z?HI*m&GsnmFuNO4*8z`$B-7Q4VXB^{%9beIjg*`0=O1vnV}7=syeZ^kEOBzLAds+GA8Kxx5xS@+h@fiQOWd zn#Ih_&qwo+I7$Z@tF(}USb|TPUyTT;_MrWY(=>vBTS9${4x7YR0IJ6{ndmT{Wg@6Y zB6w>izBxlJx(b{d2v9jy<1|^fD5arW#tR6EP{N0Dxe@?Rl^pa;E#?Y%xdM0(|8*TITC~= z6g=Sw#PS8&k?fbolsQWPfT9<2ZmHK$k>x_fgJ9t_moq~3)ak zhwa*50;E-MeRy=Z?>nHIfa+Wb$G3Q2?uDZyq&Rf}V2q0^?N+}?y6p@B|9}hqe)^vN?k13eZ0#e>Xb|bpZa~=akA?*9UH za!Y4_jJ?|=0yA-VzJjihW8`MQ#W2@ml{sZ13k>f0O>4v8p3)0J`Ob{>)wMVoqB+=i zr^?!=Cqz);dG`TRtN z*#l%UZ=BZ7@quyx$)yAhDcqEkz02$EP@LUAQoPgRZ5G3$$E(38TGbP~8V~x}aV(+y z0XM}KunW@pm|LJmFn7URKl*Hq;CiLr8`ml{+M5UJeedN>^|@=I`t+CZ{x!OhK>Fr? z++Jf?{^+`!zQo^>;Fc0IkFKMo{HLHwfe+bhhdxG!1NsUxa67)Ej4t0pl@(kOwx$e9 zKZ$$2@uz4^nWKlgA$VutFOwl;iIz>s;Xx&jhR2zacVv|Cfe!NdUOyFIW?e_{vo}F{ zHRV(NH1jQlTK0A)$qg*m**ob5!b|M%y|_%j#M9EP^!<7#On1+_$3T)(h1Yuec4eCA zX4?V`qwq{Y*W;vO*FsE$4~zPTpMF82;DWLDRQ9ZjQ>fYh&)q@Aj*w1GdCt+9BA z@oIsa=<+u6FY)!%A=02?*N}Q_yNFCq83qcyR3?S zmDqqE;^F&uqj(q&G25oRJ5-rXb*j49sT>92sHzkS`ORuE{5<)|bXi1OM@dNOudwpW^x2lAKOYxvWFM?_oY{G6v$^?VE0<=rHq;a=V)ySb zm(zE-U1@sec6gsWb1Qx*)YMi2K9%G&qx+nm;M9{@Q6I9IPF;{vnD}&tjHix$-)em` z4O?~EQ%5Km{HP1CaTngz*<_rAc$LftM$#DqtkgSr`*#25owsMZM~9u$llQx)M<-qy zL)dD1h1OI~N+a+eC) z2~IPPsq}TJvLYMPRiDG;uXhe4+L47{GYR8#>U~iB%UnpItcakze}X;`d2&0@dG6KM zE1VgyYd8SUgSNo6a^FC z&bC{D8mMg4@x@=K`Ju@59h+df^4!j?U=Ek5eQ=ZFKG2|4(t*l<-it0F6OAr=o5xh> zk1bIpJyMIR{b^HJ=_xqw*anc)h9)tC%^HaT zAA6VMc~{`J4t8^U6+^;ju$HPKfttoX=3LBl6AoG9(Q{pe4T6?08N&W$@oyQHj(q8sBVzKVD$=MF%Vn%GEc{B)S53YX%&J? za9b=Uf$yao7yh=sx!HbI@NQ${rTYz3;Bvn?{z<%Ae)sq9j%YLFOV@{(DklMhIzl>003NrJ* zBNf;WV(pPGe@X#FRmcSvD01UBm+L8h`Qqh9@k^*dn|)bxb+DNfY;7*@DnP{$XH@2! z|2Rje$BP@!u3JiZAZMJouH%IU(>$mcfv&*4tWD#|S8h{tp%eZ)0%25jNkKsn7X zH&E+uc}{=O8|XgTQOr!nXqJ!ynpIy)KyedH-s%i15KWZdELk^_*|!y6E4$$(A&{ME z1CeowrbtpP+l)Bqge@i*Z=#WtY)F`Svb;b>; z_7#hO8Q>yfSE$oih$U$&3da{HNP@Tsw*GH6+uu;OT!?T&eWtWZW^?Y-&@8aha#e|J z<{&1JoZCXYLv;+Mrd6vKQAUiC_@s~Bie*yY^rzo$7a(jYte+_(D8yPXnYVa{TPeEG|7 zf6&XjiQ$F-#PlHM(U;XA*jbWgnw+>5djhXXHIR`Tr3a{1 z4C+CG>WV>`DkN{sU~!ce`UsJV{FOsAGFWS4N+qH5uGt{`BNin6(xoQ%hT{rb;*?a-gw_A>_K|>J$ zs^FduPx@qqcYiXYuotPqIvASZD7yX%T>D1EL&dOPQN#+VPwy0aB@`J-1)fo`yYw<@ zibTrOus|e|E}{WCE{<6510zq7aq^Z%iTJO zFOs-=Q-kX8aW7C7SCEh)Oyxp4quX;9(DUMXXxO{67^tk?%-b^VO{}qWdpYtXQ}B+N z)bbip@^&@KU<%^}*8~*$ORox6^dwDJ8JVR-trWIOq^|7WnGy00R~Ade_w9=XjB9Mh zqr~@_4fMIY(iaJTVIp635-9OFFJ7;9^5-+c3p z_aANX-*2|`ziaTbwb9;ycN;I-->hx6*EV1L$69-HZL2Nb&v_osA3-#NL`>ze{orEO zJoWE0_%Zj?{N4OPv518e1OQ*+zs`W<%0vBr?-<$8CDtp7yVoIdMC{D>{ePtJ3tKF) zUnUv&JEX$EmYf$mOl~kAFhL;cAUoJ+V`wjQ@kB`uR z5={#Mu+@(*8$Nf9ZMXkt_+KBzZ!K}+-RlP*I~5;rpWS|(h7Ef7;2LlM70NC{7;=za zHoXM$Von?RG8Sy%zdni&9%u*t>mz;#6~TlMkUnh72e4IgQqJ-FSjAqj5ST%B+_A?U zLgHomh95NKI$hIKeTsQ;dvj*;QR&>yqhYVH(O!SCK@C<{1c#`svEV0 zPcf5>)p-bw)TcU|S~!TuVJ3YWZ+Y0a#F zWfm~f)A&i8WWJUa^j1;@$(X9j9p`Qpf(Vm8(-3>(nvXN#?hWzV*D4aFT`qIMWtTzy5kOy4gA!_V1_loP^yQzW0jboN_Fw zSYzeJ{W!j!K(f+C<0?+aX5vqy6q5k_)>~|OG%T*h#L2$)lVlk0-$5=jU>mYJQwFe` z3ZOZ{QdMixzf`Ebgg%n zxUB%N9TPJRIo3+th0{@tPP{(Sf?cQ}8bf_PDt#IW$P5xoS0N<@)eX%wTTO|jAo_z? zbXRpQ=oNSvXNE*pZGP~PRA7C)QfKAw2D0qcqSm~I62nr3Tk0Pl%B+;5Hjm%rNOeqN}@q&|>k19xtMh?2j_ zCpwdpQQVCvowqXP zpU}1;KbWQNsE2P$Mp9(m;*Rqe&!Eiv!)`E2CukMJGgS8mIVr5Sm&NQufgjTEASF|P zMc09DN^eG@C~TH9SNNbH1#dV4=g?>IHcomn;0H;$%D==85Sg*mJaUz81W2`By|NA! zGtKg5=rovybXZa+H0<}K4mcTxeVEZdVkn|ZxhcAVK=;ceo{XSEr{T4#-tHJQR6jkC z?7%m@7!HolcJ}tp-tE8pY5%12=HOV;bw&VLOV`FR)}l z+^c&P$CfOFdOIzz0S};BdmtF3SJ4PPdIdK>jU6u_*WV zHhTtI*)${!=-uM&rBi}xg=ETryE-3i&`n|ioNBc`NaSN+c902EYz7{g!F%-{q5qDg zBGSoMty?Sww+up9hW@^QtCNGn_nm#;Oi&wlyOU(QVA2M^qz8Pn;u%VnBmHG2(=69B zILC@EyaxBwic(0P9VGY5W-ch?blgJF^lQObfIV3T%)@Ki1 z2(@>!gAz-hrVTMaNl8+KE485+Fk3(y`!JW**EjGk-frhRe6SxpWRA(Y+9*1>)q3T; z+1TS|36;JCiPjvoo9U5qwPoxMO4M|fks|p8<7uLDF7B4i)q>R5R z)m*03} z3imU&1Kj}YmyWM;oKcW2B2bR|4|OK*Ky?4W`akOG18E9X$yB+S$ac6z33CBb1A(V& zei@r#PXy%hlGK{r8TTO?S6xC_JgCCVES94O`QOzLEkwr!cjEX?8gUds^E?)H@x+6aWCEk+7m<+3dF}AX- z+Ba93kAt>SFr>l7q_6TVXSub2G4Z-+raOGi%xIm3q!f+_G-bvwfq0l7KbZ`N92}g4 z-B3tMW`C+5bxAK6_~1gF)ddjsCfaLR|7@I*a`|q7XF-DUX&?xEBWzu^93a9|L$G95 zPQ2$xBwwb1u(Gu;^Mq1@_oAup-vtBCU&d@dtAG{YfxHqGuyt8+bp~5UvG43)ilSdP ztf}xfKg=oq^~;AU6PtQnE}P-3SLPb?a~ce?^O|Bfn6`}C280@Guni0Pbqxc9{-{uH z$uP~_MITXf7@PUZF?ks{Z-AWbpyMWbY9@@!v6Sh}oZ{TRdYhMP5JJ8!?W@L@HJU0F zfngk|I##x#i_+qNGB@cX*O3J?Hq_aW8vy~i&U>y$ZK!0XH6 zV?$!8Cnsl}qupQjPtW##KG}J9cF=)}7Ki)0r~7+8*r`IT0Le;(Zm{#0+UwuYg-QTc z1J!_}HJ7S#ayi=Gw%!}6bhBUSCWcxmaWHH@GK?6!V%BvV0wjPpy^{cLZ9r{NQp%6$ zEeYa`kS#zAnj~TF%#9w@hho`H{DAIaQK9(6^Kz%&UeBa;o{Em{{lQB^%tdnwaFb!o zw4v6a)AmKx-J4-9EB-W#_~ODb>Q_xoG8( zPIR8bJ9!(0D>R{?C0VO4oCsNng@;F{ZZxa}68Z?u8Bf{O1GepDm9G7elE^uz&70(VwDb@YJ-K47zyB^2?crvF$j92 zQJTB2Vu2jWnI{f1jfd*w0a;7#L{6=6jZ3p}Q?`I75ki2W*5%tX1q!%TpB0o)(CebL zP)==*hVh@?zka>S65G#s)U&3P#3 zRb+E;>!Oiy=a3U(t4B&k9y%jbcHQTP`wCi^W?)$wdb6 zfuksaqOLGNv)-wv0RJh8gC1}JI83D|wA?*%CIc;T_5m>r>p^HHX(;zY)`*}Jp~8UF0F^@#b0Z!ZWV9sA%5QSz z=rxwA%NIN32@FFnM$rZI-j8 z(n(8`@dacf6(lQ${cm}{!E<$02Y!%I@1g+=De4ML9q1QU#{(0xd;8?2R?Mf1-XNs* zwxJW3i%xLZtNa!^LT8ODVoQeV@^2fIaFGqU}jYh)1gsK4PEL| zl`-dM5!7{hX2(awr(nTE^w4ik0U?-T(e8T&r0|T{JBVO1Q*Dwfgoy`rk8gAcDV>|t zPGok*=FITB!Hlha$S~$wjuXbMb7$}D_~_)c&Xv>b-Y}!4p}gUNIdv3BPwRka49Iih zh8OgKDEmeBtl8|TI<$m#PDPT?{dS7&RSF#6^Vco-wz1TS2O-HC8LuDqQ0_-?V3nPZ zsC^4|siB0H4e~@8a?=PdNWG)*jGs*yp+m68pv}a88ls+ub;>th^|R9 z!VDD6CW%FjOYtJ_h*^dx({0z{R^+`azk$n;2$C9Dc;HJZt5wzYR-2E^tB%h*kZcfDl0&8VtxKyFU({}P~2aWS=vp|_R z?Fwm#2sLO9*p&kAeAq5w7l98DdG7r;T>lS*pdmii(fi@BbsJqr;-VJ?m>d!QT7?hJ zc*p*;1EciL`q3C9qBHYdm@Y#gVAQ1>D+m9=75~G@>s@p98*6Ld=ur!5{y?K;bYfu; zhCl#xML9S=v-X0uPjUl#;T;HEw+Y~VZCbtJ$@nr>0wF@4?ku+SYY4JkD0pXER&?`3+2PnEuivF%pN^ZYdM-OZ zXba4q&qI~WkM}nTN8%XGlp(m++U!VET}nCny9j$;BM-mX$b@60SMj9ZBai41`h{Xp z(d8tel3>#662af2tNRqR;Lfc8_qD#ldx`LRi!Gy%(t4&^6XV`sbvcmE9OQxlMtSk2 z&J%_P8$3Mrn3}Q=TZaD8buhdyoY70cG1kH8!DT0BnJ_}`lw=mt1%iuYU&MWJnL^}& z88or0o2WMdEhg{=Ut2Y;`&B=Uaed((#k*;$qL3U7P^di09)aO}V|B^`AE2qg2x*id zdvSIopd0~ObDig4ncM0g$y^A#+2MbRA9;D(rqeD%`XZIzkk&|uoi;5R#ktZ{IFC)O zDqr;2zn_qz@K&`|;@@usij)MdaWlc%-sOP3v9!JYXR-V3r5V);VxxW&0d;j+I03_(Mw?{{L2S$e&ZFZ{RLQ-_{_5)^sX+Y2|O;wf8 z2-crVhW7|q!{KA7790nVGC+_av(v9m z+4}ZYY~NQ+C7XjSKD--)jZfMQ(~NI{z_zP+#N6Bpe`JLqNUp%+Nd-7gf*Wvy727haKb%>ChOkmPt zCzKT(cEt|!P>pG#YrxY39t%T15Y*V9&tpw7=#R&J!QX(`tx>~l-j!4Wt7uRP)t3)^pTu`TNmf@oMN7<>2kL+waB}id?0+^+GnH`&r06M9j*|SXm ziMY*5(X2Df5w|%|G;jAR7+!)z23?}(5fY^F{fJ3+57aZTnL|O=;^Z2fgU&W~PkR>a1akle(ChS1i` zBjr69oZul<*m0fG1KYqLD5?i(#7W`@JnhAn) z3Duew_BU^|$z)x_5WzfVlm-e~I?&>n!EB&lUbQh}%%Bk{Xx;Pv=rMzpU={{=a-ii@ zl4d4B^L4vL$7()XZ%OAK^XZEg`I?%~Hd-3n&F7mf=?YPV%x^irLIdZgS1R)^YAZg3v=n_lMR9I7w#b3Ux;&G<;BHk2E0?Dn)z^af9Ds<&~<-Z?so zhjV~;-AO$#H@~X~-Nu(Q0=3aYZCEzGoht}~#59-V(B0HM5cA8rM`CGtqeUDoB&3=D@w$4Q>4@DO&2-Gp zt{!*P&Ms#?Zf9q6JMzK;VODjOOnorv`~9Un*t7jH>wiVT2 zOz4L(s(LVQG)W*pOBE11P(?!mbjp$${Rh>I~(ahxh1arH=Umi+s@5 zBT$Gx6S?(b+5+f$6L6+9Hd_G@MzvE+7PaYXe?crKWj+%W0OP@E*J2 zL{2dSAWYI}u2^)CpUA70Sg{QA-1a6zWPVN0>P23t98eZ=wIF|2%3CUKf_;ybr@g%t zBk>Th2n7z&DC|eWu*G5xCi*~+K0$>|iW`vaFGtR#-6&DpnV|$8PY*{3?;^~Rg(+}= zKA_k`kgQo6OWv)XkWaMP>xoSp_VC~dJl`=qXfW|hfc>uO&?69&3 z)_VgaMImCG*aW%|?2maJfthm-E@BR`(+2u%f?P4s6ql>SNe9Yjph<)AD z1u(n|yAv^QqS9H+Nr8K@*W$kk9LkRvd>XlE2{<#QjkKVuQcOe%T&e5^d_Jdko6 zkf5w5GO9%jV{-=Yc=*l$a09HQ^S#^zt&MU(wqBO%Z#yf|PKWYAOv%wRaAG9#OBfR* z1ZrSsX(_+YYC_BZF0iET7HVl(SgHd^l>t_7M;Lz)qsl zaVh)WP9JhNTwbwGOXdJZK)Ju`_^=lbAglBtjM*Wt-^SiyXL(vq8T#%FzB{AumN9m! z7l)*Q3HrCeeJYcq!xSLF?I?-IaX0Sc1XwNAl3F18`$1<)$T}oLFBd^K>PO>9Q! zJoD^{^Roy2tF;Io3n|ureGDEPYtf_gTBt+$>w|?$8b3NArvyI$gw_Uf7(VKS3DXwN z1V&lU2XPXbHMLuFut19qEwnfbaA7fVH~Z{Io>p`+p6BE{eupT^yk zh^opf=zYTaotTeJ-xaT*AnTMiLBIc_((<~SWONOGkx|5O3v}M=1U{S#;2V^6{7|~y zVJMdz-hn4dTDTE3f4pzj97J%R8iQ=(a;tR9$*_#C?SP|iGlytHz(W>NPY499QWcVc zED_!!MfR6rDx_MZT<>@p_jbGnz$O%rkX`PGAAGvCjD9&uk20?LWaaTe3KRSWWhgT> zJyp2i>a$$TL-q;Va0$+=7Ho9dFC_%R6z)GgRQ zvbZN^g!%CaM+Lr#K5?yC!}@R1Kgfs3PhLhg+a&s7siHbqI6@Z(0Q~^!too&Kr5FcBShkHvto|q~vAiGm( zqYylmkdMY_a!dnnIhD$n1R<*34znQH1q2=0VaiSu5GSsJc|oXxj8xqu8ja&5&3RH7 za`3XRry-pEN*ck3M`2v zYd%RAH0qSxQFO{ZIQ*Lk^msy;2&Az$!}o(BO+THSk1_eU@;M>q8&GklR0wmFHI%O% zszwv0e7rX^9$+#q?-)vk2sjU}Lo^JjW93XA=*!n1*OErg!;2XG^`Hupbuiguley6+ zsQ=5Jsp%b4DzchQn8b)?h9{Mzw_8p9?23w(!~C>lAvlRC9H{0GY82OnO9)azE{c#f@W>@_7YGcc~j%{VO zTJ(kC>%4>(hL@+v_?n!M0-->X2k<)vN~bWz{P25&Va~8&B&nBgRfwClWPan?7-;t4 z<5&FGSKC##sreP{(^uPD55F6rnAx#|3oD!-otAInYbq22)zW-%3+uN?=7pPppi1H; z;J8>bSM&qsB;8VM-V}|E3>Q92)INKW2_Ajn7?*ff;|mmWsp?4rGsn)w%wgO+jQl*F+6SOWXWeeO)ZVi zIL%OZMGx$lt~qSvTy{}B&&+bp`}+CL82R}KB!3oXjO&@4=GmFT{j;+=P#^|meE%-9 zUq5_1^DsZ=kpg#u^D8+Ae8g}W$SE2j4-!92y9=p2A6fC4N@n6k$hQ41sO*HK$U}A7rju`wpe)kMyfnR1f}hJXdR{_+$>papdASM(cV5agKHqM&H!3iC zx!pOU2#sfD_Ic{Slg{~KSD~>y#p$G0E2g}h2BvAfG#95{7_{o6)jGSJZ>_hPrRkRs zKa{GDn6TwFPnZDD^1&?c0aPBR&y+g;VA{7gO3`@!_uE zok7&E)^v0g56fm)unX_*a+@$pqFC(1eSR0hJJR3T@L7Cps&jd0j?wtM-upP&Bi z)NlfYu)Zi%nDXKGsi2w`!eqzj7c=ozUH)+~pldL%-Rmx#KvBQDhdb}~YxHb0!BXx= zf19I!vPj;iEXIGb_Vts!BcE)j|73&9C+o0tw%7O4eaCY6F$%0#v~)>Bi|m)(%!owde`?9ElszD>JMf}n?HK5AYBgd7~v4+Q!!docD%s}yM z@re;iNUGIT963Nf)Fq_^qJEOVw|-VF{#{HJsei~kpWRS|sS!BatEyj)7rNAUDi7Dc zQBTReSjxuU8+Cm8R9l(GA829U3vudqluwN_!|ig~&DGg)uk%s>nZ%}=0;+fdv@jGD zpVe$Y#C%p0I{f=%=A-D|9H&GC_&IHo5Hue#9ZBBjI3W`99x*3_$;@+Foo97ykKCiV z&j*CgN6bgD`uR;r$cvAekQ6rNxJMv^&f(1J&d9p&SX0xN7oKAF`J?A5-f0pc{;+UU z{B4SO#+E}iTD4jd_j0F!lPp*1NqKJuy9w>ckH}=j1c;>fP6aM^{)eS+Hd^iV&DJ-sTJ5zBL4&Oao7o3jOTYWe&KpU4OFgY|BPqRL zY&`i5!!-kCV0EhfA2CBqO}&7LK7NJo1#Rycb`HrWVjWxS+1R3C>dmDeZ~?FbEzEe!MZ;+IOKg`~|_I zpwAe1W&ngkQLY3E5F7rxzb#6hG4h>#?SxAiR>beXfdV6<0?(I*Vs;Rd^Y+<6>|R5l zHYv9SY-nGJrNLb*1AVPltLVz5j6kK(^zLq+w5+05I|ohg?j8k9IfYDpSW3dnNk4#W z4Un=E-2d3pr@;#KHGUSbvIMUlWLbdaf+%G|&BUvT;br+y?O~WTMSku1=-A>L52RzF z@rayR>?g{N#e9qoEan64x{`Ihv|LNgNFQ>vSxT3TP#@)Hv(z~_{y+ED-uk~+S?FOjXV04#YsNFv?WVn^lIE7>Wyad0m81kzE6o$Ls@rCA$c3Li z3cp;6$@(ZZq?8Pp7{b7+&XW;q*Mw{t!68fz)3yy|o_MrgLB5|$K#@g(#Last^K0C)_%G6%3{sz=-GzcUe*hA z^jzPto=QK@t+kDp)(h$A`C_XobB1V&N_f|aAAf~X9`@BN@Hw;-pFIlgvNpZ?cqhZI zG?DF`{Q49`c2?O|-KdOb<%J)yjjk226ts zr{YJq@k$SB3&Gtn=xgYPk8wuRL`-RP^*$`!e4mak+Fmr;*j~f%x-}03&Hr0WVafa5 z0|C>66kCvQVueOx2_^N!a=q@=WO$vL*T*oX8-s{4ACEABQ8Vy+hD?65ki);=-)p=6>)kuUW7DM7lOq!<{}S0Mk4C>HC4v^ zEL0{eNIie&@b46j^|g;Me!pzTr3x-vn=V@fS&O=|U+{c}Y{cMNk&;6-J5VDGvbcmk z+n&;9`RE)?*;c@t8sf@QGt&+_UNe3`1rnI9%6T;GdA%%{QjbluHk)P-vRAnrF1#YY zr8!o0)qVp$*yNwh6kGXUN(^a8jmT7co%cX=r9M0kxspSbgj~!N{5Vxrv2dE-2-Jv5tK=$xyAH`y>JYPqaczv z^gf)t-jyqOx$$yc=QkY3aX)QE;rIg6(q4@R{ng~63yqd58Sr<8_w!^GRUOuIyh42V zC|*&)jqI4xivn$x`7C9cQO;$Rs62F(p$)i$=~qG7S!I7pF0nEVTi`Zxq>3qR)CyQp zJ|0D%+(7`0O&z-Ou;IFZvoM6**2u&uJCQ9-S1_|A$AzbGg&?$XCc;-qvRm+;G`N&+4SBVB5kWM{2Jz*L*eHs#r= zXg)9n_%e5*FXMGK| zS82mJ={_8qNyK+#h6Fr8S*tie;;FzPWJSRRR74b%K*+X|^1@k{QqyVV(?tR2Nj#_N zT3?ic#HB$Dv*F@4lcl(HZaylt$#B|uVoJiW}-s>Kd;hT<3_U3xP#H3y+gS%*h^JEuE#4gjmc>!Xu*`zI$QEjs%rzrNl%cw5p$ zvZ(SV2k(wc8l3FEe&5+I>*A-Kz5na|{>k6Vn}Fh>yv6ICcL#5$^m4M_DVyx>(c$6r z35yl)AH6>I1_q(SDM~CH$70ssX*xQ|-JEb$3 zzUyxe4o}PbI6XK#I6c^Td+^_-yZZKMXYb(n&D-OhoxeFuw5qau>j zlQcs^9uTr#I?jpeyPy}3unsa*I#%DQ`Z#iKES?H#1p6;w@|&Dx&5;%GqdFY#VOoM`HMj3^?efEhZs(fq2PNX@OPg$u z#drnRpjj*Lq$oIRp`+LO6Y535UrN#tuztg zsb$oZsy4-Dt(rPmTv(cj9HNVwwkcuxt_J!dQ}TAB{PkA(Yf!|MHUMws@&@QnU)to| zUHN-*wkvNkWsi=hbpS2{I zobT<}(U-uoY%}pF-z>SwHA`-C%>>3}n~6teGsHWi4gOsS`=?i-=5CPv5&($+77J%X zMp-ElXyUGF7a0nTmfbBVet|itx(}#SrVsA{&(5)6j1rYnQZ!FE6V*US64A<4Jdg@s z>X&jRTVt884?rhD)&j#;Ak*FJf=iUbnDgHovI|*&l%|S0&6V9CzjiWH1(d>9E7K?A z7;0gmvax8I)}~vWU(DU^4>x5HT*L6{9K@v2D56yHyg7u{Y7wvpm3!MVHF&M;Y-M6F znR<-ty{SH~sCY^=7zJHrpti?0bVJl{jZ(rN;Bx!@68nuT{jL>NNyt`lijKmPBUa#l ztDw8B@0Yf>D|NNy>dL679gg3^LOGv!1E%_;w&}o7KN@B-n?9#``kZFyvz3GIqgCuI zK;)v|AHFRtR;;V0Ws4IJ)8|!;_{+~{|1s%**JSe|!U2{+c2trHw81{`HQ3R+Azs#1tdh5Le1P=-JcJ5eg0@7%pdbB< zDy-=~r4W2E0W+M=%iZ$cfz`ez1eHFpTEUmEK*>$B5{z4nirV6CfLtx&x7Bis16<+)owmC>U zYNT6c5ymTj7Dklh@N$M-x~Q<<8jJ-E#%PJaPq|eru2B3tO->+akeVipk};-Z ziRbyog!j4W?061^Ic1;J=gvwZ?CpyKL&JNLhahN6kNN6AiY8!LiZE_d2mxZ1;<1xF zo6pcQ4lTGia6y1ryceU_I|s|Qp`+ySNdkdH-0%S#vQjr@cpif#dZ@7ULK>$ZAatO0 zsqW=a%ARZdE(KP=VDk9Ify%Cz5!!6f+CRw(nTG+X{iDudYd6bEAP|Z=4w!uLAiNv{22tm=@gnsBd*vQ8Ml?NtH&R*urjze*bBBG z;FP~vL(5a*yR}_U@oT5?=?gf57j%-Q^$Kr%JRfDnGHib+$`PuCtWL)QjI&}sk)ezZ znSi_}gmr);0tdrIRT(U7EqgA+ZCy0|qcjh6%VyL7Z? z8$TH+3OzZ?0lBI;Mo37?DFjRaI-gS@q1?}@g9@;*_2MlB=;h=HkfKaKNaF&oRw;$4 z;Y=Xt6Jfab)oxLwz`Gn|961UP3RgNx4FY^^iAv)7?}MgrmIWmBc2442F`o&Z48Ay( z2bB7xF$n@c3x_)eJ%n&B*1g&1E0usZ$<8Jq?i)5J4pp-3=bVUxD~U?EltFO79ik`a zeWRH&LsKO%SXZ$j*VG&3l0rt0PC+9%j*4U`#qc@W`kE2Ra5C}^sQnm`vFTzYiO%py zsE5Z^tFm$7eF&N_@KOj!8}?Hp6p%?wLYJTE=A%b+yE1%iqxXy@Ir!^OklK*jV_vvZ zfF!Zu8(2yJsW_~oWcbnl6xzOy$O$f=0QcizG6i82&8-jvC=+#%BMH_$ACKLE0s*yw zU`r{8zv&jXfd=G*2F{RT#z5!?=>BKsp9EPfkuiv6Cv7O&Nl0hIv$+I;xVNsfa`W z%h9(R<8(jR5FilLCxlnQeL3{}2&?y)pY8`owan**B|KAV5(~e!>@3w-;wikpLNd9Dq5?ZrQ+l-LhJvDA!A^k%9$;wA^{#RNj~&Z|O&bl2qZH2Y+$SnQCBz~vCr-C_t4+-5}f zbn`d@Of)EIWe8%R=L5XW4;0mcVD}=NMH!f>0V)%l26&+)RB*gS(8N(3a2qm0Q(TyK;6&RYYci-*;pq)c;U%nJ~-UeKJ)O~b#yy;$d zW5}9_M$Uu1c{zS0?#a;r4Fh;xj-oR1Uzp+^lzm8Du7NDel*4L_AdEL~5@MBVzTipl z?}rC(1_DKkc!O53j|orJJJh*EYe3XW7!n&&xii@ib&nCsAD9t_Z1aq>X<(;mcBXfX zx2Jh^R)$vj8!3ePPsGI_*bjeflJV=bv z^OPoQK!v{?DLdLre)ii9ov3!yc*7sroob^A3f2ikv0>d)fgQ}_U@F1n{+69Vz(PN; z6)Bk>O-Y_Y7bjr_Ns)-vK|p2Da#H-j=`Tcxs4&uLRIVE1>LNu!3SmMs=(CPAokH_0 z5+MbCNwj7t;fLRZf+T<+rczU3ABuIMks(^DcZ82po`dur`3=7LMX?oaV%%utD{r!r zJ|@6_jB05cY|{Bk z+Ks>3#33O90R#$m$Fgch0U@E}Us}f7_=;S{H~?SyG_nl0c$w*F*L|pDoyO&W!tPWl z9Az6~Q#RBELMKra%wn*jpijK6G?|78pAt2Ll#f zU{R$oHeP@$c{4Q4NT4-S=r0z{pgJo5Vu+QpzJ!p61yD(Dv5uFHU&&e=JP;h6&nU3A zuMmx@eNdLO_-(Q^#0uB4#wo<=fJRS+5B^=i?QobULM>1=oj%6rc#9<3zQ8M@%#g4o_myi0xM=s>kIQH~h z4-A=M>TT4m?&$AHaD|aTaFt@K>4y>G{6e1!HLfV)X37h^6Tg*DLCVi@ zCLkH5)m+L8XT5O6;hK+x`WKtU@iKwv8@SCkMtvjbm3KZp&L(|@wtf!?7vBM`&p-3? zgV+9vqtOVz_@2kttvXSDc30H5zFxd2`}u5E0=#~+K9t*6aQw#lS}SFnIJkd*hY&tL zY{rK|@Th1a=6`xDl!8P2Yw?*`bSQ~amPm4GG^obCd2TsiCp;$wd*KzQqooMlWg26P zq|z3=M!oBd2KTnTM!E-$$jz`Pc#Oo4UP#geupR3PkOPwU0-ZoTGSIuPqNfy13Dy%^H3514G(Hb1HKg*Pb_!Qn$XODyTw?)& z$3p6w$dXo`n>|*cT_+&DngcUe&edqdom6QX|4`ZwK=qN%qNH?ueuSH9v1o;`>i(GJ zV=&$a0#a1egOrr2)-c>cv;V;{&jP8XGPEK%0fYegJ{?&uNHP6cd<+)I5-QgO?+tdQ z?;D}u4?xfvoC$cHonXD1|3}gC7A~vAcQ!SN_gO#SY$6ntqKV^7vHV=|Gy+p{VaMd? zfKfb|m7FoZAxrGrID64R+m(SSazUF^Ap+AEj3GqIn8gTlvU)3R`%sHGW_e+HE@hB= zd(A-!zV*FFS@ajN$Otf*?@BQ9%5mK>P2mP#UO0z1D+vS&O!*jz+h|%Dx%1Yg)ew#G z?RQ@0=hZ>mZvTS373>zM3}cCY(%3&kjj(2+ZH%OdU@Zemj$|^YxPX;mS*nFL-JrG# z5plXIAm5Jz1jJ@&$mR$itm}|+5icY?u)R7j1-`c&R@Muhm0(;QXB&`xUsi2~Kmtg3 zz)8Wr0J~u=TCgw2lVCx-T0vq~EVwW`*($q9&5AeRX>~_(2G{rI2E?k06as+oAJQfs=+z z8JcQ6`3^DDpRZw+--D-gbI+cijE4Lq?(kWbmbs9?nh?dgdB#~LLp1u*YC)oSg*Pqa zdd@Jv@j$*1I2(hEuuxWR&8JOjFI1d^a* z41V|Hzn64jY2$SCL9Lh&gzrrX{6Os4fQzE98X^e_`F+hnGRWbENjQlTvc$CGUM5lc%L=@Xdp zn#^!HSa6-#ck4__6 zv}~@z>byv*yJvnJtLo7hmJ^aJUW zv|lweh`ko1VRj|vZ>qHz?hf__JHZx|{|G{BJz<-qk0UcvD5I_g3rSE19W>E~4V;c- zqSTj7yOOI1?UlGBj%KFHd?!Nb9nUiSRtuezW%Hu6h7HLOJK5|2ep;F-Y(N!p`8xWnNx}ZsT#N;$?q*dY@r4M( znAP%PHQ#i0vT?u9bN1zM?PS3F&^y3$?W97cfo$e9K8djU09^&7YEGli$#g#TiZzfN zXEDyI+ta$*3VN&v{wvNi8Lb!mW{hwFpZ;coPg2DO11zvv?XEhjXf)Nk+7yU_rPI^HANYTAlySrRdIAoRF3s*ss>LRLiu)a5+iC; zKs`Zm8d0vGRL2o?kOZRH6hH%Sv}u+mLfFOYQyL~J_m_aV+L9bi3@xi&>8Xv-!sB?H zkdX?<2C`V6WPE`5|cYD_lc48B?GDb8w10@!SjQC3ig#%?T%seVwfk# z3aj)5BL>?psN>=+N^--9#LraX@;u>W{3!3iBvD`U0xo%mVIpATXfAiA8yeQt{n`!= zX`{c&o-C@msx6s?eGDMxQh{*+&0-)F1|r#y&Sx>l65k!@b_{AHwc5yuce?n-eOQOM zp?M6g5q4yrg$#rc7@e$IfKeKvQHY!^g4)zpXB7l{q-FPULoOYZ!Q*Qczo!q7{?9!N z^v?825s!5?T@(3NjajTfhamKHl0>8gNW~qbSEckA(p)(3z3&TSYXA!T2)R*-jBAV` zZL?V@pns3cDMXAqY!lsg;7D!R@x5A-Ql6_az|^kj)EC^2T;u8q@ucdiSvyGlJ} zuzbos%F0kNH`o%tol~O`!Xt5|DY~EK*gQqirp_lYnIgIDv7lEmQwuPW47kj$%ItllW*jdgVwNfg|gP`>r(r( zBz%)$`yD`Pt|f3^f${Mr3bWo%>tt%VqFQ{m3OQEBv-74pjoqG+ht4dUN_T;e`w(3L zb(8w4njI$NV)cO ztgo&@YsB+^ zEb6K94Ym^RYM4=A#80@qLdH_a8Nchm&la!$yH4x>t_w4*5f40JA_|zT521M+KZt5L zw?0W3wW+XO0}1T6vbYmD2#!5&4Qt$2(sJuCwy3mdJb14bU~J%*=1sd<``!gC60x4v ze)C;-=zT}+@y?vA-_}skP`I|Ox4&t>i>YRet+~iH66ETTRr1kx4_oZ3h!!gQCy>ZX zp4z#E60bCl98Jtn{RkonvD*L?h(bVx$mCVyHu$ipFgkf9iIqg z8b_(Vm>{eu(S>4Mg0QNRc<)3bm{3Op8Co9gAXbI>@|a!0ZLbYZuTp zq$NU6i{57FF^~ADW{I12aWqlm=;{b&S$bk8I_rm=+X)`6yP#T5%b`gKoj%U(9}k~X za9r@Dd!sLUr)C)9d~|SiQ!RYvM%aax@rgM=ykcu+)dyIi*2azQV#m>T)`0Q&nv4OK z#=?Espi~#LZLcQQmchP4<>)vX3ArD9!-P!C+l<=<85pEUVwFwZK4cVoubWwvi?JXi z1L8Pq>T&48QxI0lF+#`Z)EEL&y!~u!DkwCjavic6R6IBti1&scIgSGBuaSwO*lY`n z8%bG~eu(G$#23QX39+=Tw-Ww~R~x2UV2{Ea4XVkQqQ}3mqY#6;>oN4mDX;#t_PnA$mBxaildK(tWCz`?}mhFS%hoWk)VTxcd{CT zgg`2yC$e=wq?4@aR)fK`2nx+%WT5WT;j0u>^YT0lHh@d*gqsv2CIm<5BPpJpr??z3 zohRJyW})ug!Tna4TZzk)VL#nDpw97-NkkA{sKg^34dvl4BqArWU6$Vt2<lGA zk3ygT)TG7OVGw4F`#+S$V_M(bi*%lL0pR*I9Z&|kgg_d1~&tws2FdSme@FttOvzgQx-D?|6{37INQbCq?j;g!)%T$3{34yGYnPg`N{y zwXT#G(<7UUQ=Fi^O5AQ?x#8JsG6b26X}<;|0S1dO4jw~FQUh2V9 z*B(Py#H5S8shSbWsB^dkPAxnHbCcpQ&V*Lud&gXbK*R;SfK>Q;L|?$?zqS)W)B_&5 z--N=tIsKtof|zAMbg)%|CJZBHvvaxci3vH2vCyO(p>M}|%7#v=^nus7nBl^@O2A>6 zLzRZaOrt)HMy3KCj-v?_V?-76EGb$$6&GAHEvtk2UTvNI+qgbK1TQf#sfoe(T{JrK z3kJ~UlUCB%-(sO#iJw1lT$G%?n~Vm5`>_~zw94`e96_yLVAw8p5#4LGlTeqE3owi% zhUALi&%ePq7k&C=57MJ}BDK`8>sEydoUgRg5(ZEkWs_6mE=zMyj{z#h;MXh>gZG14 z2WTts=szxq8JK(P1e!&{y9SCOvU^g}8wd1zt@?pLmA!s&w;$Z=2lu;BU9(^7ea+{A z)*be3y8Fc|NV~7txZds^3v0akig=^$^Ex`OdEAdJ0AvpVbsj?mZNpCsvxhGSlz!vx`wPP%=;C*2A+9VCob807asgAG!YHf04KBy?s54X88 zHz!x7l7DcUIHTzFL5i6RQaiKc>aI1(w3Rm&&vqET*r zxcc?84!wQVG`-(yC`3IB_3jotT)#kp6JmV?FmW^Dzco9O6N-nHoX$|vUJMk578`Bc zC}zRMzFaVif=fA8>S)>{&>Jh2bwV7X`qtin4qGxa;5py_v4sk?4Kx|MWUnPEg21#? zi-c+l`gn1JO{4$gxY)j&K7@_^AGuwk?oYV)zjk)--hXg6_+R%gXF2xIAEN)`p7p!= zW1asc^!|jOrt`mlcW3uurT^!>yASW)_WxYj_fja10$Jn{? z=?|~KPG&dqW9A1P4T5pOJ%k0j;#Z5_H@X3yGrE$fusJi-6z(#EJ1{iqGItNI)`;4h zp~!1gQqf5PB)?nR#BP{bJ}u}w%#a;IDWe36zfd6haVEh1413G}`yq^6MxXKN7l#jm z*LX}tu<_#XHF&{S?fW;b@A)@&?;r#c=>-fZyszk!-Z$o>zv+@Tm9mG%t9*w!um1S< zd;76@KCz#{l}IEopLB2|Fbeai$2s@KXcPAz*d??)pK)0DED|T6<;}0g#aFT^+O|0; zyb=5$9{xW02+`9@Hu!En78;58MQr68?;8jCOMy<$vE0(E%s{+U1O3x7aG7r&3Ek42 zi|v5_44y}2Tz%zD_5-LJ&x{PsI5%pN=6RaE_zbPVK_Q0WCKII&REMLTy-0@{1a466 z-r%v4dj2WoG<>3GeB|nnF~7a99yW!j3u{tc4CnyszS%RI%?0JCPxhTf@}}w<4Vt@i z_f<3LKdUpSp?S6{*~4@4V*w@1QjJ^Y~LTtQ+CkX$1E}oHss2;(9XtK1n~;Jo56@%Y(YNF>crUBSIy%mvQ8QkxZrjNNZa=M3jgZZAkR=q7yXecmCio}SjigV;>JvGfkO`99s&qdD zM?;)L5HgwPWp#WYLAe_2Ty_k>QCM7>!-j|tglKq|O&B3ojUtMvSaCj&`_fT^4HfA^ zk>j3mPNFe*0hO!KUQeJ6l>tx!5ntlKEwIZc)U{ELnMP?w-m@*JnVl4vk3(@`kj_;I zu9bX-E^Z*vg>Q<`1-g)USYMZ)(CPms|76PB+ugm_*PkKv-Fvk2;NI5{zBWE5D!hAl z_t7KcQzpe-<0GWSNB50SkQ#S)c8rgRAk9yR`tI*NG(J;Ad2i?I2iE6AnC40pW$ub4 z?mhY%5fw{8j;zx#yAF;@|{xPQN*U)fdcPBUyN4~eSyBqA?-QT;nFMj#!>mzq< z?H?a@d)(j=jju?fhp)MB*5liE$;qpqh<@op>`PlAUu7+C+$ZR#vZ5Bx4O>2^R@dU$-wl1(;RU-s z<$@YpFd=xZ*c|#I6hePeZr&&uNwH2y!)1Oh`|7g8gYMaY@?Pi1>S28)iR+K9IQ3oM z$@ay%w%7*_Zez&$5jVY%Ce6xUcieSQMvvo^Rt5$1n!rVef1&(~6=vPL>8ZN!Cb+XW zmA5^tNlZ!gs;!S8s__D*=YkxtMMEM8LihmWWGL$j!pe+;#V`wqLI&v;Cnq`8_W;)e zG?q@(m=X*z@H(zg-4F5z0tqQQ%5+nZ_7DbYi)Py4uCh-1@PXzqtJ?ZIL)g)d)zzs= zzvMroBFTmr*03yNY4FpaXRKpwhSkL!OJUd&>upwk*0E^ntTaN+Xo&?b(!SQQ#G%yR zmS1KY6>uF(Em(;RfU=iZ=RzfPJ$RZItR6k_sAzdshOT@_rz58?-Uh6fnIlqqpBQ2Uaevb!HJVtlb~ca(AyZ9j zcVTn}hS@*E)TONpn;5vdwyAu+zA4F!>Rx)!boLW3Gy|8vSbN|309TGl-~z1NW3(9X zmpa|u6uo~{+NiR<^7G36S~aNZ5sYTRI+7S(R(;}m^4?%uxt6_+?nZR0iGvouZR!W@ zAQO5D8vyIkysg&F@Dys#Ycy5A)1Y*`FNPK5xU*{t8Sq1l&LcNBaI`pKPC%_7A!t!kDX<_BAsD^jhCx*G++NUIfx-CfR z8+SLuU@i!8LLC!?qzXn7^ygr(W$rW*)9ZUrSIQtVTb2H@QQO0g&!z1S5NYg{_X;#I z=aX|P2SolJu5Dw%*C@^g8z|fuPo#(Xo}$uELUCv;_an=ecn*_KK3Pa@tcU9Fm_rf? zbjAUEZNuo73=Rncg!KLJc;9t#ENaqnc%86rzjavV#-hDAhy#ltn^_@|9cbr z$z8a=y*-W6hl4CX*%nki{|tX_&7zaIfZy(J^BaS^gVS<4+2pdk#^t>ZWTFH@Ygpna z;7tihl*y^tP?}NI344EutPL5}Hm-SIdBN0dkqfHOP%3Qm=t;NPBz2<2QmBW%^YU9TXUK!QN$Z}N#Td49Ad3|6p<0^NXCMTyQCb=G4-R~&T zTGwdSjfn|W+hV9{EXpQmSjKPay#5I%b>T&5I24nVS&JoCnL*R|9FX*4A7vl*Er7Kj zSc937j2*Z@GvQPbJ~)hHI~m{(M?9>9z(&~+(;p)hq)hl83!qPGyE1hmkvz%Ic*4BNki&6wRkv!=ORu z5V=ni2CkriAom zFdKHHn?~n^Z${(2nqBk?7vdP8gKg<3+oOt!>d==0dwcN%pl^5l(uTONEp% z%?hwG7uy9|-VDc;09P~OCBm?7#-+hoyM-knTg_`*2XuX-UOt4qv#ttd|5n;Ux}s>j zlD(ZV22EV2Z$VQ*w?s%~#Mv1^Wvf{G)5daE9Ox^Wu)`s&dz4Vh2!&5w(+pd#h_-4queWEJa9UG>w6xD zgB?{%8+ew1R(no#rI3kJS<;s5Y-WH)VN?NT4Hg}g=Ag3L5{5j8V|Nb_Ech4)2{WUn z#11vAJ11!a@|4l`K`#yHVdWg*=Nbl*VG#?5GS@C&qH)I~>OHQzkv9(&s<3UpkHW-H z=gdscgkl2?=av+zLLV&AcF`I}4m?pXqmwB@;1&2$1dPt(vTqKV41^A2Y8gGO6XEHe z?HB)dq0C30{F)DH5EDH(5U9V%!`nvug?&_nUnE-l)4K!2;dAebR+a>P1B{|Fvfm$` z&LL7z<#EtCca(P1(JG7bUk*!&$^dzLq_JW(-A0;08;wTVaHC zWY#Y)q^}WgO>Lt+x-QgFx@aiNA*V4wC!93i>xzobtF1B6dan!Oxk~G*__nN~W4*Z! zoHO;dE?Bov-|MFBEsJ@^5FK&Pc(Xh9IWKp>KkLnI80Z=VR>Q${YKNC_i`Qzy?UA&b zLcO#)y&US+jn)Z^>jvqH&`smC#_jq+x}bTZC1))dznZ4LXrQ%WzTZmG8T&gJJ61Av ztV9Lg5tpF^??6jZL+w~yDWYbeC8(m_3b#CER7_8XqnZso@A3r82e<*66(bcq7%yw3 zGG1Q6Ol6GX+NtC=>K$OufD3?M*4W1&pj314^J0OB890Q!?m{b?ikiG)C5|Cm1eeIC!vLSlEQ@R%40 z%ufCd-y1xvH^{xCMXbXn$E(2h^<6D;wfNfBCTC#4%0{_{vAkBfKcrFZ4{b`zqa
    -LESWiQE%M>M>&>`gJJ>wEgk{|n+gKMwT&qE=8``ba61L)LuED~! zI!fJ4t5-K{TC<_5D@Lu^##>d z-ZZrY8ef(9Xeo5QDnrzI@aA&uNozyzE3q+Ea^)}^9aY1q48m+O`T;dsR^vez#V2Hv ziX2C%kzpF2;lo06=7!f%!I|yqJJq=({w!8r^dWd3v}HMtP?{kRg>4;nJi3_}ZjK2R z!6;zZ9ZJwyffj`Vs)%9d5!FSFW81L~NfgX7E;kx0la1=te22rWRi8r0G{#4y^~X&k zheW7oQe^v>`2+yl*lU^iw6{$!2%Q=8p4w%o^SNDEwOXzBco{u$qL9BbC_h6Fr=EbJ z@h9br>+S|vPio8`mjX@B0M6g&FRgY5Z)p(>pZHHkdi#a`)m!gpXRzn9B&y^oUOl7Z zzA6ja4;Tr|kL0N|C&BU*Fm5q}V10&RtxeJ-l|Y?puoXPRI7!3}YIcwZlWb^IAd(e^ zYU;C4>jT~!a}GVtPUm zd=Q(D^90lBCLesOVX$8FYP4NOVZw(Gls=n`&p&)@Bpl5=qJ8fCh(C zRYfYnauySS!E_4bN{pa60kT>&p}vTgLsgh|*AkGLd<@7PD z35H5uz-@u!Ycp-BD{oQX6}cY1p0NH^5%L)Ag{}=xi()<{ zM~k?%dO%OxW65*rUh~wNx}(P3a9&xJO662>AB>x%8a1}WQGDs;Xk$FGtBqlZ z#CYVFSQf}E7uC{a@^4t_Mz4&gGpWYr|HfjGSox^EXr!NU%C-d>0J#2pbz2C`y?@M+Dmmz}HZjS%iCdT!;GUqn4et}xJED(Wl(B}7bs=(P z>Bu|{EYnpI%B|TS~3L*A#F#+ zV=PV+^8l|>)9S1+)xobNJ2>o$%nb~J!v7NDEPiTNv6BG!i!Tv@y_!(NA$WPnVO$cF z2+&6D{cF^Px&9T>a3UT#=wK=|cRIcEqpqB1SPw@7ZSp}cR(US_1i0yHt3>hDB`ZAi%T$`drOoA4QcrvCe zGu(g0-riN7s$-pUJePx-gDeNIZ8UX`dWs zaXuus0EQjc;AX8Z)r^R`6v5z5T zLt~(#z>du~!agRDzLR-DJinaR&+qiY0h@eWw8Gx>{DTpIvy(l1cz@M6oFnHrVEsrh zUm25qWz^DRe%K|ha(8gI8U1K`F5*$EP-wWlf(;M=+tvn1SfB-aKbl_0MF60XrUUrB z%9k-rLAu4nOEOJZ@QPs>O|TsF$%>p=A4p3cd_^7tJh>J|#7n1g1Lq$suxjDxUVdvq zx!G!HA*kWd?SvRt}^bzR>mvvm9{>{>tPRmsCG3! z*5dGTM#vk8eii%RVhVp&CoH9vrkhu08AO?s`;8Qx#(5kc7b85Z;Yk7qG!Xwj`TIQ1&mYrU|60T!VUdsbS|64XNq5-x+$QT1NW_s^ zE3oIYOpxt4%A_qvxp79wFI=4ILX|DJ*B_3cmK1j^4;^A?X#)f7NRiNnv z@1Qf2e})vk2QL+yAt>>Aj58M0hbUDoV~Wsesw9{DDy5V|phFJSg<8;QNsws9;Y z#0ZnmpmbI`;bc)fmBq5QgeN%2HS{bvsU{X<<%;pp7 zGA8&6w#Yn-@=>AM^^$$(OWHx>vCQCJo)(-Sow2RG!w;Qb#*fAIf zJj$No#E*mby}>r^4nkz*?>dp_mr6XZSnGz6MS?`Uz4MLu=P%Zn1B%HLU;Nv@SwX5u z73P!glV4;!E)jGkaMm=1;3EU82fZEYT6x$Coo&^_n40`T96$EDo0qeBsXCL!(_?Rx zG|#Kl-+ZoqM@D3BX%v6j4|X3seE4v0Z>O(6Coa4D;L*c}#-}Nu{eE!Q_z0a%_jh)U zkI?00jh5py<|oIKk45qiF~z-|uOAqnCut_8y|*X+d$4DGP7hm;9#692$HE>KZI7?T zhr9P5?Cw6i_u&5Bork-FuOFC8p1Ke1-n;+k?%?kI-ABe#L-(n@2M_k{4({K5U@aoa z%Twpc-Mt52-+egPd-U~PcWD5Z-LJQH9&GLH9qruRzx#0i?%l!8!@d7<*H?M+!T$Yw z1F_Eka@Xh?bLYX}!QQ?9@~zW-dhgNxy$1ua-v6qg<2afW%VN&myStAbRWWDxDlli~ z;k^pxJn|sUqb9`JeehuS(csbj`}Y@N&b=n2A=G*#{#k%DJ39{_?(Pg8-g{VCmJb!g z0q=g@8foq=MjGFf^+@wz|K7vF!`K6<|wD{kn!sR zwGB%b2sVOR_6u*9U(m!~rm7oJ@*_n*H%0j3@)C{Yiw58OfJSvE| zzNwCO%du&=TqcL*exry^%kk%5UXFY|wxv;H>OZD%-T@w8jAUNLsv9Skk2}ca<4%J4 z%Go{EvHI}Az=@kETQ6Ah^~%*Aq+D92whFeDc@lr(i{tlsO`zYd4Wn9slx-05LNXac zhFNVV4<75BV|q6QQc=EBCN?y~{NW;dJff+qzI#xs7#2#M-xf zb9H0ftqG#bDI1Pw(vpP|{2_Q0kJUWY4Xl3oF@=11Y%+Hm9!$7cB@Rt_$GQ42Q-tzA|NVb4vL0r2TS6>~10|$v3I&yz-WzOB<1>o< z6u*>bSx?__O+`Tgb))0#Q!Ha`xy@?fhS~=qjSHrWWO&L)g-9vB2)Q(YS{GC(P}}tc zTOLQnsr>WLLLe0stk7Ql@<0FQ|NEc+^WWmXKun=O{6G3bu(51?8{np^o9x0WB_!!Q zO&;k=wm=p8^7+9L(8&5LhH4h(3J~_G)JqHM0;e6B_qY4Pit=uaFkNDx^qGRxr4*8H ze{4%ie3A%TMi{MpY*%`8S9g5&wt!|{N9UbxwqS#cxniGVerl7h(x$t1qyD1Zv=-NN zg9J-nA*uHkG4L6FYGmJboal+sC#=3KE&L$VkzG9w5ZdAm0wesQHeBz3xgmvW86kaT zYTI&ol!@EJ*Jkxi#cHA78^<8g-P3 z?VchuH`_xMxrpRSrsy5sDXqBr*9|sJoyW zM*e(u(=Yq_Sdr?UJLp39klC_=`ye5)=9b>EZUfA~!nj`&S zX><~SeLd!#RJSgetq!=>4*i0cO}4nM=4Xv;lHvHx&UFHffq>#_gujAM(PYjUbaqzf zRT$}1CpNa10=g;;*+8U|*ydoAd}I_f^)eGYgZy8`vn0eds4$2fBM>Fk2C ziO3L<>2wVt`S!T3`?&lUn(3CruW!%n2A$br5>wYsLx3OZmla*9SICPbFQZJuzF~5CxLw&L%CLn z^!OOl%`<^FH}1B)dG2n@R|a?K=Hcq^MK(2D;+3i~yXaZR;zz?Ql@?RL>o^CaE7`i? z`>iA`;NVb7vCjdL)7 z%Rx7$^Wo`caGIPbm;V`r5u;0iJfv#@moDQ)H#N7J_xtCi3K%v-XA{!K*d2W{9H5T^ zecyr}0qX|Cvr#CR3O}bEzE}>&o%R5H68H^8QL`XGXI7Gh@yDZ=kC^(%hs=AZ)ESat2gUefG$d)SwM*z2e1 z<;}b|_q;no_p%tH&+3aSXm9mh1;&>S=bK4e1_r>-^_hTg&+ZGi2j3pxO(Q|OLIU{VZ)BsE{~_#C(P_ZQAHp|+ZIQ1z%}J-`qSO!Xw?c~U0jzX$11fiu$0zeil-o&AH0p-)!m8~YtHNtD{-e}yfC!WZBDc=(?XtMKCW z%U9pOz~A2J-wuvmy#C?nKQS}Sd^>#c!;81CLvE@gP7|(A(DiaSP%Ft=2o5=6j&4Ov zsy1-oII_kCw9dw3!CeGWK=&ei`*}Qx&ck3Tl+r9c0bjk)=cA!Ot^AxD8q>WYCYwRG zlav|&nj>p3e~v}a3j0N(`%@em4>^6nLntc~+7uvD_WauCH2O?c z*x-)iMR`ld#?oz=#eX}{6>2<(RzOlEzyvIL2tdGi5Mt630A3`Zo2TMhu{Hwj znt*L0s`bUyq_$7Ba|CN=o=q2pF1uzYz6XR4p2m|u7BNp#H%A}1=+K;yJFC}OFTlNx zC(xI1Ab2J6phmYOyf>nW;6Rq;M?X5n&U*?&Wo|nh6q+xfdA5MC|D=uXC(dcB37)9x z%&krvQ`FIVg7PSIQBTrfD!?yTnYfil=*LGYIgZOSXr3(5+8$;p3~xm1-5oz-Yf5cE z>_%}7Y@CRK9l}`QdChpc^rqEPoKl}#3v;?%8Z8+5o2635+`w*P8u>O^mnh%}k>|cS zc=6^)GEdzl*Q}Jm&mBE~^;SPfqKl_L86-?c6q}WRh?@vZ5kjFX=OV~rD<6l!k7@E5 zwkJS0as;Le;>l8-3K!9)??PK7-)R1_w0N^%ETxT@ci_?z6wcAs!O4hg%1>_T3x?Ot zl8{W5%Y@oelGBRh+allEp*$3hR-isPtW&4vs;LjQu?`AcC{k*mwZ?)*Npqo?i3JAa z9j(JVmCM4olDy(X*9#Xx)bX;t6@|YnQTSHs`#nj0hLH{!I5A*(hGJ{M2AtA_4g@o$ zO7R2)zmp+H@Yir&CX=K*Us?iWUM-i`ramJpUkkYH+N7N(QD=2Ir=5_qj*|-1QLRg4 zSz2CMFXFYa`Lx5Ch1YYdyZLqWF;?wn7h8kUQ8L65XlJJ}6%3;CZR2b*0y7^sUp|(# z(kzvnq*i(q4a59QU&ku2Ff>kbA;$98>J63!RBGN8vD>wDiI)x{@-m5g!+!y04uSsFS><)aR*2vE*&)cK$=JFfpzajkwFZNvW7HQd9v^XLXjsmlO_ONV_olu{h~i*UhvZBaR3*FMnQpc|{m8}# zf*^r8vCsisM{*C`w%k^Tq;{)7f^k9nG-gc^;n# z_9|F08ZaeTLU;%h>G*L=Gq^+ZZS>5cdR_x&X9rlLH|s#DjD1-_%{&smGx97m2_**N zLtNq2ak7mZl#a$cnRe~d7s6ZusS9MpIf)P6zrbY#sOIb&nhUzcflf-KdRjv7+5XSH zUs?gs^~cc?+Zzw?`Bj=|JZij%X*r5dI~TJ0T*+bH3)ihk??8SHT^wLtPb#5GI9RLf z2MP6Hi&>2CGP%-Fju#1w?XkX}9d0Z6`=kfkVjLa`*xYPLTtlXpAIwWC`gBFNb7-`ov`YudbyD2*Qk{Vk@UymdIjygRT1f?d zysdLoe4ZlfmZ>ebsP;QVwI}-(l=28E^l=wK1%5gSEAZn8EHtYnwA7c7zQx=x9CPbU zsf&e_HtcPIjoD|T^I41WbSl<2!}!){byFe=I)4&bQ_hzyBHhl2ybGgbuUso%;K9c6 z?FOxvt(r^qq>2HJ`4hLg%8k-hI^oQdo2g#cX*joNceBxM#Ve=<RDgHieZ;gp7NZW8$E(F+*skvm=XJ=j1Jt?86@pR5h>Fl3Y@ggzFlkc$G>Z2CfY0`S{;?3)@bh3W`1$E<_B<-1pTEz< zq5ga%mj1JTT8`N0JHdht~xyfvPPg$w-B=qX2}JpsvZ z*rLR0LXH8ZEJHYcBqX)IawBUDCO2K5!;Ca-Lq`}6GBWvuhd~4%0IQPpgB;3S2i`m} z<}#p(P7$Ok(a5ZNNVHVMKo_MB@!SZRZ&4;&Z*w3X2{+pzAt95(!OY0h>w>5PM~*Ne z!fuVnwGgQHlm{^Kb?U1t)*`No;Bg=^+&hZ^H)DkO?ar$=&ko+ceevw*&b~`DG~DGA z$2&mG8Bhq;`hVXQ`0zo~ij@|?8-XCHV) z>338pSxU$G*r%(>9qg-@Dhk@N&U%SXPEnIa-R>5rE*qz=gm)}gobt;!@NVE;KL_?X zI#CpB8`j(b#@7hvn@L;-2Eb395#CQ@>nc)tdxqC{hHEWWd3%sInHW2DH1Zp{uBj3l z-v||V*Oy`=TS6xy%X9mqUR<~B%aBHH98oTROe>UcyFIHbKC5L~4EbAUTaf~l_SpWy zyqLkZ8J?ZSIXmVGN(F%|$2>Zh@IV<^{y}MP31uo6NeZ8blR5IM-k?W`7veYZ>!Mfz z=)?pT$xa1|;SJT?=J(x&4&Y4(u*M!SdeDY?z)m&b3M3(=n&CHqoxc==LhJX!T7VIY zB2kQx3nv5=j=&!_E(YMsOv}o29nvo(E@^{Lw|Mww%Z|-fS=sbOj#~Y*y2fDs8V;#a>JFbo8_q`e4%LBj0CF{IIp`Mz7Wv36e~u9{j=XO2rcBLK+e#h z#9$PakrIzg*_Z^DHIre`j_y2*UPEFipEPZ(krI4mrAHk~pS8e>OUDc^c3e9@H;@T_ zE;F^FE>~g+nHPRK-vaP+;aOM1Wk3(qrC~@G)uHMAEf!uO7W$CT>t&~}7UO4=xC=ik zqGZJ(af@0v6}7w!u9FbEJihoc#a8BFhD7?su1jT6Ed{U&wzST9mC{wcKg?&~ zwal%zM%8s0RaO14FUO3^G_sWabWy2S!h+S(p1uexs+k@oIqss)MmJ24z4nWIjYxC@ zjhqrY4tVdR@PtV;&1smab6mDYWM$D|3=diH})Qkii&{9jD z%}-8o2wJ%qJTwaQO~vU=01-iOk_4ja)Gv}dX_f60|MB^DiT_LVj-b_yN3zJYwtGM6 zSOf`2YH8Y(Fo0ZYd@ZVAkVjJ*k7Q|C|8ooV9KFq!RgIf4yhT%m3UZol6>brSuL?CLoW<#&vPJl`!wzwfZlyQminwrX5tjxUVcNY>3)fQw_jq1n?O0h|9^dm6 z>9xwG;tTNfS)M@SP(1-Fmtr@`Y(9ZEzri?Aj^Z4iiY0ktINO9sjW(+hOprcqM7eE* ze+j+~_Jgm2?cir|^FImh2t=o@07aZbOJ6|LTz3m86rf|3k$rp~ynhp6=SH};#E#(# zO_sMpgZq1ABGn!^w5Z}i#n{C5zuMW0T9DFO< z0&s5*f*)~BZ;oCb_RWL927atosuPLCCliRTwOUgE>PYU!>61bLilb>Cw}`ZV48$q6 zhQYP351+pY0QZ*P1y;@7qG^gsBJN8jtRgs$3hp5;_!E+ZU`_Go(?sAPMf$4VD`Kr@ z@no_OPa<-`RO0bIwTuzGMtu;M!^V3^a`X4&Npw;??&ZB-kUm3hR1boY39b;I3oFF} z-vbpr-pL+3c<@Uj1HqlS-d!A2$VuWmw?ud!>9bloTzLRH`U^GJ>f{t=9wn|w!XdL? zq>2Pp;;rHliBTn9uoB`mQuquJTvt=nS8i)NwJ!^T#*h`eQs+5w+{Ue&^dT742%iZno%qoRzaGvyg!%NF(*j>Se%=%D5X zKFKePU^_ICH~-n;+c;iInyJ35%2+y=1mPp}SL z2GGzkif#fqN(vN@l;%rq#=8k4t4}@6pmu+#I5ifHNIi&j zZ&7P%Jf;dlAn5mlBk_OwVCsIbZ1ZZIuYLY5;TGam6`}BB8=bH+4l^k;E$wOp?MVd5Vm-5UP1Bi!FT$CYCXW_ojVof# zgsVRG+>WZethNP|yu#jUT-G8BcwY`{8k7#TKEC|c$IMYoi{7Pilkt_ZlQmcf|4=b}Z4hRnxZCxa`>emZ#yj@!y3!Qj&dDAUHW@WQ{P?AY6+qbZDB)i&LFb zR)~+I6N7+1CBvA~300xA1l$&y|6$iiw9P_T2Qd!piHGm1*9Ll><5;!1l_twEkWvSm zB|hKMD(msqXs+D0$z!YTjv!ip{h;~O3-`R2_r)#3*CBj62GtH%Tlyy6p-nzK=13>ixN#EeVz{W0 zjjIw@n2pCpT!yfIFzTo5loE(l%IlK`=6rIn(Ux&amho^Brzh0HP8qAcUHUMQSv4^} zK8LJzXp9RhuPjNhgam*P(w$w%9nn&$JRhzrK1tHl2$CRI1}0Ra%m+v*N7a>vc?SdP zN_;+x#oKbq;7^Yq2R&M8k0ZV;Cp*8ac1tx3*`KC{A(88SIKvHgKs9H!K9cbX%#hfBb)a|;`UOVv#zzr_g82;R2R)2Ygs34?1OgZDbvA)WDG7lC6?L;^ zy-YNV&C?wHosGbv1}cCz4|AtV!XXY&#}JFB3SJBk77^zfJX34{_3 z<21^Xtgk#{XhlTYJw%7fg+WDm3~lGJaD%({gEaUaP^Yi3Et(J^fnzJ}iA81kM`{Ua zT7!WpqgEwr&7$GZM6Hi;p2idIKFw@E(uE2p#r~L+v*^6waSBZ&Wu`Cp7)!qzgtzAbS&whBLmSQq;0Ka%+DTOGq<-0 zX(0n1X^Yppz?bypBJM3Nt{WG>2n_i{9{V~@#?&U=gSafHb_6Jyg07N|*!c9+=!alQ z`pR4{rHi9wrTZGOzMe3>(z>%O6?=_Q+@EJufS>mwzifd-&16gCRm&lF5*->cJ1&jb z#e$dbUVMv}-SM&s#Z3O=U{otix(sCa;_+ZvfL}H&D~3pl#%${(S?dkk7U)9KKrOQZK_+qz&^E$Mx6TO;H&wfg-?MY2a z?K%)|C@ms?06Yul@vTFw{=6ZV-Hb~q($!>RkG?Zhs7t&QH`^( zAV~18PI6HXNW8cil5IsF^?m(GxN=WJEfMyNOHyj*m9-pwg1)4WFLwQWeaq1Y^Jy=i z*EgsAK|q))a%h;PDkrcny*FFgcuPK=$I%d6_tLE-2X$E$rcsOM{}Jce4RHkEt>d{XESGE@u}6+VAp;5p)#Bt3^Vvvt0G9i( zSD-@+`c1>66b#s+62g_*-|O5lKFgnn?JaA*QzWpWwf;~y97LhNK!5b+T9z7 zw|Dx%?%l!e?t;!C>qBEz;i2x{{PtQ<(6`~57`_$P;)hyGOC0jQdQq*LcE9v}V~t|m zIs7X#cpg)Xcy^i$F;k)_!5jzUISO~@%g1_a39SOZrgb@51x|wZ5|T};3+Sep$QmtV zO$M@N``B{kF%$ilu#H^>)D|)fk9UUsS3{ZMLQ>@oXxX^J!?-fPOO0Xke@9IC&` zmbCZi=N+PH7O5JHJWaw5EOKoEPvvVYJ18X|owFg8W)&b#Yr+J?VzH##9k8>qVEx-r zf$JgWSjcl#MHBKcbGKWP84svrBySscSpcG`N4qK#(c6y8;Wp$xpN)E|F}JuSmhZ_8 zFRSmoy|3$ZcG)n{TQjhofh<(4&j~LG^T*!HdIBoK1&^3cm%kmU10?E zQ-h7c$AJ77c$|}{1fIF2att66cNz^34*N177v5JTb95=y7*cu-K}FU)74N^yBDqk}r_Q+VVsIT1HSNU3{z-SjLVF+3EHtk7~S@L|*nRD)3h`TEEb*kOsd zmuF(S91Pjk-XpeWdJHwUo4H^zmNwd zIGE?027`g;Y{VDH2+p&4a2BPdJ`3cB1Xz>N^7``aWIXi(6Mir6=k8U4QN$Wm@`Aq5m$2pMER6NROt;<2JlYC?>4GNUOW~?E*I-Y zSxjbMf`uUGd9EF86>Enjl>al>Xexb+eh!}l!v2Ap8&8Z* zlJ%8NgMX#-io~hARZlOY>k{y?eYdH7)#S1kvF>s!K)sUFIT?m}C?|=Mvv$PkeGnAz z0dt_C{NE^u=4A$&5P-6_%jt_m;l2{LWU>#{V&(GbQi?}|jV$D5zlRw#hJpb2;%rQO zB3(2Va4h3tFYhe~GQT>~aDAhfM;G=yt5L!VL9Dlw@CT-ZF7>Z31M9Ess&Kj?-%?5w zr7Xa_283J3HNMzAfr5V9SmE}kcIhW~C8uZYLh`z&HWP#5$Fk)|4cju;+Ld(~NQ8`| zQ%9Y8CI&yc;dzxsb&_sdaZ>rut#eTLmc#3?y%5?gZJAXc zU4~V)t~<~|rMV(&ww5zna1~3wR9(UrWym7(>vM2MK1O6zvz+bcH=BhnL%szX&13ylQVA9SZ575%yy|} z{Y4Oqka9S3MqavoODxpsf}G%?;(9=A5OUFw^Z(?ylzTG!+KpKy@<>h*o7$jgU5qVKRqHl&Yb-%jF*N*vs{T+y zyD^^IyQ;QEKEYK##__ZA8N17>6OMrxM1dGTCTaNy098OfuOrs<){{ zTis=;H;s!TI*AA6=dwq3Z@| zi0Dm+I6{cqC{&CI&8V~EIFwO_S7rhy)MXCa=5ZsKwun=R`27TO(+Gv9B7weZ6n|9< z5r4T*GqMX#&kf%qMk%J9;8)Jssx>~tM^riEuZ|%!CmxG6mtT>(T0o1tXqwGatdN4V zE}n#zBmx*knMjk!9j9cNjC^5uTZ;nmbR3?C z=gFasP&6aSh37B;(LOlsT4TQq>hBi(MOi;fnkn=#qvBHIUUi(=4KeSObmGdeZ41RO ztaT*?zsM){HOPCvD-{ocaHR8`jj~L@`NXval5A--c4l5AmZSMVb!F6y38+yww~*pP zixLqFo%AiSXvv-enk{!M=d~J6T{>RT1UJ(qbd8v3t)q?6gAUg+c}Rl>2nBYjeff4@ zw+JNB!snne)GIcD=z1;a@8HxUNSGjr7atVoKB^2wI@ZErsIB1QQMB~Gu#urV2JE!W zhR*!E>Chx=)%)g2^}<o@3TpUBZylD7uk10ufZ@O1M+Vzz&iJDj_11X>@t_E;-gS2|HHU67uq&Q}Z@q*H7n>$p;>Y4cKhiEhTLbAXoOuyY z?mILOmw=Hy4;t`NsaHapTt3!D~E>%Hb)$U`bGmtZ%z7ZFU6Rcv!qgMFu%51 z?K%+Y(vgWKxK(OzmD-!B)J97xwM%k`l@-~;TP>#|r7wzfbfhf%#YMvV=6bc7I>Bmt zJNTQR&B3Qe?|2)*)%*p)KkE&uOg0C$RwRCeL%j zs7X4UTp2w##^d?eUQA?sruiYKTt5$Z!!y50=L3(I^S z>%zGxAMq_l)#OV%REXV0??Xi|A3isV#^lvVwUZFRWidcaxMZ zAO33wOPKgS(O^cTEuD1==KB@vI%ZsW;_YN`t$Y`{RkEuma?(KqSu$29pIyqIOf z(@k|`k^xF_bt3)`v-It0ZC*1V{!IRtNOr%;1xGsy`d(XF`J+fjWc;4mmoE z-pvEqg_-=gKmfM*ES2>)2B&!00xnpg>>-+o)1bdh%1JAUYM~_fP*(3H9;)xd_!B^8 zLmqX{Omo5+fSfng`Ko}zsG1d5oot-sMx`ugN+{W{c7?N48M`>cQARz>+5JE@neR6T7BZU>RKYgEkj2BmBt4L-3<4h~tOW#g`B;E3K3WWpOA=)l%dn=)7!9bd z+ZZgWsy@T20SSwU!E@xD&}{)|56f&uvq_I^4T!-VqXBCdnMc={mDLsHWip&Y-l)0? zk*iFzPgwK3Oe z{p;t|s`HOL#sl`uL$P}Gp}gV1Lt2*9BT##w%()w}-dtuA-al!H_?4IxM|qbVQ8ug5 z8RwcqHZ}f~`EaYM_kxwo#j~H{rU$M5mXu@6qz5##Z^}94NDZr-i@8=s9O`27Xy74%-Uc@ky!t%U z;0omdlQ&nMaYz9$HiS`QME9RoShV>A8-59a?Ig~*qX5q5?gM&TWa1K&<(i<=s9pms zj4V0GQN#$j$xo$Ru6?40u+EZj<7rnR2#i?r7p|P3p}+#P5U#bZ@bZu^zOauOjEUm# zN@Ax_D3;re(J0a>8yhF#snQh%VZn*Ns@qGS(ko?<$}r1?tUb%fGw&qDl8AzCUsKnY z%{-hctYq8YIhRsZv+gadL;%Perzr4^~CXC;JZbGMj)2cCX-cSv<-v z@g;k8!!_`XC0hxGr1Zw_ICA%JQ~Kd@h%() zZE4gh@VbwHe*Bz7F}hKIkpp-{Sojg!dJ+mvY$xJl8co z|JVrM73?dqk0Y>3OJAATg_N795k2mb(#S#F5+e*hqSh?U+PHbDBVqc;Qk3Utmr}Ab ze1!Nq9|<5Z#;*YiwsSf0f*Sly^hC8yV3Ug}4xR+Pg!2oEULfR|Gz;kE)|q{G?qKJ4 zz?QfKTgO<|=TQPKSU&*DSfd8XoZvx``ds1UjxnNqvl!gDBfih4z^`Ou^c+NYIUOM+ z4`GYc0oB$5D}y zRfMc^TrSqANTd$jwtA@f{l*x3iQuXNY*kkSeuX89R6#|d>5ai)V-!8(NZNj-_ZNrO zT1A|gt(vuzg6El8U?l@{M4pZ2;1`U79Ly4+-X@$ejS@aXoP5;cIdpuJKd9=P00$B* zygZB9=>gg%7E%&?hXB?G7L!vYB-UwRU)!*sZB<`Mj!1!{vc?d~bJRTiU3r##%22!OS;m*o{!5_Wshpd+tvF)6=HDhGIc zF+}d+iGE73uZ-UEh_Zf0QO7TuPPsL^z(AI^?4kikgc+B~E^6`a25}3_TXV#&uLQKB z=?p{nuv@wo{j}Jp;v882GUcCdP_X%`W=M<%EJ40Lj)xJyey;R5OMsH2`sAoSfFnvP zhVWNuZ~_V&c-$5Xtte=lqS#rM{?C8^UvOy30nukDSJY=X;BLq-2(cV`XiB`JDv3xL zQHmm|9E~MYk70Ueu%|v8L09V`21*^$_q*czonT9d=PF?mq}L0OrTK5t04}7Y->d;M z=hoRur2d*M)$j@BVDtM4h4O2y)}BqLwDVO`o6g=;N^PC?0Gh3J3VMfnRscUEZBG1;7T1J#jBbBj| zPHf=9z?&Uwm+)$i6*E>)!C1!BnpzZCQ#ML%+T9K?M)@f+oZy*!#3XL@DKbpMJ~5zo z1ulF_RAJ!qR2dEwhcu~=D%-yNaPa@ifc|f~Ovah)DDWJgx18doYAc_0b4bSk;oVT&1K}3V~xh?`4QM`$-;<>n#N$YN{VT7MG6NTFJC?T{@~4v z6(I8L#y|vKb`~-gcbzI1ZHAJyg35=N2XCMGV8i%+AoP`%_)eBh54LBh^+>@5o(4?b zqFNZk8Ztci@b>w^oA3X#9r1UV8^O77@^^19Wpdm&p-1D+-@RRVYQ{<(q-s|QcSOL-C}XnoNfdSlQ70B z3WU5h#Q^nD{3#h4@hz;|OZJX$7N_8&LRSncbz)dG0v6mKW*kT?%d_JE@)4<}@oi;J zwjsr1&OECe>}do}`p@4)x1oP| z<|FP(0S%GvhwOGT+7!vo00_-A!|cd7=L{_|h&isf*5T-6(W}>f*<$@i8i|!nkF!ZK3{bN0 zuju8$_un79Tho#p8im(PRr%HSfp-;$|G5^5YqtVAbK(|CI4Z1`Hq`h8N}-9TYG`2% zYvv0d!$QrI0_GJ@#=7@KB%5{=**qV{vV2>Xq&!d!R9}Dp>P<_1NG=jn;lzy!d{;@W zl8a5F5t5a-Zjx#8573V&A0p-&WrC&Q0n{BdaggzWIW3nyb<*WsoUV$O;gWx+bw?)NAGLDK(#h=SO8X8!P zq4Qw3_pJZ$!>gCCTLN;4#l1A=9*=_eeu_;Usuz`1&hKax>vm@p?<=N#`#v3 zL;ejI!BGxu0^hU0UBgO|c)G0eyYE}_m36N2<*Szm+p}a=w%zp5#y(vQR&?0N`LMs`8aW>sIcM-eQQ&P$OC$utDRBfx90Y-@k2f`nUZ4n&fe!zK z*s!w{!nu4qeEaUFAJ+);6?U*_p+6q3li-(Fr~+{FLf>8cLR%mHPuITGR_J?@XY*Mt z`mXa9T@iho7W&t>KinMjZCL2LYhP&V!~f~pm)ef|f_CCFuMz&P^DbVM{Wh)i;OK8R z2Z5Vb`tI6S+W!21s#~jRVli~hU>Z+_^v(s=BTBbtw+)6d&}y~4OqplQ0bNVYJF)ic ztf;fqK&~kTJ69gCEVZR+3gY(9O@^Ky|Kr2U!w&}^z;p8YsYA+@IEEwabs1rdbgz0K zN*y#qIEK+kvs754hH}NE-{y34BkpIIm+y2sUje9Vly=c8}mt3#PKA~xF!N#;puG+dhh zZPjubxoY+IYOqFpZ@Y!J#EaIoC*Df$!oQlfgMyE+hnNQ zWT4G$-LF1sDxwtx@AS#<9E!Ak{=%^OIV)=+~W8_DC-WjA&X$+>9g;P zO)#1n&UBQUC&@G^l>shO@be`W$Y5xMJ4&g&(Wwa76%dbH!jNUw?(w+v1ijt%{Z*5tirHn7Q7Q+(Dg< zTiw4^Q}^}TxLaGD4V$tqX)olE)U4HPa&TxNoQ>#V619R*am>m(n$#NZ4%x^3`9 z?{D<1T22ehc(rX$A@NKbk=itXbVSosI>)Sf%~QX)sYbHr@$ty)V?@j@7F!f}&)qb=uUWhBKLQO(pMj{osN%Alt}W}` zVUDtwJwv72Rzr&e%gY7pJWWnc-$BQa*HQj)VN)l4NN)vl+6N^|SJxe%__9mWs2|fw z!mU$w9|RwdRUyF8T5`zl>9D|Q2XEP^9g_cwK9ystTDF+S35C#!cbsBf=DG<4&w6lA ztf0b5R7GZ>RzXFRxzHa&ggUpH5ql0LYlJRNpbCR=8Z6FY*yD3?10s_#85&0~tD<6* z7*dK0ke%G$3F+Q559e-A=2-dBxDfD3!64=o7cTC-oj&xQ!CGp(I(pf>27i7po_Zg? z!2=t-e)`jg!>2D_e0cTd=*3@OybXWZI4#RrvA?}N5`y*wT;+pl_7A~@qd}IRY{%)= zkB8f%Y*=i+i;uVeJ^Buw@G_y@pZM#!#{`?Dpj0$Uy zM|RPFf&fD!QM{cyd!g?@Uk7}9Vpf|*VbDn6Y#?du?{k1P)tdwEZ$L!)`0#+l&4<1P z7CLlMP1)Q#r8;wXfMCL)lzVo~*Yx`K?N2OOuaqxEiZ&qOkJ>jYaR;3_@XXw<jhF#sIEFck7m8LGE~-ox?E(hcPWU zRCkN&0EVR_s9pxT_SjpNz+k7*r=;3+LM)PW6`95;NKOvdS4k>`Dp3Gg>UlDf8H{F$ za(FWV(}$|HL7G7b*a^f8hbALDaNi;4s?@JQTYB`&I3|uoZrZ=kp>#X)8z2TINv(l7 z@6vKm)0h;Q{eGwLZV~vhfx@-v`=HDv9$dcj`16StH6ujUzb>`K-@535)N~ z!lXhV4_KwWG~9)@Z9yBYNdQ@&l0_LjM+L&5r3-HXF&S*{SZaG>5HWoL zup-Pvg}23KhU*^5z|z`3BH za#Rm@gy0qA$Cf?gddng6L6t5DUX`-(Lj)D`d- zzkJ>7$#6Tn=x#10+2)I*t(Urx!%Cs)vU(t0d>Y32B^=B0;vECDK5xjY% zJ`*X~S_=fo`;?U&g(5JfWxCs*l#W5xBhlhGK1tHluy=79|CgwSyoRQv=SDdSBPCbs znzKnX#CYYB{S|nXvpfQ}3=^csvE&?K{%@h13&CQI?!EAP6WiA;wWCo}{qiZa<@W;`8ArkggnACK z%^8%wqc^C!JD5lz;7>6fvd%|XMzbJE7S=ya{=uu*2tTL+REao=ozN3XY;LqrgHU_t z+=vnmy(pRNcz3iXwL$D9=usH3o_%`$Tuc#QNfC1$$qJS#~7{gTLfR|a0@w3nfjEr4E6#V-< zo(p(DjSRy)Qdcd7>#Ha;oRdN$c&GHKCja13p;`AN#+_o&?I6IrSypQK;o$JqPeKG3 zgP;K~Z|rUIy)UkPLGBOnrk_Cl75H;&7M;We{I<8P-Wlu-PRr?J)2ZCa=}%DtLA`Ix zet1>{1>VCtr$XV|XSiBXlFnr>5?OOm@5wEGX`TGn4;oKi?|D3u#`C4U-Dw(CO|W1aRRpKfOpOfYDU4+3blKE9W}0K4UCq4=RY=LtD3k~ zzvxoPcxWSJ%h;1)HUnlD7Woi`k`P20ao?NL5q*Z0dfeKT+Ae07ajR0TORf!csuV>x zyK127+=B3j7J!pEbU`m;iddVI=oJZ3HW_l17ZLvK|7Y*r+nY$Pz0v%gPtiNcvt{$j z@`dY|Vb~tynPGOD($xNv+*2VI0DDKecXk>uPmNmJO5OCmCa@YSn$! zs&)CTOK*<=HMD=TlYicalvga`%|bAqBJ^2!MOs>+S65f}&j*sEl*K;X8U;c706-BN z_1MgCopDwKMGb7Z*zZB;lKTUMTBw=AM8*6x47e~jV5PnR$=wU-3p@Iy$BtWVbGF#!KHV=v5KwAyWRn*j? zpEeFGI4_IgPFt$f8NaoqUx*RecrGh`8VkK^9Ule)>hub-2-MZC*dGfpNovbDL z6+YsD4u?Er9`x?^{KU5E4vW}w01TV5w&xD>=aSHy3WK-PA-e~}t4;nlJ8waE3%r<9 zwRv23@#8_JN%h%&GC-eJcA;FFy6w`svH&ZM*-k-W0nzVGwKG@qT)ZY(CM2k}6GSw{ zkUX-oAR<%)^2j$q;XGFI5wcn#XVrO|CKW%2FF+oJo#`4 zHZ1Ys3)>$#2{YP7K)F#>2J^`vB|G3Ls@mGP`5zD~NJHI%B&6UmFOv}e^gxZ79 z8w)Zk;ebMll@{kkni_S-K4r^Qq6Qk#|4z-3KU92*lUphQ!u=K|=v=)##$YKVi;8bO4 zC3=nS_xYquhIo(!iNY9&#)^$)=#r3)Dg8E@8{i;u>>b*av|`0VdY)NJ(8F|4IOwvk z&S8<|2>T#eoGQxsN3=ZDaORgjw>?e2zferH_FWyshpAGxK!d5n6oOnEJ4xZEd zw3wt~ZJ~XyH>YE9Nk$jRWyy3(vs2B*M>Yx)@Pp#Gr~CLs-jBG*QBh3tBdx>xX9T`T-N@cIf!4zG-@FZ{TdNs| zd1sgb>CcuNn64*FRHb-RL&pX~<2MfexS{{{im>#}dn?rP!|IIG^}v2yRi1Y==gp71 zt86Zr`_S{x9`XW1!cC-xqpA43_yk7(#qmzS3OKMrM-|A$)#9`s`}U=EOsc&#ob-Ij zfP<9lu6ltZLbkqGXb`F-A)*KGI;8{rnnZ-KbN~&mCK^CZ{oIjWT$^O@O1nu{#DZ7i z^&FB33cXtXolq|i2pk>w+sNg~X!m}@ z9Y)*e#;!1+x%T^u#_%;?U#kwg#oYy@YpyQ4)pgxlIM-k9+OkIbg>NmKh`^;)bNUwE zUqxf0U2N^z@2<+`f@F42vLY1VxK!+^=Xvp5kKcs4tMw>I?a8TGX>j5LP8G3d1oVP0 z2*I(?Y}>*U_$507`#38yN9d=WGf0X})ApnTm+*6{$7sCs5|A?O@;Yku_MY|ews*dc zvwtiKn{80Ja~3>nG{5&K{SRpS8xJ?Q-w>^dOd z87FZot3x*K+5ts;Vl+CQH)?A2@dg<@_jPE5b#mmxO`CDbEytfMzUg2-LhSlqeV%Gw zOJQ$o3p~bxP*Xkc&mf-7Vg%ZYNeA9h2q?O^&rj_W3XBk^$QMrWOu=kWY@}%sHM!)R ztv~EWXQTX-Vm>Vo3PN-diozc;>L?p$kYy5j+MfcU-EH{q-gecUefM6^Ry5eCclyJM zVP3HKU<5wkVZ|zM7lvG`3kBi+)LUb<*%C)w!v$J#m{{83=yXwF9@0s5_@UyqKbLWow z?9T1o`#X1cckbT)!_MyAJ3Bk-`?dC>=4TFY2&yYrrGtaniS+NU;K!a*```A@_O^PK z(&_yZ1hr-TKe6!-b0Hyg=O2xbhJRxsI$++pC`B+m9l2We6qWvalaUUwrqvXmsrMIU zl@j*UPo}{BkD>etWO&)2Vq_oO=hE!5N6jhLqZpA0dYS|Im(UCGJ9eU_$xK2qe%MFI z#GRJj?eSk=LJ<&(4-a|(fP{DxSZ53CY$em|&waIXlz96OMQ_Xcu5?(idO|7AZH-ZN ze}k^sBf=st^;gDT1@805O88_mSu(lYbkz_@+thpp;N8Z~@%fK`+`hH7+>aW+NhHwj zr>4r!&tCj^@NB6n4XrFWlr1&)e}p8*YRy5exk!pZiNTu*=esle87BM{BYDV!gBL+Q z{-k7c+ZKtRzJk}~hq^lQty>k!{7N^ZSB*b~;`%QAkm%G#dSASxzaKh<*f)0{^FykC zJalQidnf*;a;-n~zE{GF`?d2ug9_~1Q{_^iTYujg-$R`LV{pw&O8&k_Qb6fc<{ivn4>7VuY&9PBOh=IybfW=P! zxk%4IG&;@IX}m}W&~KDdgae#qv-A0BPwk%Van>*LG9S*iPcEk^!_J(lOLP17gF$k? ze{W}}|KN6d|Md3m?svD7dwX}jySsP$yJTmW-nsvve|qo!_9#1r|MxD^Q}7W?3%qRq z{OsQC+l<@=F%~$k5*Puol?IM2q>bVaw1pwp47~w zYsFU=gyXo=rgs2Os-+b1SfSVAK6e{2^1)ea-!DNMXp&yQs#L!F{4hZNn73h=w7oBF zvd(_pj!s@Yd7-`;3}jD4BvwI_ir*-<@3S0>4WT~+7>|01s_9%iBSqvx`cyHqkH8hb zKl!1$awiy4hUmohtcsm789%s%rH1-pY-xSoNn- zo?NN!y*n$_C39zUWo@JND#MVMs_k$Oms5bNzZRdg_UV3a2eeQ4p>}gnw|+VWJTwB8 zgD6e8n=Ro<>x{IPZg2=y)Y%{}MC2^$coOGOFP}*{Obhk8`K15weYPm}ZKFey&pU8& zO$KFWvv74*|c}Mca;evvwC`S=ULIExp1pOCkH}&?ZN%QTi?e)ot>KkSn+dfp6X@ z{#ll9-)fgSo0jM&!iF4}3pK>&s?RVVS{({1@cLOf6hL_%UL9%CUjS)sw5q=E11&ta z!v?+9x{(rA2!s(mwQ<5j!=yAs&eu9Ct$uWYqdrH|ip6xC3xG;-jQdjB>BB=Y+8Py?Yh#> zNAvMyeVsW(dP{fb0L@|QF*6fZ0?@DE2tnC4P?XL4>}`UvBbj>9XU>;ezqa|44U zYXHx|<6y6{@`MR)*yilIemu!j?g7_R-b?w8Xv}*gQ-Lh(K zLNAuTJ-~+R$UnzYOEr)+{;s8!LQsM_+)_ul&cP_xP0AvbNZ3oad4 zHG(RpNQZsy99WQtF-#jeez=UN0qLw9*TT)rkR;+wZswl8)%A%!(I*koYM zr$vE;-bFn$W7TI4r*>m3qwPk%B~h%?b^t=B_gmRf=ehfXE+P+YzmxUVc#&3E1x z(`((XVXsh5HN*~1kW^|;@#TYgAa}?MFtIe;P z+@QJ}s^(t#2HJIOEY_Iq;}MAh@lNkvZzp;QaQG=9vT#>=a0)nJo6WoZ^K3LI5Ris) z9rheo@&q1v*13TVStFk^At@};x`D;fn$F#x>g$g6m0jw@j=ysBP~3H`r<#{@RG(;I znS?=DAm=li$<;;X*3JfDwFX541<$HEnl)zMfAo8eZh#B@|J2W&`@a9*y?eLsee?gj>Q5X0KgU}J7k)ot@Duv; z1ZCncG=gtG*ZpIie{gwPzw_@O7N7sUo%_4@cK!2z=l-4DZ|DE2KdtjXZ( zoSeLj$R&zH*)!13gCS+CCQHkJ8y(m%9fW5h8d6z{Am~CYVsU~o_~0eP4sHw`iy%eA z6msN(^Xx6lpfk(+`G|w@&yx=+ffmmSB|ejb?+8K-hr_Io(Umv`=#6?6gTy(5&y%7X zjli$CE9k+O5h}d4P-OwwhU2sZ2#k_)uo(d=!|wD|$A@!NMNd+g6w(PvK#TUQLo@)) zJC>H+sN{SU0A`h9;E3e!s+r=SnyOCmPBz#ij>Vii@#6;$-Ssxz8jR zW%ibOKz7jDHkoaycfi@~Ts@CEyL-1gUGlxv-vXD1@4zs(Jsl~5-Yzmp$#$m-yie2V zRx-*yq`JU)Ue4ev&Jqdkk@`DIPzT@M>cDf0Ayu)Le@!oGV2~xS=qG^wOU7vvfx|$j z1DPDPmU%ItG%K=a$h-)4nyKn%F&{?+)JynG7lqL%a$`m=?W z3`Ck9q)HBw>^Hbt=jtSkB;7Nw6cAFo42?J-O=DH~0NpHPIn{Q`&6=v(r}^L#QCPB> zh8q@AbOMw9Oua*NB}RULdNL<~oe^^jJuVm9Nn*h59uU9=bD9NrTj6NT48yK3k_%G= zUp<$C8P-oT@JXfp2!I&IVjrt&zi{(nfbE)mpbpv_yfwPyH`0Z)-Fy6p`rYgG-o^;b z`9}=A#!V&ZaMKSN;1#*YL(aiCJ3F5dZ%CZpjIvUn5^(=#zqZP8c@uRG^T`Puh-Y+M zx_Dgf+`U&hG0%>k|9tWb7YLuHZty%EzIgup=#yt;ApCr~F~}0k{OA8#3PZzm=Pg+m8frA!ipqlQBncfsdz^ zS(>7}=o7}O*67x+Up>=E)>v#_jQlbu{VC;QJ0x!NVhWH0^pX0_7f=~JPiOQ;H+q)m z@8?tPGU2o^NoO7HgqbPUK8ABCTN-^Bhv^U1AIGC7;8jooQkewxhs=WPpPg4429>9X8n|MD$#0^RBt=>YCH#R^v= zz;nM^WsX5wt#Xcb@@4CCgu#m49w#5S+AgD2jm3vmTb1fGT}`!B|C&m`{5AGrG}|ga z^c!27t3DN+th0$GYV&1SO_Ys%(nyw>^B^k)8Ln}PrH+`iT32X&lsy5hb#eCDXk7u1 zf9ukCfi=#2{yuBkL`t-6Dx&0wv!)^+LAGlyq=fLYp_CGgAP6iSG?i1=Nkb8ke48dT z8!B$lhD$?1mUg#LmEESsM7_k?)1Ob4YytfAb+4LA%Z_X)M*O(R>7+=`#z|B6l$81L zatl}s+)W_aHjc z{?j|ELlSy^h;J_pwbq#W?RIbOi|BzY86&r_h(z^st)q# zRtZo;*{pF)v-eE}3V>y8TxM~SZ+*+mr)Ndd=(*JaZ3D<5lg5qkAwih4g+;Qa^QhSB zguFf$_Uhu|qV<{mEJA!fpPl8l5YLfwB)FH+hP+eZ<)SVzwNYmHG}QpAq-{|o%1z_F z@Pf%25kGol9Of#5{X_4CP^}(*Ayms@5Qj_b5Or&>NQgTq&TK$Bil=+*M48obPC8ij zq}JP4{Tpm?Nicb~D?Loc+32#t`4G;UU8DtF2IYELSF`3?8XXJ9wK$3J z^Ny$Kz^fEuoY^>4N4{aE6qo-cFBif=;%aS&BDgCGk+BkX(gO7%@1XoUQg-)#EC2j# z@BRZL_M*r3q4n%AOCEuz)W(KJC9Rz4Zj?`mfFLXh^aJj_eb#vx2RZl$f95q4-0Pqd zQS;#`M;c)(NvXnMKHqD4+;Pp**cd2^kzZL2_o(KJu0@EH;XWm5SAY8`{5jFFwJKgi zkN0&~gY)8&!_wSho8v7AB7j`X7$W2f@_{3%?85ODzW!kY@jHGCypv-_2xj|$R-~R@ za{3|GYGpkaeH(pCl8@PVK91;x2>Mfr2$#z+n-H>k7*laAT*;f0*NB-3?mZwYv6>yV z)|}Xp1W-&Fk&Lnd70?8ibKIYuz>NG z1)dbbFoKszwvpj@;Q&K|CCJ%<3^QX4vJ#9yw2{Evrk3@2ayCie6 z=>Wh7AS@nJc_t8VZgiSP`+<&Vysg>|(S|0w>v&9=!B6rh=_pwUf!lV(>4XMsRNgug zCK+Xf4usBD$n91gde`m;AL0 zc;fiq>clf^nA7*t+RC$`!xSbSUg1! z#*(bMc%%m-S%dJ9cUB$lQ)@ySa|NJy&P*L*fzwG^e6<(TqX;~1_f<2HPqLqa3-tHg z#~-?23a)%d1b&GAGx`+O*Nr}FNr3Gc2H-)aey6wF+r9rsd)oUD?8<%pY9~!Ul*FcE z-S1Z1l=w2sCNOus-WL3KS9k1(&4)o!S}t?toofAVbj4P^qkAkzlLcEA9T1Edk6K9p zDd`x3QDjOij|fg*wiRjw0+t=wll-n z#w^^k5l@KlZ?9jN9yfE^)0t{9MpBT0XmSQyFg?Km)OFBK%x!f*r|*?H=b7$BzvLGw zNn1mXEd+QHnz2?Z;S zV)IIk#aV(HM#Ngx^E7q@CU8X|^Edzipz8^^NI^kCWng+;H=l@1nEK16XVTAC`iji} z5M+FJ=Qf_M46t7&8g?KiC<*bS3T_A`cI@udZwY46ePQ;45+W6oOV!}j zbp-$d6O9DMn;_9rD~5bPV5oEW!R-h9Qjo)eGIQ09A-qhZ5QFqvm56JZ`H8t5gw!ZM z%lae)&LBk%W{I|znUfl147X-eqrY|u4(3s?t zt$(CN&TGAq_Rf0I?%qzs=V23yfzlb_{>~splGE{NJ|oAG=t(+Jzqaz>mK^qE2B@W| zz5w?>dv4&JmQF|cCCdjehlx$MfE&ETC(Or7pfD`*$t=tyc6*$nZpRM|GMkB)^Q7gT zYRw=L8POz72Y4KCmtp?Pfw-v< z#5;134UjRi>tb~f*T>B*7Vh5L*Tc;p^y+SFttDuC0&AXBiW4}ek<_lRt>wJ9zS>r{ zHeMWHm8ALq#@fGn)_$j_xO;d<@yxZ|Plq&}fC*#oc>cG%1GTC?+?@x#y_(+OY8{M5 zMj|gaDzF(>>k@MloxK7w)gh*k>>+g&;PS~B(z8jnZWzo{^&VO{8g;*kvSb4v$|lBL zcC&h2_If?_z^5>0Hv_W!)(lYVU_Uwzxg`mh;0A|Eoi(lvO-v2uk~45#ayDf zn9U132GCSj&b)Qdo2rdY)P>6%k~&2z2U%yrC7K3Rk8VTddza@h5*C}~)vRunKS3QNls_CVGtPWW`! zC`CAHwtnHEy0k9obzO~%8eWqeU{N$j@n(k7PuFrf4Vh)nr(N^PC)6Ug@)@;gtZ+*0 z;jH(Z`jpptQl0g?jjsT<;w;kK41mLK5o(nSajfHY!2P#GS67|9F^Vzv zA+Gh>x*hD5UJa&wj0dr)hic*zFol9MM(%E!9v#Ct+>P74ow^A8{%E}mmO8gos{mE7cF_zEEapbKp2hcJj@bP0!%!!J}v&;hfHxN)WN%)C%X z4{i7e0Ao`{b8slplQWy>Qv@Eq&{$!v#LP09cdfV|adzH}gFfjodQr#1f+>0iy|U9;jR!!j8@KpV zn|$Ot4G^W0m4?B!Lwo6qYrf8(e43F_pZ82G4pVfag*U117QU=kc*yZ40bKC2QR;dX z4;h}$!DXwNr#s%sq-jD#ZjQud4){UCVY}f$kT}f70jU9Ir6w=34(ZZXI zpT!GFJBwL?j%G8Sse5CB10wf#Oyo<0g)oIl$8oGdcPjK`;>erG@{f;oxKthMT`;qf zbBy{IoVT;!ylsYNY%#7zh2K%qS+#S{5xhYi$?2t^z|O~c=rNntwQQ0|0HNB!?U2v~ zKM;WA7z5v;@qDJa0{R(gmrLCH;Lv6h{E!rgFUWzr1!Uk%Id+xd@ED7X;6dL5ge8xF zlIpr{-;xEJJt)u3zAnX&OFArNz$J&pt;!;C*`B%%M;*6i?kcB)pn#^rkb+^G8sh$f$q*qx06G<(`6x6$<{S z(u}>7PJaLwL25mE6n#?cJKv{{cO3|w{hBWE^To_jh#%drjoGm~7DT6L<|P)UC>;dN z+w{5A9L1j(I7QBGUVM_484$49(xm2FkhMZa5|X>43^5l0dkfBK3>}P7mLX;d;#4|g z_|?!xGfecvQ z+2oMLtx9j}h(Wqhgi;*a;qvH_O{BG`R6_Qf8RCMMeZ>5$>l6-{vCK)Hi@BdVZjPjM z43vjNlo(RPLvcESGGBr^B*Tp;g)zEALxdy)AA`en+Z`seiYen@T{rf2cDjJ@ExYR^ zh~aH0)c$mMs8Csm{rco?C;IH}Q>P0XkXi_`dxgs=K}!~TnK~ZB(Y!q8eeWU9*UartYT8o3+RxOP1kGAfLUf6QzDxjX1;jyu z$8VynUJtWuRHulDGRdYZ=;!nhN3MX;S4SU(R>3gl!WdcMJ_6G^;+6eJ(+HHk*A{c zDM7tBIGZSSsuZ988PAqZU@!*Z7#=D`uR4Xev__IYy#$y5UTQ!?7&8ba4*z}De-9Zj z_({vk_;7FlWCIJU9i0~KZ5UQ|^NS=isgNzuKFV`oWuc&$BYw4jR*d!9LK25J5RDB5 zvKW<(R-0%;gR3}c4XPn(^{Z&CYn0zV)aReWz;8+vttA!Nz8f$vTBWB0JIr;V4w8W& z*!1pBThYh3%RGY=x`Y{-kwfacl`ldQE`?jzzmlbU5a>;8ruGi5TzPsB)QLmr!=vcV z&YiXw0IE5Kiq^>_WuWuEwiDEBpe8PT+1j2Einq}Oy+FNMLC(@q>47zdCw;lK7xucY z<)`>LO0qXfhluiFDYckSQ~Q&F659fTfYvlR%fWpEb8&-q8j#OX?zI6w=`Peh9wU0VzoO=k3Z?^vu8|6XgEeiW^6} zJ3Enh1DIXu&MMC%NnoCC$%>}LyekG(4(76lIC6A5xQ+(~f+r^KU#EDj6YKCG3b~Cs zrF*N%@OPIRB}xx{`%EBa&+V;2cBc4+4`E;x>{5P|SaH{ws9;#R!48TgvrN}fRa$*< zBYthr#7T+}Dxd@h8GJrYCR>uyJ&K(T8M{}vqsME20n$Ab<*#ZoM)5cX-lU`0FG<$3 z^sb!12D5y^yUiI0$#m}&i+yK3>t zOjzfb5NJtF5}rlHZ_m@wC2(U8EJ(EFox!?rRIg)zHd;xIIS?Fq5tz@lXHqn`O~_PX$Oa<^_|K>X zaqXV)0M*n*TOoxY+fHjNefW|E9S#v#w!s{8I+dq#X^PFP%ykr&d5Fmbv5fV9X_)=%rJ6Q>zB6FT%!60*)IC*sUDIt24zbn zQ=I|WHv(MdQ`lGVz_ly`E{Ksl({Tk2ronIyNeIDGR%EFfIc0mpTo{z+qAOXjL$e<6 z8d=B+x3@L_wYBAdp{RLJm34C5|0BdC>CyX{SoH=7Z-_jJB8JBt)yKB=$zgYrwd{O0 z9(juDO2z+otJc^>WtY-c`bs|{0W7DJzxT+0Zp&a}_ZC1lNXJb;lS!pu6n#DN|EXRU zYFX9BAAll3J?I&zO=B{{UwD;iFlLiv(AsPQN{AvR$R%KztoBmQNPxbiz${(%PsuPR zC2P@vMXS4C?OVmbRfDy@KwqzxbhmeVfjo`7%6uJ#Uen#c_XaYYb*4_4CbazOr*Gaa z@O3pk4Rmg$#+tozDzB!!=w*?EqnPdIxxRN(P(8R)3-p6iVmcI35!xyEG;H?~zQL@N z7z=bK4R2iFmVYC3riEYrn*5d*RqA$$Y!WOXy8A#1K~u`eB_Ls=&Ad%j;|Og&LZS-M$c{E9GMzVDjgg zKg+T{LWQuy9E-AtCLEaWN;^VLH;4PuT6$;T(XCtX*drr3$bA4V+Kti-C5O{Xp;lD@ z7yP_{&4cMqXEu(rXke^WDfB72L{~XPkJ9tXulNuC$B~Sc2f9Q|4VVcv+LCDZvo*1BS_}_Q!c~De8#{5hjb=2+D(XPl!Q2 zIJk%+^tByw-A;s&QT`SJqbDft0IdyiLDjuE&@5<9l7+3_q)=#V7Bw{jNvAOmmH0nDJ9jZJDFerV za!Yl?p%FG^O8b2Zqe9D1^dsa`AIjsHVG^xuAqkk!)vYm`PaqjOxX^c55O(M$mr*gF zh(AE*2r_rSIyyc&arpz5ZlUKy+|WnjWwb$gwQIdPx3>ky9%ZlSuAnjoF-|oCzD)ue z@YIv-RRq@ieS=i9|1+sP@y!d}|E8iCB~G_-duL~-cFamVd13eROuZBU`4eDw>uolx z9u+P~3-}0eYH`6ar`*OT11GzWd8WL{wh8Gl9Mtpy>)~rm?LcphsZG@@*0}jgyoT+D zo2b|8Rd-LNG1!$7!41K~3kcHHl?{1az?mpb2d;LSepDG?3q4wUj?((iKY!f2_mKVz z3*1A~BKVBkOtCUu^i!SI3KNN3M{*jkdpK$quYq`tXYKB7LSM$4t|0D=~jY-BlEkH09`<$ zzYQ|uclX0X!dlBoEXnMANhceq(%8nYiV-?qZsg%VlpAox#c_rwq$=qKZ)TgB{C{g03!M)`lHN0BNN#39oujE~ zq?MQ_w!(-CWT}6{Q`Y-J z2R!ZQecvWjE>Lz|A#xa-#lj^tp=7pKqKN0Xt#FhaS5#8Z8|k>!r?=kNgL22+-Y#b% zL9Bt=C^El8Edt4`+aS!{131#i@mGNsH!VavFOEE*M z>e_gqgIv5O)@RYY3dgg^EXnAa!IQ6XQCGwwUy4<&6?l9(#$;8zD(A45>B?-#$CSTe z?qk6PFUfzZXxG=iS=}a=H{Dp%!@b#$-JdlzOk_!4Y5h_Jj0D_#q( z^mQMkI`s5aSaOioy4i9K0QP!WbFh&$u;(D%)mZdeP`ba&?phbf|0?YIrV#yCV%tGV zYhtiL+G}Iq^*JI|XW^A_j)O@Qdpk7_gm;`?x?t{~!3nD#_}#_6p@;|V&mTa(!JyHq zyShOj1we2}98KZ$bBchKF%b52B_4r7Z***vhE=Kr2xLPHGH0kzaGueS+Z1YMA`qf- zeyV}*V+U@ZVtK2RspzGnq4q?My=@R{b1+YJnSz~vmSSXq^ih3OQouFAy+J55H)O;7 zmOT5HqdWl|+H#T4>Mfa0_O2VxN3(3ou6rh5wi>8$Z*1>}?ZXdw==d^x%Tvqt8uIRd zg$_BfMtZwuckNvmY$J$!owv61((>BI{q}tlofqlw(Vuu`AlmiMIEP#Gi9|>IiDvfE zpCBCfPd|7Q`TchC!xi1XpPCid$>TY}1xy?6vkw$)Mv+Yne#JTJp+5deG;GR@%VXk| zD)hunKzt&$Fa)%c-uz{epC$k`#xW;xM{U0jK?A6N?sRG~B_MvoEP@|ehrzgpSAl!$ z8D+Q+R)JVMU4`6uYCX<&gNt(Qfq#n*3Pg;I(pkFjq$H6PW7KH@%?q3w3G_ntQ_hhe z59bi)f{d#+`25609xC0yD#eu)5p;iJkY=?@BiDN+V2$WOsV%*22ZSvtI(65RIBA*7K2EfB0L8@m+Bf+(s!8yzk{<6NMQSJ zA+O3O_25#=v4sH*fa1}g7o+X_y*(v+x$IRHu5#f02N)4iDF;uADU`g`aU%kR;f?aM z4a;v&ql~r%1A%?TFnj7$6v>5=;ER;wTLVvS&LM6 ze>ttgUWa!|SN&3FFfSN}6+RIB7YgCDKY{%ncVl%*&*06 z2&zWObhxeg!}-MjI0l?IT^Nc%;0pD{nbdLeaZ7Pv2!6#T6(jg~xmD>sVTTopFvgl} zB>;*DUyyJRWAt!rb`OC`1p&IDRg;APCBI|@YoUE$d-j|H9gMG*w=NZN2|^6-Kc*7c~_x7gjV7~2Y7BE*%{j<4lR z2yKTxz5pkIO!ty9e`!R4+KZtjuAU2~XOp-RuAYQb*aVlv)vFmIGbtL(HRD60a~bDC1r3WcIGXdi~F=aV!<;5Cpxs3X6a>34p~%V4#} zYoK#*czE>kB=n8C7#v6I(8XY2Ra(lYySu%6!E;s*&;mbgZhf6Yfv^4O1|i@W5lH~USV(eR5w?(X3rKblg4j*or=Ebw-z`vG_~F88wxey*l|P2tOtp`$%rG@pRDff;M#9Bch7A&K$XXEL>bmIt++&FF z)LaQDhpSE72T=alzpFU6n*xB6 zu8-0Wkghr#no%G~B;g)_i+8&MtK@vQ2j4xNfMd+;GAs)xA89YGt=rgV&Qb`9Cg?fsq^ShyPf&8)8QiQ;TeGiq8 z-;t%OWH+XaUx5k1*TM!AmA)`%p@rv+fx_Xek&6!+;GhY@%;FSrJabm(pf(&Vp=ORA zHH`P^6mTOGL0W~i_I3w*TWHr6p{9sWaql569o{#T-z39o$epbVC^-WYp!K@;fmTsJ z>kP677l*)rDU!Mi*f!ih12%`q4Ib+g8AoxBS8N4C_a#*{^TepNa_?*%IQV~z>pG?! zd1OAo#NN8!Xs<>mOhP}iCUQw*6dEMI@N^3o%}x zh^-lbiNf!P21ga;FmGy)%}5k0FLOw@GAD!}x|y^~n7=9W55hrU#Z31CgROKPXBu~f zPy_5D>Me+0#ifIk(oZIoG=i6#!G!sY5`!a@=j45AMw@zjERltyMT9ef*uMmn3g9?2 zD1XBJt@C%9a%)h)Jz?bsu0NEdh?G`o|MG(C!!1a=Ft(mzK9}l*T3B~lM5D7MX~iaB z+k!F?rPR>F&hb9N8iLj;xU$83f=)An-wZY?v=IO%3nnVgzLO#W8T{ zd|vdm@kDp)SWCs;QG=HNLf~mMYi4#Sf~OI`)7%{LaG`^>&c9XA+XQJ)I%lm=rX2#J zz6MyrHL;+rowJH^1~GXA3P<)UNlTz6dO8`MAYqYe>x`bXtfC8K_s)T8dEc8DOSg8* z;8PN}EUPX>jClD(iRZKVa3~*s-b61V?ZnS+n|@8+JTSEz&XkE-&T`s!g+d<~&5LH|T1@A;lrh*D0qvXJ;urNiC#LRW@8fn$X-)qkm6z>xW`Bf0b)9Xy zm_3CA<%kZ;%rI$zeuKPGG%UyxFwsm{uXE$xqFMBPxr6(|d6_ecvg3n{>r(%4{!wGq zir}sU_5bOS2_34IoVv-9C|D$*q=_~$wCdVVn!wY-PFsojCgqKR=T?cn4ncfy)M|2S za15OXMWa_}bp~R2bj9$1;rucsKGDaZFHxIRpuEhm0;soO(mmJDD0tzLidem%@V7Y6 zYIHC1HDYg+32Lwba%!X2BzC*TLT6sQU(4`&(d!B2G&FsSCGDn82uzThiZS(zye!Fw z1E;DCPCzS6Z10WSI3bGD>MRc^!-=&D9au_xGxIcn9rhy05C<7};i;{LFmprqtbLH+ zRY7N|$56$T((1C#RpHnbh~lBy=Y(Ewz)J-JSaM(Uiy?8dIQp_TgW2U18w|1j0Nx4C zc)`igqoI8a*&Yt|PEa7AU7Wsr^S0hHzS3%t)Wo8wqyNNXRX^7)j+P!=c})YuHz^Lx z2=DlAfun@^)>2L%XMrm^Op`j+ZkTmObv;b!M0lK@8rvDL9m}F50Z{GOD&P8mmM64Z zQ8(?}8<^-Yyvn?^HRs071P_yfm6E4Ls+dasqCMH7oryBPZ7j4w=z9P z<++k(2l+)MFSErS4*5EBR3x}d*<~Ur0*Q9S>A{mf?Ti@`u1Fq|2AI|a(Alh6zprdpNjogi zNuT2y_ij7lo^Hs_D)7CY89y5cc(1B)`5|hLYQE@NgxE^wQF4>g8ba>pMCXSMZ?Yci z%+~VB_pc=GN~->#_7;z-`rX6d;T&jk{7#bLF@p?@()3`J`J>v+v#4Go$q3%wXXipy z%yhtkO<-#U!yGoSn|wy{n0AFSt&C*`^jf&UY<6Su>QRq2e8yu|+fkYnl=SgKI)cCl zdVSQ=lGUm9^HW9V&1%vT6f;`a!_QGkvWxF-4*jT44P-RiC0r)S$kDOFGk_zr)JSlg zwkpIZolfkGyQGVx=Oh|el1Zt=X1)l^a-LQQ=z*aN54)F&-x+FeqWJZzXR&sM1Ov3V z`{Qn#~N7AI80 zP9%1kL;KisG=S?Guw*(!g&dfP2<>C?3O2cdO+}8XftScELE}s%8L-3pb3q}G#p5ux z9yNNz$l}rYPpeMsY;{60oTaU@te$FyUy+pzaX>8`q>lOl)+9S$S-MGFLr6P=ampMI z1d|RM5oD9n3ecWUA>p3yB6G>^zcb(UCc$pmqPm8Q1x7@PRyqrCO zEMPIztt!JrGZ ztG4@iOd{ca1pa(w&$uiZN5)E(Uycr*9KFIi-YNqLo~ccj0H;tsQa3$lNjEz4+3-Qf zFJY$~!i1H6*S((n_~Oa`g>GP3x53XL+JP9QxW!d|DQf$FA(WHN51 znz}`xXjX_TQYU{b8cA}jRU=D#?44zguG*fu@c)jd9s4}Xoz%5BB~+^6I|jeSS)5Q?gqdqFie_MPdJ2h+(^M3!YN$`1 zlT~OmN2{d1unu2FBM_j7Y>6RYoWT_(5%N=}FE)keyUE<|+_b&fs)*o;dq8;{dLMrbVPndab!aLx)L_nLGpUD9SqhC!yg4_;|o z777@OZYDnq8T(};2uYJsR@aoBXy?90TfTY%{B#)Y-P^sV{-Ei9(A(?XCdZY$&}ZF( z4+~GlfgMWe%m%v0)$>rW?2N4JYn|7;=0@Zw6WF-T| z7ObvbT+@!MYUD0!uYO(aj}~;(k`Pf!wS0^+5qS-~Pc7cxx=?a~V-|-YSu$LQ~!fRnKZI|U=n8$ER%CCUK=$*9gIHyi{slS4aXOpnw=uu&<#`P1ChO(wrj<3;a<$w-4c=4Oc}MdA z&_Ni#NB}LTX{p}iC0JR|Svj1_)kHr4o1&L~d;qkM71K)CgoIX#J|`KDv1vW(eqPY# zL8n@*3c8p=?L)Bn^EM^_eu)jZND!$*Q|whDMWtIhcmV-(17?5imgHOgy_fpFZwvjW zlYrXA##o$kdfzo1Jq))?y^1i3+D&$CjMg=MGX+|AN}I9+U9*h31TM($XLhCn%^=`C z=nurtTs_D$IObN+zz5t?#?AE>87e1PigYQ>HkkmyS8Bj0%6)j2&Ms1PtA{ug#{E!R zi%oHb7~wM38D=xfdzOmNa_lF?e_(*IQAa!0Q|f`viHvIO85oxPh_ICFFac+yxz5F? zpQflJh_x=s^%mJ|*m_uo-L%n~Xsnl{=ZS{t ztdBf^bzAMc!>ce20D!dJskcqdqEA-reDoQukL5$Z5aYvv>5WQ=>FG_!hK}pJ^|fzN zG=k_0;MNw=?QIN++57m>4*y4EL^3LUb($!b<}-%^>clTnb??zm?E@Y&Oc^Zso{kiT z(g1mCjq*PpJ%R$8u3d_*8PYQ1^|H|skB^@K8EDY^pGhbBKX#SsPkc<{A$P66e5y0@ zeU4J_w?{12?f=g*W&RJ^GPip(U_jQiZ#MV#DT8p?E7GdZq{#+h#xtp6NRuNNy^&`5!;o;0E0pa80hJs$1%_ zVy%kjp!qb=rnPk8WwW+`W3FA!Hv4nV++sO{td3bh&SyCz@#f{bpvcG8rB_PmpjZZM z54#O;=Yvq(3fqKLL(?uG@oXqQ(gkdnM(>2`(!;e^@469TpX+=#V3HTj31h62-Dv}E zfyPLid-_B4^U-z}f`=-N=x2E&mHy>#T#o=A4etC{%+C^vp#*@q2Z-<5A4&Y6vx(yA z+06FcM@S(=-NgcD6ZL%6rcF;=v_jo(OjLw6tI}buRCv{Pfe)RH^3!B=Kw(?>E8z2+ z47Tu6)L_cwGW`y=#k%LjASPzM0C z_R%|vPiFcNe2*fIyd}pesQ8C(KVQ=itlRdiywiKI4NJ7w8}w%7n%hvk?*9Gz(I0lz zfA8Njzt!hEw{PFMy}P46Q@`%-+}+)|d;1SNyLWf?)Mqb>*sbcJL?C zzrTVXdrs|t+ds&o_(g>qAeJMoU#9SAf)@|Gq{vZ$eUjcFcH!RJ4X9YESI#WYM`bTd zXTx4zoNYsbmF;5Kzkm0R672L&=4+TQL zJVcO zOSs~QKD(p#nboP;0ak}8;EqspSlE3<)<_CQ5n;IoVr30WW|3HKSazyKCh5#Bqy7vO zBEMO?9DNcfIvY7{sy_pT)Fo;cQh&OIK82vDp(6ab8~Cmpy_nC=a{t3h`Zh1V;j`Tf zzDBGI=2M7jQzhffZ}*d4ij4nk;)6Q-3_!R5l;?9Zb?KVK3)D@M(=s^gb{cTvI{PHo zHJ4-L_St1~Q2_TDr;EyQaKknZWbYXFT6h-dyO%|VZHoYChM9iskJRaJMmnQlga&M+ zixlG28VZ%!h$z*zSF@rt7T76vMlF2g{5_it@(U1@ni_}N4P}txA?U&z3PN!0ENxR# zJ;k3OfKNK6&hOhJ;V4Ko36)$rOU#&= zh^8HhvvRe~5SSuxm_~J(W{mCUG@oG2$CU7rLxx8k{Y^Dr` z(Xtq%zX(KKx6W7RW&tYCAxI28h_&&uf1Usu5nNv;cKQ_KJ9MTXc1iEK^XH@s>QR+r ze3^pQIFO#m05k0N_6V3^rw5sx77x}?ZUkpoW>L?RlGcLU!GazAu6Ze_cJoTC)HMf~ z!HN8~Nzc)rd)2+9+gNoBN6(+UJ3e`JbnvTM`B8F4>B&+J$7ES#U9%Dq<**zj_9bJJ zy`+nXMWFOUHApgpp(leu#-Vhmgf#x$Qq3luXkT>BqX`yZo$1P%dGQ`tuoZSOy1ij8 z6$3f|CkCB}qWOH{Sxk$pFV6tg$q6I|W8VTez~ODu)9azxdCY54C3Q|HXjOEGRkuwx zSQ6=S$^9ROvT)MS)K1*0XPNOOTOR}*!mHyGz5NMYnfziDSqcO;0BYWF9dIP;sG}PU z<4MxS7FPtjEjlk+yQ|Sj)hN=!xskME0lt0te#EW5vB@c(>~D{f#jgW?;wVjhvE6BVrq04G2H8R+f3d;a3x z(W_T4UcHT8Px#`zy|;CmnXJuxS85xUxwm?O*0k@?!NhA8jM67mn4!eFU}};TZqP|NcPO(!SlnTXXv%$ZL2^v3IXJ#<~ozJXgv`Y(@QvP z(*P#}nD~(+t8zee2Ol|rkNW}Eju_xw&LHkg7`VGx?xA;gzJ8D5Fnjb?PhN%kd;LBnUvF`a=y^&p?JA7@rRZLpbT%Px zZwKqyod$$KGviUWEx@xpIXF3xsV@l;+tKWZfWii_asi~=)sMI1PqXJb)VSr@K?QM! z$#4WX!}zaI+Hw~2*-d#vOB>*O zY2W7-Q6+u3CIOy4wjYl-cMH>;`!8?G;3gnIoL5`j7N;2i*T`z)6U!1>s*Xo}0VG|i^oW+;pPzMR`vtc6>S=6rG;RH-tG_TEDG zS023tlw4t{W`>PgG)&6apk*F3uH|Z7_E`6-{nlpY@^XBdj~qh1UN0%2f63(X&D(mi z2z>8zrp?v&4u_JTI`^y3Uh$wa`riIb-0@-^2rMx zx2C%K+^$sHJD>e!dM)R$xuDtkOC7N$y3VO;DqT4{-hl~JS3=i{SGZMkshiuXcl8U~ zCbrByZPi=idbVq=b}L&Hmb;AYiq~=nTMbM3UG<{1NG*B4+BL87TD6*4 zH)DjZ?Nhv$sMek>);PIx#c*7RdXpGVb@!gOIS3PL$T7hY9EP)BAdZc<0&>Wrn9@-jT8 zj>r=1rk2ENoTrZ5a!ja}%C+#Ly4J4BOX}!eolDhGzAD42qq`*UswH!cY^<)$RXAD= ztu->Y7m8=DiNOU)t-|Djgx1FB!qit_c0oeRGrTaFD>1zw$(0yin9_AJzhH}NVpBod zYh!{z>T63JZ+~WtdqJC!fp7Ll`RQ{j zwKQ9{TmstM6^gt1&)Q(HE9u9lbDxha>cy3s(tu-MdeCcE=Ii~?s5mw2zNT?ED!6HV zms!*%lGZxj%pk6&Kwj>!S{1*@8MPIj*K;(j7QW1hyherKvTJQs{X(m4E3K|;y{$IB z)QaDXGH1EvucPusc0#SX;CePiU2|V%e|({*@k-kzNa;&%neZd)TDMKG$uGKfZtwv? z?uqRm5PmcqI2&d|9k_D=u!P`csfL^Y#$PUJZUOO$ahbwybSwtj9+uCr_XMeEja{`N5CRj^4d|ef$dtMCwdX5b$qPB@gOODHx=E@S@d}*cDYr zVR^xGL=Js{ZJG&VjKMbNx4qiLF-~A?X0RtHyaaiw5y`+=UTu=%(s!0OMckN|Ri_{N zcR-L?Z36DlQ+i^DfV$yPOSw)j*JaZtAI{~RFTJ5WohV`$q>$KaB4nm z)-fpL96Zob7ZzPBA1mdT0zZ0$ak%6M{pP_$?oN&h4iy1|U3Q}GsVX@B9?IHTM!_uOdD8?Kr2Z6+P$g0HT#1>>C z0mbN80fJ0q4ho6aClnKoJ8BC_8#g3OT8h<5_Oy;AJeZ2OoLd9a(mHOzL)}7e%jj_|V^Vw0%?fP=+uS-31X%Hr+~w2`h$*B8mQYp3a2>j*^nIDgqarCYPA| zSg@Df@G6WWvViZ9IZA$4D>zc|kY zfE^RtBo;dJS@r?KrXe-@AT9evHl3-PJ$jzoR1uUu5$2_21b6}AoxO+#rU~W{@4T=S{~qqj#6~#TxV0M#>bl`;59Qyia``VeSUKE z>iNMlierx}k?9qd1)MO{CBmFgFYK5A!D35W;iCRHv*F~=xHjf6EbVf`vQrx}ea*~- zyE9Ovhh-0fV~;N<{f*8x9K~%|c~!qt)b~$F01F}_L-;3B84moz&J)F2o<~*wqBCKP zB;!0#>jCa{w^A0a+O2Uu0O+5A6di-pKyQ}6J~=!_UDw8DwWgDA1H1#$kF)LRD9I)d z5f@Eeb&uw=;nstW$GyVLi}?%S;{EhQ4coj7>-nwt4H2VN^M)VDyj>x-RpT`1%Ut6a zT6vVl$t6ZIQv@st6Tn5_JkizbzCRRMQ2EU#5Sx$eeP*js&XJr)9 zaD~k-Sc{lo8Yz2JOnW-kNdb5bM3x(6O8kkOENJReCw5)}mLnxBovGEEpJIM%!~@{i zbmE7g4>GxeVZG+KeuPc`3ToSQCFjwiv3SEqVGFPxe^Fx_rLnwUneS_9&%AEw8|N^V zIV3nD2{P5FgG^$aOfY9SJxsHi1A~X;9$<~~7%rq^Nfk{=N?$ap@QWsq8%ANDpa z9t}^Mz$B;zgZwBXgt)_NQgyZLMX%B=Nzd)I>YO5cEF|{Rntaw$g!t2KExhl(J#dKh zzsdvW9lUVf{Vtz4-=vs-4=Lt%^q{QfgW8TEL7g7dgd*BP1RE+c#N|$ zEqms+)l0M7Q#Jt2+!m>*NYCb@q@eMznMlMG=I~%GiAiC@iE_Mpj@VbAD5i6lT42f6 zO_Yb=GwEgbwLJ=d_o8>E6C_r~R;Nb@DG!XsKuH9FHE^f-s`>#`59lWYgNw(uHPs%6 z#ydhOBQyJrEFit;g&4{0T9yN>Hdd%3+;y{o(4e70W8)OB}wwaLg@>B9E5uPNPR0TV1}E?jZ|cKh@)KoC(&5uF#z zhCRQ8m1)p?s13nA6!#uIdK7hzp1(MHe$ol_8h#cjc<=1o30Z`7F3hC~-VK|W-38zl zB)4I3zHx$H$}77+Q%^VM80T4l{(Zog#$0**S5u6!7pxXRC` zWrVKib6cYNV0C3v`)jh42B`7&Nk(OEKeGB3D5IKL0Ld#**=$ojz2r2YXyYcYqF(fq zqi9HAMfJ@jNPo~ICYBXm?z}$fL5)v1bw`2qdy>leM7F6Eu@+1IJy2v4A8Mwgg|vk%2``N_LhY=;6g!6&omcvp2I3t2F`@UW+vLGANJkmC zGKz?cd;~q~#EHd6;vP^|PDSKA`H;cznIoYr{yq4a zD6U6~@$^ZX43n+91G0eHN&S|@DXOG3b;;iH|0wCB%^6Z3jMOYYxtt{9tl#$dXOm@X zEle0l%dKORob|pz?*Qi`7IumA1jZ zf#VNmTB4WKAhGDfmj#|T6QVo3_DQM9d5EI-#Bt1F&ky}dH9>)kmV3RK5Q!PUa2ojl zXIJ8*Ude6e3GH+?yWu=}7Dq707$aU>eqhr?odNHl7Sw>ZOfFfy{XPTb&XBuqQ-!P@ zm3QzmM=PE5i_58MvFT#3q~OAA^zc^L8mSRTQZcfvp326TSRK47;Y^YE$yubl07iWL zdLVYoKv;KLg2c&=U-=5h36GBPe@&x3e#d@J?Ct+}OlYCG@AllI{$gE4& zv@%u8oJMNAnla^*RX3z=Utd)%6WcwdJf$fZLsL99HOr)(&Oo$<5x}%6Zam2^M(N-T zVl369J7#xcrwBHB39DW$4hZv zAk}9A2_zHz)+A$&qYcnP%|>O@) zolbRk{NnJhMugGuia#oe48 zQo94!mGQA@RwfN+n(S15D#$Cs5J)aaO9fCn5tfpiSu3z3lRi5A-#H2lM(p+yGaeru zAFJ)De!u$L(W_Q31^2m#dOAKeO^qBrdwTTzL`!|OL^+M$it{(Ka4>5p?q{{f)8Tw1 zZ>lnIM|LSJocw^4fcP;h@s?z-?230jIM%=p!#8eL-~$%sWm@2K2&z^96Z9l-RLbsHE<4;yuf+q zDjP^$W7cd5@_~PL?s}fI_^`0M)Wh4w+z~}^U zz3bF`dsbdrv8f1X1RL;vesS>kga4}qV>NyAiFIUPySeqCn|n)4zI0^5De-~g1y=&^JokzmFII( z5DkDOF1&tg55Kb>YRN0h5hx3aW>GTZ8mf_|Mb?khpR9aDyR?$y70UzLvBM1m6!U5F zzw;DS=t}&L0daXCk5eVy!sma>(hKXpw6Zi>uCd1Mt=M!?WPDfzeZ<{D!4*BrlZ)ii z&roa+*!tM?T7CFjRr&AZ9(J1$yrIi&-L2!7>Jip18SFvuY5?__P59IVu+ihk7H3%p z;HjRd3l~YrNL>74G(b`dUiIVTV>X_TMN1DVh4~Dyb*#m6A zudrBAdSR-*gn|$iJQ-$ZbMif6b0!T-PPKGE(cIlxz;m5&LU^yB$3(0%%&MiJ)q}^2 zwGq4SPPF#l1J!f5>eQHN|G{fbt_sV~z(TB{nN}mTJ4cIRmz(1DcJu~|)<8Q!OXD7{ zRFS3{;|W3E_>{|Mrsv*9iUI5-xKHMNIN&7j*((g5f$@OXE7mPI`fg~fNWpAFVuIN^ zW7UO>^FT-GD47BaA^xSOMYgGk6OJ6_s#>5ZAg*N}y|{a_0glgG%LqqWzD z$c@m!4QikV(&q+bzEvCb?7Xunuu?KPU2)n8xgmfj@qdKfZ*5Q7_@%p12yp2ypQMe? z&Wy%Yzdwf<_yA~6qRwAF$t=uraozshsnBpd09(7!iKbJZLcJ9w9MhGF<*-Zd^eJ=K z|K6RgQxN&oOJ4Dj@if{PsS`L#!3>@ylTF1eiuYEiK{1nSi}$unT#eN9UGH|_4wFv3 zkf0FUr-40WfhfUr%CQY23`tkat-};0PlPR@S5#}*fUXd}q72BJ-_h>aI$A&(%KujjMe_(Ge{ zQS1Z)vwWrqShYBYrwcpU<$&n8I7_asGY4Q|C~| z5(|2i(PCD(n#(q}w_)OW&b=v9=bD>y>sZQe&s}4q+UHfAuy*hEZufS&>K}J{yANtp zbXQt8d!eoD|62Q1&cKyk?r$yBd4O%=(^#Y&8V~x!4-h5hI%J0)-Do(7$LbDH;*@GHT>H?dx272(9PscI35~B9g;H9`GoJDKR%>Ge}Rv?BZJUn%r znkku#Km&VeYJ^1zZTc%K2B$_8!%!9f)^C0G_=cZPZuXAn_WaHT6W1)0!7D^y#avb) zQdh}5)n$$O(;` z&1|*0w(aaBIA3N%I|-oHwWZgSh5TC6L9HVx_qtP7-_X9VYyZZMKwSscbQ#4ftEXp^K zeb|f8b3Uw%&;t+}*1Hm|I=@N^D+noF8Ny;?GbT$&i7LoKT(IjL_(->BVP|M>rNmLe zbMFKZr=m4xqe+d<710rrD6UQvTA3(a6MHarEtg>o(J(Pbo>7O@hoEDO$rZF_Ml9Xs zU|x`+6pUMHUv;atc0_)Xff~Rxb(+CkV06OVMaIKNXXmrr(eh~|XgipKVB;*T53fb= z$NQM}=QA?yTOQ-&?jv5ZY@aLgi(2<@#6@90nQBA|Ok2Pu7&Oyuy@A=@qczR=_> zwpOaKsw&QK^alMDy{UBPEobd=hoWkrUDC?RxUnFIm+b~2h<1U2z4e_Rq#4X)p_)KE z7HR-2oV{Kk4TjVK@CXe;QB(ShXT&kqmn*{25C%=fioPTq4f7`9y!C)I-=JughN5w2 zgTNMK5;y`CA_oojf_CVJsB-w2O+Mc3Q!s!Dnt8DLVLq7^0KH#W7fzQgnAUBA?%TFE zwm4(kePKuCio0=TtL@W%Vu-DM!myo|>3ooH$)+Jce#`qvyhvj%;RfES9wSWrl+2(Q zUrc^Vv%C(I?v~Y)|9Paw_Vdw6C-zHF@8J9GrQu?TSGER*S%4$5x$j79xPKN~Ig-(= z{Lps=Q1zL?tDzW7^LNQP)K)QL5iPedj%PIip39Lmek_i7j&rjg5MR43g07b9fre(X zJHV4vSqv-D+%+W_z6m>&-ZabXlqO?{-W+;IyyAE!^n&}I$o|ks$Lxr!ZiA+l^vYlV za$l=~=-POI)y5T%zHQFB(Gzbq{FNQ_Yc#c75@JO8XW-F_QSbGuXA4`flS;Q!l^eVRthz7d(EIdG*s_bpOHa2X8k-!8lWbVcE;l*|3)vXWQqq@o2jk z_My<`W>p(r1twUNTC`egHK1IYEt(i~%#MarUx|PWqfy$~4qCsTN7w#ANvVOCC6iKO|$r!SUhK zryNd-af&X!1k^;F7~~I%-OVH(qXdNwsDxA>Eg}@#ffJLA7#$Me3DTtK#0)1tO-jiM z0iPoj0U&E+`Me~=dOc_0<1bT1y8`FJ?&2T^5Q7H07S8}U@l)dxxxm<9FA7nyN<3iK zPTn&Gq-YqpV~2_qE7f5HJk`b;RX~)1pS{8=$vyB*ct|u39lz~io^PMRJWAXb%{z@P zSfvy9Ai`cSjwEyuEK*=xA~mnI#fX%{!jcIEUYI%Hfy20l>fe|*S_Wl`%LLS{%Rv+? zB7*bKrDR=~0{fsftwh!Yr*tEC4<)6)fL#bgB|y1;LRx4Sq_jdalv*0>thALI>hhVw zFmC#g?m@NtvwyfbzG$_G!css9>M*GJk_>Mcjy`lai+xJmxOMm1jOE&lL--i(L`Fxn zIcTx@{BY7WvAyu3Z*Zoy7r1zF{pxK-eCh1OY{;}iVLh(ZLk)tqC&lYK z%-c3WWCPPwIAn#diGVCF!(JdYsejc3Mz;3@fdXzl=P(!F1P{wV;wY%1SEL$=@#&qm~x~MGB$?-Kg9I>XlO?(k<>t zgV{H5ttO>?@WXegdvV%SSG_~^#rcKqOIKoPgZ3=B0Hh;HT?Xu!dvtg zETIIx`BeGL?t@4{4+Et>JD>fa|7sWTx=>?SRWaSHIooc(g{JVUvRMbr!YfYa(q`c+ zPTTbc2j1w0YiUiru6=f$(P=k4k1Y+5*Ef?l6cTl#)4Gav?z(39OGVLqi3wlYWOdDx zetmW+lbH<$P-jTOnXTHV#>vMgE2U~u6`AO-sglDkmr0QJGRcY-8P$9s$TmHi45*nO zM{1k2O2{<@1kuTvT5~lCXHDY(SK?on&krZTJ&#RvPphO8$Lxa&uT&1~ftR2IkqE{O zR~OC?f$|*lrGig0J*m`#@=e^CPXPT!r)=uPZ{NIi5q5^YGQi7eQ%RoA29|7`+G;C& zfl5l%%malIC)wQ{_zBA9UPl=ss&S@AkW!Bp^)W@mseNF=&Lk0__2Fg}*qk0uhdSNJ z;|?&D~c&=wGAtyQjBJq zfdLnChPGLAN=!O1e7){>R5^afc9uxjhuJEZoEqSTyTY)4Ri%>WMx3!7}NX$S=ysM9)2a{b zoDe#A_4B)v|NF9rhG=QRN}4$W`pLx^ij=M9tF223i8qrhGRl{nYh%%D2h}Q&LLQ=6 zvdP?w5$EuW{lHo8YTL|y=nyXpRfROaOykBJ(oU*hiFzQueO0WruS5y;Rbqg7TlorG zs2So)w(K=FVz%a@{n(Pq(elV=H>|C@Da@~%Wq1w-)eZ4ETbH;t_EsgjB3JurG@V}) zg4a!NN(V>k#t^?AJ+#veZQEMa_u6)FLklZz=HG$J z{`Z2P^+k4k4fN8@?)tF(Vck1_Q7c#5{l5qM$=8o{Rf)IJst3?=eN#PrQ$75?R1X#7 zkvk?f+pg{^^i8$#O|`L-Y9p{Q!@KdDisYM$Mk}VW+I@b^v7;j(Mq=o-(aB-BT`}*^@?!OU%&~a; zemmL^u1GF^5ei}0$_4IRDP&p3@$?XuHyzYw6_u=$GSla76e>FVGL0Zq0)*?;;?Oc0 z5!Y|d5Pf2GL_4N3LN8CK+E(dk(2IUd`-$2v0=AF7c%@W!hQK*?IaD~_*Mu25Iagc1 zi>HMHW3y5Mej~`>4pZ3^NbruS-g%3Yr_L<`TSqT|{zX=%7;L?e2(+oHFPSLU%%}0$ z^`izWnXRp@P%cQWSxs;{NY%*t$OVphsc-jodOOh;098kEfLfrdeeE&2D4wI;R#wMo zI!b5hmG-g_frJ6HEiqnO`?H5P`Cd=$^M+Ls%1dqYZ4nqWYB@3Cx?t+Rrk7i^OQ#S< z0YTh+E+&}b7T7SmWJbR@Ulfqu{30#3AcVX&l)VxPy}cd1R9kGOIARV_)Nm1vviIq} zTga>ON!^X5YAZQYN23Em-MkoW-|y}1^>#X4uW%G$I)bRPyLTUUSZ^1BqXOmNUYJ73 zTOB(p_LhU*FWW`H{vUeds~I^S73L-aOvgAXb(8gU!tBRIE(hf9E{+N3zN;PL@xBsJ zdsvVnW$sal{ukUP*%hkXF#Bi&Q^osn)IU#(qz^#+8)@&Xr!H574e!L880cSW{3n~V zkd(8dw)kj10C<1SAK*=($OXOV5c-VR^Z>$;yjRD`PivnmDg<$&Mx_qLI3Hv~1dB19 zF!%yb#G&o>`N7?<@^l8s8pl#RWCPU7mwfrWS)WJ%QCpnjV!b2ls!J8Buy(+L4f zC~m^hJB2)GG^mIA6wwA@yE6WdVD~|N{F7)n2a{6t2$u`cV;Bkzo3n-YHG&c-!3R_F z#2sK8wa4&aROV4UrkIW%#F_k!X#bl0mKPdpgyd1M&Yl69(qs^DOePSRxP?fo)WfGYP6Uh3YJ?yx)&W0yoA~~oR6TZ{_*7K+0n^SXJtW! zVKRLU{X&1xmWs4R7Qn?R@O3EbSszGk68wA%G48rvgNz7mnRzoXn zDwW$EV)O8Z#|xfX9;iMu3ZfJlr^VT|-~Vr%`@edTcTn7h|8Xpc#U+bWa%|xq$|q@v z03=JLcf~ewkTMI5fjDu z0s!gYZ+Wgk>mqa(shWmVUdKj{Lxd3)Z(_Y%7elQ|KcE+2&d1*q>=a~@!`^^RDAvQ2 zZg4g!RjO@MCiG6Hr>YS1J1*e3^;D<8{A3d8cR3$BQ<-woDFi=*U~a)gQxYX4jk1#8 zJ%91;_{HI0k51nGdhq<|%h%5iP9O=~JMjUg{k3^F@P9aSLE3tOz9iK`;6{3_$JMsGLvX&^fFXt^`ki(Ni1v zWttX;u%m`}xpA_q{1nl2jbPew0oCS^sA`7CK8FbQ8OY}=ALmApip5F|2UnAiI0SAA zN0LFW+Pyl(1dl2*pES4dsJK|%wKnVyUsyk^~NmyINSdJ z*?aT$wv8llc>bPGfp>PFl{_O+l5aEPWN3=AIgvySDcO_FFOLb4poka*H~?r_$@;s$ zb#ylxAV4%g%2%YFjU}>=>gww1y1Hua0rY03i*qW#rfHxdsV%=aiZ<2>;FQdiIou7hx#^OZ25t(X^E zh;dgz2MjoO=6EVP3tVJdM2;Pfrtp0+lDNqkrt*U`4)`BvAE3n$dv2ivYm2&DAG1ra zBb*^cm>-L&)PVN@y&9O%V>Sk)SoT(=GP1BaHbxUf_sdleW|g^nIwvlr7&+eRSZDDn9_%wf;{30cp@x7X#kQ22keTrJVFBi_31U17?T2l}W@9l_z3IXKcjFZ#&ZSE!~sl(Dl66{=)NCM`jCOM%n{C zwa4VQS00HSk`(KOk5ehpb%Mu5g$m=q(*~<>(o&)6 z)ee|G;kr@a8;^S4^akqz)z!9G>$!tINGg`#xxlXE#q@(QC!67u-p=i3t2{NUh zsN;{FaT!i0uJ1-uqgc`qLpdi&xDz^-(dN5j5enF4f$^Fc(l6p5?$wU<;8_NA^vghN zK|kQ4RJ2c=F}5Ju9%lnkhUR61P7;&&sPUxKb?W>l@0r4#^U=)tD0#=H@ID&OW$J!R z4R_~%EcQQ|I!G#)1X@*W76U@)tq@)P88-xXcjr8f^m>Mr=(#l>L$Bz&ydHGn=JYv( z&odoh4C430pMphbbmk-C5^*V#TyUG>Q-CajR2)JF1Bz_&v}`Ph=0?a}MfFzTf9OF; ze5Pu^>F{8Vf;JGgPG7v>zb-*Wr5$xAVIISoT*xzAcPCpsR7adQ*rCn!b$^QxrV$Y z0(|9(5D_N)u1&}o+f<45(ZhY~Y2%=Azwz)M=|~|; z<3ZAuI`9^E$25VPkgn9{G8xt#0pre+2Df9KTnx_B0-L}9>$OgWJUVYAzqzZA6p_CGz-uL$fZx|@uq2l{*pl?f~7sKBmS z=bY#h?FmwfAle1(ae;dYEs38lT?|W9N}Pf!7)Q=7um=Zd94moVl)I6;!0^Z`NW>L% z1otE#>+LPkVi!wfY^^DPCc|>ji}GHY#_j@R!;O+mQOcVO-vtbckbU{?g$oHG_K8&~ z`7Ep9q@Vf8*L;ZA8X`i1x1%7ya4D?Ho5osR#zBk7w=S<$_{bhqcvd2XB+fZH80M89li&jkbqq2`ITB%0FuV_4(- zrgUS4IV{~P!=)Ddf`f=i#Nvx5^0P%u>HzB9bYjP27xi7+qq9$!)q6X1gGFlVdGg)R z;kZrIN%3vo!jl(C)JWdSsEZBPhc^hTPU4Bm^03<5Q)M(vUbNsQJ6ug(G?x!lvt*r; zwoE7-Ar`1NxJ+A7QVH04I}RKY3g1#d9&inzaJl}}fvYTeSolx-y*(I(?mV`J z@;#`O5^SFfa9N_iY@jSX(E=`Bw7LS6jX2;+wRlOVXcfN%UfZKg5+qU6J&yP!yT%e? zkon3|_1Nky-G%t+br8OL`}Hw|d}dI{2$%`{4$?)?WKh$rpjiORn&E;vV7bC&DXU1o zQx~)kLZ2U#TtiY49t9G21P7tw+fsek2VLeY=gFXS@y_gcG!=E>*Svv&KHK@1Fnn_x zmvAy{<`OQ``}_2qHp-D@bQy*U5lOQE8Wl1so!PnJr@M0b0ztb{99tI!snIi7SgFKN z%qmo|4 zq2=>MJlTD^atBjqF(Gc^BkncU(pA@<=Ot#0#w20zrsxv(M^=$s;jIzUzjSt zWT2B9tSiVdZ}%_7`SbMto!@>I~eGnnz|{b zrsZbmwm#;Kh}!X1@NO&XgIJH-M!8zw4xbFIvZm6=^V2e!u;#nx1b5E~3P^CR=LFfb z9usLxB%OzZK(dvQQ#YTRrK^Jim^B?sFq=ZIaEpMm71J|1}`Faae$ER z4u$T#vkV(zIpA8#ibT`bzkEUnOMKO79VU+q2ky-E?9jX6VTbqkABymS2l$)vm|1U$ z;3!jtNZtcuNrUmKH4F)->K&d;1cFp=TbE=?Y_Qpt+qp@yke%hDnu!*RRJH19aE;g| zE2Tp`3Eu?53^%c~%BBv+iyKQ8gr+=8p%=@#%o%@~|-`$Ymrz*B36k9?Odd!h((qJa=Xx$;vR@|F%^>3IAEb+>Ry51y6XXR@R;Csk)l!ri9^UG344K- z?{JlEgHzTJf6H3h?+ugloS4H&cqU4w%}k3hQr%1=%w=Qd76uv9)) zV*2ufB*$viEKG!4IoEc%T*}DE1^}eRCBXtTuRdK74|d1y74RTrnJGjh4RL5bZC6l?h4ng%mi)zss4^=kUXp>k;{(C zHFHwf_#94$2Pu znmV2rprzUyZ{=HkTIDR)?U}K=iZ>z)K5>-Q!I#G_p zB%gur2p!bd<#1<$@vBP#_DU*R7519 zaVX81)uzZuiEU&FWCFP_^!PdGJ#3=G6QqtGA0<6cKR|2Gv$_~J%LHm8wn5>;7gXYn zTdou*r6#Eeq~$7Um4KTp(a9Rjsd9@SAYaDklWa;YvbRcu19K+v210xK&^>+KI_@66 z9h~<&trOF?QUtDISuI}%HH;nf_gu>OA<-bGtAe&IWBx|Ys(sP|;mGDGlH)6d(dL6i zp?+-1K&#_&LFV%P|h5B{lw)()lJPRg7E7WCvco5x|MvAk@PRl>sh)ReVe5 z9y?ye88nylv#l~E=bVE?y-aDBA{7fU=F$o;X?5#%QmT;Rzwy*1LA^q!Oi}BAGk511 zd_>`BsYXWCnx(fe>gFqz8m3pF4X={;B-zWdPGb8?+X-~$;;_6<=Ni4&tj<|Chf0+* zR+_!U;Am-MR69{x$8||QRgiLXgKfSHW&Nxv)wZ=XSBcTaYNJ%$TCMB)`;n@0N6y;JzN|GLv(ewUcv zx_#X3oSv7qCLI#~X`Of8b`Os`l{)m!I;WL7^gFbO!?(x1cI&ua*M8@ucU}$7SFPhC zKuB*;Yi7N7jmf!ZS(nq^ThQ=(rQ3Vf@16JBy<@Z1-P7|<|FmV;`sld#=54!odfqo3 zf6zHU@1DLKygl!pbb1%2x&a*1O%Y(w9`H}Yuq_~g;2cxsdv!_fR0On?w+;|JO8>svKn;S7ya(}Pi0;3zi$uV z|N79e+b>5u8k(x2{^+>%5=i*8^kh)O&Z+4pspc5P)aeh5+PB(28nruX9UdA`AvNuH zd#jLr*g0xl9G@rWf#H37-gLLTBXl% z>-6PC>!sNmM4vwN>6l@jdl)wz43tCyqyT3Dw&G>?)U3bhB5>d;wD7-_Y|5xdy9ERx zmtfX|B?#jQU}$79huy(hZ_usWuM&yKPL*gxb?ThHG^BXd1%&m=D>^xRRH;1?Z>1jR zKb@I&=>6C=YkJr^H*45AZ<%dY=ig^QN2X0dG&DQFNB!Q3QNvfgf!XZcBe)aJ+h(MJ zje%f~x+v*)L3%drg?Ci7dCUm|8eg2&0PDB~H?8bv)}wp+qglf$M~7sFUjI$2e`rPo zpcEaUEyAd2@83TW=Y*rvZJUyL(ybc9HQzK^g5e^dEu0TC%ISB``vCdTx#8H-u4B~n zyb4bNF{%r?CTN&({Eb5HtO6JjbZu*3^8Rf!ZL+P!EEI>2iTMHkr#)D@$K zAQQEJER*8&wq#o}Y0TI#YkmCBYswtxg*mvR=>9Q3-*>0zsc>m|(%3Gn2{e&-M*nKtO#M}|G#^!h&z&RS(R zwrt-kJDs9o?+njm$-$Rx`*5Dm%0&~=yh6)T5llAhcMaS1&W=n^IX12UtKkvvcZ}Ig zzk|1)QPV-E)i(qb?nOglxi~cj_2RS=pSw6UKJL)e^uS-7m1`lXrd3ZH$T{qsD!){O zHHVsZPcI71OM2VEn=Vir8jz%$q|oH1cZ0@gXdnrvymfD-F-n2m?*M)Zt;>2-wuqRu z1tmrqq(CNq-Fe$R1;PD9$j2rFNG;Z+H9FnSt8_SP^~rEqq07m|@p)I-?hMd%45&T) zNgQr7v~^EVh%{*k&DMR^ z`ssv0TJ04}?^ypu_wcaT=bhaM<1H5K5&Mua(v%sT3+90i3PVnp*2R$-S3!Z;kura8 zhJha)cg;5al6%ovtZ@z*-PyhnN-%I^7v4Af3~;(eM|iB%*gvX*@ob>b5~YwsO=b)G8g3 z;(*cqB=K!@b;$!Qjl12>@!_B%wV$?L15#S2|5 zRfUhYA-@oGeJcn>+5?#^h?8jHGiNytE(tTWJCvd%l}*a;OAb~~qGU3d&C&MLHFburk3owgC!HoKR7nyrnTo6<^H~M88-=am$ zy}dXHyr|(i@uU%iSM>OHFPx09uEagreZ)nKRGuL$R)i(bKB8-i8fqVN2Mau>;RRRQ zJYbCGlTTv|v%7865GNB_?Vto}s2{Mp%X()1N|f=&qt~(R@Zf617Fu!+1U60;VYt&l5Of#CTi##|k(u!{pzI--{ zh3z)ZMr&{r(QFdwZ6;BX+#v7?jkTlk&ba{*A!=YMtRvTR1~>i)&K#|77rt!Fo!Qns z?NE$BY%lJC-*Oj4@+){B=FtL%ljeFxTtnkiVp(@A8E2YS%~u)Oq(vy6yH#cW^;T)ls8mIi;G}$YZS)3094Cq082l(|KMS+5OX0i-SJRa zuEV)V>22qBWumkfpbUpddgqj25DTQH83pAVVW8nxsY8nl&qDvh1ga?J*wzeGftl@5 zmT-4$UG$GN{SB84E9T@~a{XA5*qOK=fLmblFnnyt`Ej~uTxE3|vw(sm=I=^%Uzfc^ zaiDutQz67$uGThX1MMEtD46f+Ita%g!NNJ4?qJf;@Fo(;e<&?;XkSqZz_A0Gj2Fp8 zG3=a+%f0f0P^BnS*i#9<->3=?SNKsV(~Sqdvr9&VB=0z@*g}Nf5}4ikn64yWaQFr7 zs7=!zdM-k*0T8F3lQLB|tz}BzF(@XhAFSmO3V4A4QJK3|!KxYwcJYIpM@%6Y2K3+~ zo%dxjh+Oy&8(cXJUaraq{mz{yg44xPJhjJ$!KRWdG5@{-Xzf z+CO-7aPSDe-!L4xKfrkH5I|XX99qo2rT+Z_esrAbzw1AAle1BBAd{2h9~PA@8wH*f z;GG30d2cW{ZeW&rnKCn$c1A29iVR;c=|7Wj$7!_1QEvR1u1%27e&%}LiS0yKO+YW- zLt6YbqJQ=-z2I{1{lU}5eq(>nb1wyT{u+UV4%|G;Dd=0tBmf{}62DuA3xMo{^-*vO zVkbhV{!VZCS4#EfMS45<4(64X7Z7`%`mI1Rxx179=#7j_M?;(2PZ#@7z( zvjP$mbbXwN%{l{iD&`Efli__eVM>P4pvxv}MHM-siV`Emo+A0X zEQLfBcQn61no!_|zh98amNf8|=OwH!Dy=e55hUw+>S6&^QSwxjX{0>=OqW3G*S1T( z0&<1t7CARwOn2-#D_2vP39?q|s=REK@0=SixJqY90

    xmnGdc1EJ6rYOlrfq^M6$ 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 U_vQEH_vilof1Zv7O8_)C0GQXu+W-In diff --git a/tests/registry/npm/@types/node/node-22.12.0.tgz b/tests/registry/npm/@types/node/node-22.12.0.tgz new file mode 100644 index 0000000000000000000000000000000000000000..bb1a33560fee00028dd52010946dfbb6c4b44af3 GIT binary patch literal 422084 zcmV(|K+(S+iwFP!000001MI!&avMjsAnf0cxbKiwcMJd-#KKJyWXerRl+A95)R0tb zIykyQ0!RQQ7OLP{NWn5AChjZDD|~+@Vjf|>@5j9{FLIyci*rt9R%TTe7H*Q=Vsu+% zRo2P<>`M?1MDv^5{b{vY54N`0H?3Ct!B!joZMC+Y}O+^%k0SkKx_W~~%G0ytobcO)KAxp+y%%Hyu9tp;S0poET_C2160ULzD(FJe|r#)92DmS5bfVMhbOeT3)*4Bo5P?7~aNVVbZ=#7X4!0ZyHHLEldYFc$UN z_a>g~1wO~+h!J2CvNRTT9CMvb!htu0e+5o)n)ZAz9@p8x1Ms~x5p@>BLtNiF%%>Sf zEEYZuuOCi55!1Z0QDQsjX$lLR$R&&6$;CLF*fa8IT*EX9ym&0|yFtj}5PSY0`UyON zPlloIhZiu-ei#fqm|fhVoje%}#(UwpzurrB=GSMiwpKI;j&fMNj4 z&2v+WU>I@2gT&)Ln}!kgo1d~gQ71p|vE#!RCvSI;_SpV0dwq2H_xM zug>1?pZt9I=7hc7Jv!PwIQa)Ve8F}P{=xpXfAGA{_Ws-JqrKx}c6fx~_Fuhzxxe?k z&h`(Uy?pb0|KKO~^vwx7I6Pr5_h0Rw>^)~EhuEnEx4(A`0AKALJ^Ok0;AHpd{>%N7 zf7B7!i~W-Wfc@g|i0!i1yGJMc&)&S;Jz}rl9KAj~-ebE5&)LD@!T!OEqy2-Q_FnBB zoHW?}0XsNkdw<_MIAO;>@4kEq-66c)Hzz+I9>G}Iv%}Z_INJZ|=M(nx;mhZHN5|~x z9(%dJ`}E}=b$9R&_Uz^E{;N8BzWZwTr#<}Y@Z{$`nkO`+k+Qcx@4;i}clUtpK0Dbz zJb)=ZJ3Kf!+I@CXXD5e8C;IcZ`^S5AwtKXH42$#P=2ofy6 zy-SBj`1hORJq?sS-`jn;fAG^We5|IcKKS;tVZ^UL`5&bJM|-=^U+py}gWKt2KKc-@ZV)ejy^k#77_)V!(z`IAQAJk(Z3qUZWpQn$M{h;m=NH zQ!yy~okT)3Cp=C>)Xb(qJ^txWY^^(RW8VtO?w}$<_%ceY?e28(-a>1HryBaOR zvq%iQB!-n0vAu}6AQzFBBqCtF89U8bGnngfKk}wY)}66Px?!!(PIvvDh?0;U_s1UZ z3E%m}hqG`p3qopt?#1lq6L!Lbk+U&}7T7cxMB;+I;%7Vx&z)_fjbO&1?Nbqa;1e%k zCt)hwaC-^7g2vCr-YERli@XVY)^N6sC%pgg5wv~I&%FWrYZ{D12Ns1roub- z20Ug@`56y*>};+Y$u{uaUOEziVE<^a|Jq>3V-Yw%6tiEj_0K#AM9g0CQIN)Q=x$7n z)^ww_XMe+Q(+g+waTu=SZ2uBZx8Ae^nd*r&J9@D-1|H2#&n_0Ezo>i;@BbAB_q(C_i9a2$((?f&XbJa>C+(1x}L z-kFzh_7nHdN~So%SJ3t~kNBkLMeNuMMq_8=sceE9b1Zs1PCOp4V-GIHga;)%IgQ(X zh<%)l!wHYsKm_dP(D!*TC^==+a3F%8;j_1%-w)xKos~4l2J{}~DNh0y?2K(EP7y@X_NTJ082w%q&c! zI1K_E$iDA!_LN7ncpP|VC8+3^3*me6LVw(2Ps7-a0QNrat-(t?VqTa;?CJmgH~xSB zkN6-iypnlNMIxe}&wrJT2s;Lx{VW0ydgBtD!3P8G3;q$>|J~~+VFW^U$!48ngDJen zs}c^xUys?dFd)%0jNJ2~c685!G-hvtK=l6O|LME$F1C4tXOa(7_{;mhUclYAyiYG{B<`L*pLj_$W5;6RjUqmX&t}fgjQ7Afd^Y~-kMM*1KaXP(CAX#q zUS0pY)oO2l)&E}iXKDQ}?SEs?NaEWV$2|G3y}q^8+AQqOE)v(TZl&;`9_>I*iF!gFsRV#Zl4642RE1Ju5zK|ho3&PC)6XI?M@cwTVMBaa73 z+<-s-5(~jj<1mf-Zl02aLHwuL^TS^Ae0{y~vFUp~bvQr7wQt$|=C=dU_d)3?$9Ioj z-(#Op#e~y=pZjbV6p#dp_+D_v!n4bUdi|H!3;Kecw;EfGNBSXhhwPmDslYYy zf@zwtWXu!LZ}-Qde+Hsx7_puJHEI&2$#|xKHl-exmPM{q6`^%l8k_~;MF5)OIOZeq zV~2r;I2f_t*j^NcQLQ7th-mWWoBUHch zAltMC+x2}Wpg(9Ag%>DECT077;VJztC~*6krnfiAdvp-1%AqY)Yda6={{8Ha>sLxqC}bz@*^MZr|2_Sch$qmdsH{5Y^q8lZAX3?4gsJ~6M_ zG=fu*%$T%?$>ot)!Pz5y`lCLmOZJ%EpeyvLK3=(3b;hsMtNM6_#Vu@Wb|d11_s>`o z0nQI6UJ|om1Vn)K#4wBmZL}gX&ha#xOvJtyBx?gN<~?7m1>$3}=6ius<)Wr=jT$wB za4ijDJ``&TDk>xkU~yo_36GK&!H*sGLeaU>$zIm7zc0(k7Ala3f+s1OGTA^(Bhkl| z0HIJ3ph!%@b7@~>!xUSeizr50v;pq5FL;ca=-3;Gh@~-FnEgaV0Z+Vhks)D3*psk- z)@5ViPeqiistHkX3hm9tdZSfm=k4`I`%$B1wJ}EhT>m!54{Q42o!^ahJuR0 z%v2sP0NQMV)*T5J%z&wZ=i4FPR&Uu33&e#Y;l_SeYm55Riw?h3YwXkI;sG9sB#nX? z55N2xX%(D{SOLN(lQd59$APxa0aoFZ+*XxL9YDs=7u(UF;Ik?`EX*5rEB|QmZDJ-X zemV?xD!VKQ*TSiudF5SMYn<#(yZAoBX4IYi+4!FRazQYfBFndxRDqLD;1^DoIA#1bukx!<+=zNZw zb7wc=iU&})ueR%Kz0NikjzsA~gqR*1Y`N-eB$8*?pN3qk=RuVGoPI*my&H`>8NsY; zIRVUua**%X<-64`)5FF?x=h=R_Cv>IQpZ1FJc{@Xy_^`Lx-lUNbS>g?O$RPQ$Xx8W zT#R9mu>-Y^N!;Mq({~HcFnS-s$l}a~>;=Oxnve???}e%4%N5N-$1r3u<$Xa{CSgR}W>W{&&ou_zK4;fe@p@+9A}l>#9&Tg#kslNvML&fG>$t|%xW;;E z0z$YOv~J&0?HiQ>a-*h7MbavHpJ^%9OIl<~g$fM2tRs{;I;KqIYFD5Z%_b}G0M}tg z^7u0xvJgEhZ%i(`2FABYe1@jbRDAdn7=6ps=Q< z26{LkH591=Lzf>^C2@IKh=$b-dXfol&;=;Lyn=QIzz1PQ0vTv_338of;}{rgXMz1J zDESNLdCFNJC+<-~D5&NnS`LHaEpuop=deT#Uj(CMTxact!^;q4ED{4mVXRjiLF;B2 zDUvgWf$LTzq5D+k?=DPqXlhVu9fu6z(yJz@A|l0oIvV3`^Sv1DGT9Z8S2GFAkV~dm zQL?zya=|UN*`)jszH&`pxh5Mjc$vpKF6QtEjX`NYDKIk$epx_%PZEMP~A`R7D z**$2GO|V{~IX`K&h7ScFl-Z+A6}|~5M{gF=nkF$ECdskjNpb<^b_)j~y33ioPc5V1 zyAFH7J>N1DltHfa!f;Yq89scq1au&K;6RR0s+B+hV-IpprB>)tx9hO1U2cI(x_pDC zn69;A@}Nz~u*CzGT$u6z2pVA=dp%#E?3$TbEECPK5UeNs@IrDhQ8E@08<0Q0)0oq0 zv>WSf>y1<)%agiOq0KRM&BoQvC_YSMj!Q=%&V_veEn|@)NUcVz(PC>5Sx6w&INqUU zJj4m9Gpac>c?TNhBXeSC<%&{*Q=PBNrf9b+SVHaBw_unoF-m6rI`_arf+9}PQ=yC2 zb2Ma0zaF-av_kxndgt5+XO1M)2UwsC^4)j%RUJMN+PSAzihuU4et?svzUoda>}e+* z(%71aRN1LPyvDI8FAs8G3QIBXBCOoi+Uah62_%n*JdV9l0Oa&K2>*ImevUE$t;Pvz z6taP-p5n|uhR$rK+hvu5P_Co)EsX8@K1Tbbqvf5_Z_q z+qbZ*A@?C}yW%DPy%ID0YY`#tFfUPUOW-$~Y+pu}i>co!S;yH_ghSR|-(WjCJFG&- zb8+w3G27WeoHTa;bbwe@G)4`Uh#37WZ+J8(q#cL^MUD&D7cN)^U{>T_?%yXfwc(^V2?xSzWVUy>MH?#B%Q9kd|Ncuc;{DmO-8^B(3GaEnm&`hB zgRL?8yu;qa!qu;4WlP`@lZNRg!VAc~A)>x_E{O5*k{RoX-bsLioA%&|B`&au``M+lV3P5P(2|gZzTz3Deo- z_ajZLg4pR;Un$lePyy4UK-)9!b-hO_r|e+Jez z2UmrqML=5Mm_a z)K5xvQSYCdGkMP@f-65w)RP72L`0x4X7|F2;GVjYGIL&k?D+%bkY%A6NFeCP;Fr-) zqu4ta{>+dEW#D6$6)#GCv827gan|)}eCdZh2$ScZ@w_{_U;fBL0!cjf88gsehtp{o zdx^+h==oE-G2%+D6k+c}o9&o(ckl$~o%|DqJbvANcxnB8`Pd15eQEIPR{_6qyQAL( z@a+BjX%r^m`}ZAMu*=09%X59L;EOtbx3Yv~!kHs$Ej@xOaZe678=rk9n+r7ctMFHF z=>Wt24%n>EB7j=h=Jq(Q=XXMgq?AU)=!#4T;}!-Uz{80rU87IChe*;JUR;rk&QhGCCKl{%AuzYQaQ@ZIXZEmv3q_Pz3PThkX|?jn89>_O*VujS^Dd#!)| zbuQz;r&Gvwxx?Bn!Wr>kgm2d$FIZoKQ&*qVSyw{-^C$Y{61QAI{PQRI+hupa~ z7QofcQl(v~vz+76KJBE^V`{a@d^e=BudYhO0Em5zzEDzTV@^YP@JAtK#*z8qn=i^$H>wBa7@)V(})NCR~%7f{Jn$Lcm~ zT@@95MMGZ#8p`eR?eo;vR_&P}?}0RMF9UUhsx`M(4Ha%HsMgvLi?LXY+ zRVdXwEu&hyJsh0Vu93aEtqs+ccEw?%zP8j4$8jZuWkS7S++~8klKrI&cP$C{uF=>M zcgS%rZWEIc3C>0MK%y1eMl%9zj;k~pSce{LP*=!2gFJwBK-5q*|K zoXGT)5>;7L#Da~gbnB4PxnCW=rAbp%CM&1}2OtQ8HG|M(mj+1~#A$U6y3=59bJ0IC ziI-Z0I$R*k^+=dTe9g|j>5Y@s0*b$@~Ng%^1op3epM$WHVP@6yIUL>hWJYtdfY2No9@&1VBe(#CBMd_xeq50sY1;jjMJ~ z6aZMT#nASPD0*zaxy%i;@F85e4y))Dt<>`^vOFW^S{ItZnmLR_bC-?HSvuwzJ;n_k zLOig^n+A#*$Ro%CvT8WMk>fE9Qm68WAkZfQuEzJxzDRfkWFms3!44t1;=;3h`xV^W zn7o*cLd1e0UcJV=eX5n63_ac=X2ZeB4%N-iM(*h~V z#n>n{XX$`x&KnOv7|XDk2~QxYqeSIdERT{mXSn=zEA3zgR^@snW~^{t=(aTfRbQ7s zH_Pu!6Yop0!7vOvgm`Z35 z9Iq;kO?f&0dpxeo&qY9h`1`Es8(~Gcm*83f5&$6!4K*Tx)GK7cmcMO=M`^# zC0?{IgkMOhA#@6OOoEE&ssLLjw%~E`5a-rRL{a(Cnj?h&U15C1lZ8WxJdNDacg3e& znXniqw49+U?q5Fc_zKHr%lNc%w<_+H?FG?wCyI>HAZFc05*{NZ>)Hval_aE6`Q#K6 z5v75_V=HU38XvBH@llRmFMC|1Jd~HG%J%ZaRCQp|9+@_dQrrXb z^kimy#I~5p1qu&lpjGlFJFZzWwV~oWk(ZGwv!a6SkGio)G@M{%oE}Ju20kP;Re^TM z#!c+B*#I$t$dQXO?t+d>ZX>B6X2}?S!PRo;Z@}fBocn3hU9yLkAL!03hvBvOae>BH1#1JO%IqkI}fp!Qx-jZ}notruPtC)ENgTR?Q!E{EdE+%*fG9OLAd z=!F`t+D#B9C$gtp?z+5mbK=+uFE%zyo?$ARWX?k%UfRp6`xVe3EDvcg@!(@#6vAdP zNOOZw5S}DCAMQgTe?|_hUEIhXktOolbj;e=I&&{+mc0S;*XV<7Ds`!z0_%xD484Sf z=OVJ+(t0RQtoFi=;*I~{i z7P+9j@?ylg8D09=7g+13!;bUBB7e4qXd#57Z*1|Lqt6Di{*NRLdB4Z~BsYE56Mddq z_5ukirhZn~=O+E~=jJ@Uh_o8#M{V9}v=--<)vc48dt=?hS-fS-u?WvI%}zfIh9o)S ztk$Lxa8N;*Am>wO9C=4KA#*VbSN2bl>(KK<$TUc-_v-fB<-iG&t#bJauWlyZmEIWI zAH}v6=T7Y+i?N+y4n97Rmsu95(P$E2rZF%e=2eI+bnICe9Fa=WA4^MQhNzLfi-bCc zkmg!5>6%5cHheH3p}!wakc1);Q7NbttByvjDaSBpoQw3CpVa{ZQ;3$BsdYM4Fu|)d)`*xcsi0zrjz@D7oSm2sXmv_KFVzEeGyOI0 zt7b~NHbNjQV987h3(!8}0hOuUbdcm7t6r_Ex}qj#DXV%>cs;n_fyHt)8jZ>ye@padSK1K5$aCC_QSl?a?@SGd;z%8? zaCO^ZZ?Q{Ep?hUk{ljlw(`cMG9#`Iu!*CkUQ);1T1n99-2q1M|i4G&6<%eUn*mrZq zZi*9K0_aWiqcS75PSIM()@me21p?L$Qs3`NRUEJa#8c+o%|Oenba0A}XBreLqyT(D z+>jD(mS8-ydV}K^RsyvsrPL!R-;XTIr8lHw2&|jsjW-PwFrGuIcX6SLi=v9r{3MBm zKfGgGg6ba@b-4th>Wf8L0gD2<{F04Iu19N5ZxvE9-*}%A?!1-J%D!Su+;w~3%O#%4 zfv1WZEDk4vMLZa2%NU&?OMLZ3Qg9opX6drvvlsAHQKu>Lz6)@5m}|W+Yt>SXL)Mp^ zbV+Zy)df4y+&*q%nX?Jy0K*TY2{uOTZXulS=V0$g59VWUHGexhWj+TbqQKPm-35R1 zg8c>er2BW5$FrdSB0#T-3D_^gsE(*rzwpdDD0Ne=G-1j@g{GDOnUbt4U0F-@l!PE< zPkoVyhBl<;iwmGrN2Y>M-+JH?_yM(d^RjunC!u87OtC7foy>y%I0}O>js00&3)|FD ztc&DI+ZWd(VBOa=EX@F`gHSB(d*7k;)Bxq|uF*9Q=+N&U{C)T3{`2=odna#>4&MKL z_vM?tOi~2w{~<>45CuaY%JC#?=j-c@k4--H$f-DPjFXA~ClN*Oy#Qsw_tgJ;JaSg% zRW;jya;SldH#SHgrC>vWJU;WVxJSvZJ(VU}64_=!p9NHY8Wibpn52FW&kd|%Pe5v; zIP*I5XJ&aNl1u+drT8Vn7*-5ksLu~hu#Uu{IE8D)AuP9{1)*lHZ@)YXGqOtNcKc?D1}V zT5`@M7EzGqcrVCnj*C7gt2&yvqc5>~&wLhJogSsepnaC7=LgAgKY`j^`Db&L8LBZT zHJ&(BD8)ky?)|He!TP>L>0-56Tra46^nXZEf|&3-5+|hQ?1+$3?P@}WrNDB!Qj`l7 z^9Nu;{t~1Nr)ZI%{;E=j(-@sC$THSwXykiI;tLzWIxNz19o12hMrnM6HfeGKx@F5W zb$BbL=|8v>b=$Vk8y0y@&HUXZxG;HV`##+z2Yp@3=k408?cZ;kqVTjUyN;8#pzSU!!M$UoFk>oFU6@zm!tIFjCQh>92ARcEALS`En!4~~U= zR%hWb5olHj3Kio`fG3nM#W{&p{SH56U=$U(Tu@2mDnw@vvfGo&Z(4j<-8-0r3#scG z1gEE`kO;WWHr~Cfv&}l&dRJ%qVP&JDA1|zhu^{I=^trZd;&-5x?4=h7t;n;#$w6T3 zwD6?(EGHZ5B=B}Y790@#Y~-G<;jfhqS0?#)c@XZtwhGUdjBGjy*+B4q;+=z+7iok1 zFpBF;#ffzf4&OgJe0g|8o{tBI&-dOx-#^}c`f`t+A9tAu&b=rMkcOV~$OAijEUh{^ zk&4-^vrpwuf3)}dCE+sEafJcBXK^~kqYBM1u{QV3p5uBJbetrX-oHB%$uofQTuhTO z=wSz8A4xu+7p|hI$QCFu>PSu=8RTTW&dwjf6DL^#6KXsKXHI#u47Cbqq=37~@mo9U z9@)L+y>#9^RZzfFYWbs zK^y6;HwV7`>Pc=PKNUW_fvVK%hp?~O7Gt`_rfT_hYdg<&@dLdj`itChIs15C_^Ox* zxA*_>~tAxkY)RT40c`sdUKwD`Qk?xq?6})u+ZagFTa)R1w35}na&MH=AOI|HXF91cBpz! zHj~VW1Nb+;;~!XvCfZBhkHhdRZVVbpe8YXTTCMHPP4-Qz)qb$mhJRb_?QQ(G)!N$H z*xq8_v^O7YZnrkJ+FRS-z}w9&_D$=C$Km`*3_d~A9GF3 z-_0MCN$<0_$eM(~2)Jl3?uTgvngN+=LJQo+LFuyH*ZU3l7SkEQUouD+Y_fgKcQFZL z%wz;E6##}jc4a!U&bJJ^2Gi;;z4y1hs}C zHD|Fj5Xw)~Af{2+7jfJeiDVa8QgI~WFpc^m2Cl`b)Ut3)3Kot={xK2>vbrKta3N7r zHYR+>^h>!sltz`%m9h8|kx7>=bO_mfy^s1M07o;Fjv*OL+^_vao6Y+$E+O--stu8H zp&^*+er+*OKL%M)iWc|TUqHZ$JY=bTd=Lx4PH6<$5{|rNoc0?1a3WU||7rI8u-Bw@ z^u3;inLfm|Z-J}M<8q^o!sS}iVoAA%geyLZehTyvPu~6@FX38Kv%Vc#i!jU@sCK}^ zhQ4U{;i#JL27-1NRbN|Uy)aDTB;r%^%Y+;&c37p6bv=w5;Zy`wcvWW=D4qrmmUT89 zm{!{Rl7n8@`!-u+2(YF;)Fxa*Lew*YBe?%ObBL1pKnu{j6fxm*shZX;SmI4kbryt) zo-9veN)=zd7<>IOrWXLLLB7)6B=SZh5oN$t3PtzMO36V)fOjB%C~5RDUg;PgRUs{D zkYB83lO5rt$gr^gTp>DwgX2|?z=94ig!C&j{B$gUDw2=VH%gu^TZyyx% zJy)*MOy=eq8)1iP1T|!hFCt>1A(WeCAXlE@`~xaY-U^{Z3LEmN8i@qbcK6|B;lRdS zIA~HOu15quHqsB2(zXWdRC)0k2O5y97mQXWQ#4UU769s+hPtMpX6vK$4i6h`rCYeq z{vzGzPBcm0hhS7XQ~fl;#1+|C6=j4H%-~_BX$0o5g>XJfX^1Y7s%KJOWD$FXo$0V3 zo%Doc*A0ZLsHTxsUE&S6);1v37H|ilbYvJnZL5-FDzGY175U$3;3)s3fl}g#0Wu;g z@{>I)1HO)~g_$ z|H`K;F+&ng*L?6JD{h#P*7d&joD7(lOp}=!FF7r%EERfjB9vYP6<&sRloPzJp!L!O zinUusHCQBMhIx z&`;yp1X8W{BmB+!^fLS7GF!r0Lj<7MFLEF`Hq2(hBJm5(DSuPSCZPrf1}UD14j?tS zdAhy|d>o79#G8mPO?1q6H8<5r#0?P)s((E`JZO+Y(;LpJbGxmXOL$pl?N-ZVMiiH` z(K4TBx6(8_XLf=IZW^vOqKJVD#M~s}bQR$W;vJR*MFCrikY|(bNGebu=QqM-TeFl( z0!rHmxnt5IC{(!l#A#kEtps7S%5 zmeBDrnn_^6@fW$|i@&m#3%}3$b^?KmdVyt%iu^rdyIga)X@pV-j{bEs9ju}*a5)X3 z4nXXYc}W8y2Fi6J5*S7~V1pFxd;Yxzok~v4&E0ncT<5P5I zk#p2rnZ?mM3VIR@Q{8%rhpHyH6EZLlLgq5mrxI35KS^&mQyOhMk1_0Hj|yfuKK?*H zjrcm|-oR>;yI;-&nqqG^Vnh_uUHVFzW}ex*MX)@6ET16b=pi~H9 z8W@A@RuuF-1-#NFl!3b= zUgQzU*~kN~GJ~PKbkVmr2#xl@Q0kz66zOCp0M3FioVs^NiGCfVU!^2KpVV2Bp z+W zgK7eE_-EJD7d%L(nn}?bOF`_o%&{EMXGj9%+`1XXGC3SsPYISw!BTHv~M{*mOi2j%dUOb_MzzSK_S%$6ZOrt9-YG{PwS0HYvG-lOdW zyU5*MDNL)$EHI@JkVbu#^&jPbZn8k z*2!pKUN*Nhd52S4ic-eGRx-GRQow*DftnJkLk!o^Lz!m2Q9OfO?~ zre#AD;DiSVtX5}f;EOo6_)n-as!g@%CIN*|&$Ap!Ca72hv4?bc_w_z}>F%A3pI*tX z47ne>c~a@w_zDLs!T#6*e-t3T#r-JoIf&^IBX+IB*Okn)mX44?lND@a0z5J4iNOGM zjTWDi`6%gfWgf*IL}b?zJobR((%Y7S=mah^R|EBc=0^&@Zwg z68ZTNvr4K57tAb|J;uvn<)?E`Txch{97uAbv%t7H2HVJW1s5g-5d&*1?LQ24B6yJG zHmxD?8_X6lngIgnOdbrD84A zMikDIUoQ2Dwcm{>4fbi*j={64It=QFId-E_9U`Q7G>Tn&gz+xM_$0SsBw}~>XJF!@ z$w#|anc9&3=LLn4?bx8@b9axt%)n&#rq=7m0!p;#DG4$apqi^uq~CQ%6`>%Ygz6B;v#% z^x-^AV863Lm>7Z}&A$oo|4gk*8ZJ7q((e|PzYscU=+;9taqOzZs2LlrPOHu$GL$t2 z<%bhGV<4&p`fA+251OX?_??pMwLz_z8Z|Tb$IKT)#ouVvgOYxKdPYavR$P;kEI;DF zo}hhHr21)>MW!b}moI_8EEaZw6~}Z9cWGZ@> zWNmOO?jgkQZRDW08(5`KHKlJ`_Z7@{9g8rO-Kgwafm zGUh{(9}Mk9a1Qp`n8Aqv+X{RSY|zB}l^e=g&@4lCo3MB8g{c+;O<(2tIu(`MI|V(p zYkF|;QqRZ2y9kr{A#Ael3WtFwH)i|K5uIWHH$eaSzT4T!^p5ODfYxD^waR6uTW8Q=<{_9HAk>=j2FKzT zw!>Pw6|7`qIsfD0n4>hPBFOK*cQ|e`V=2HhJW49I!!^{qp74&#*Xnub1ztSPb)9)T+s`j8e`c2}^TXD|R$=pT6-OeeR^Yczvx%_- z<1kJ-(B9~L`Ih8DA0%QvedoUmHGV=KKg+UxiJb$`Kogx{`$#YYL!0stf zFcWT8N&t_xE<2CDmdI-+X4!*Ge{I(NHUTzpj) zq*8$KF&!ph-2&i79Pnv84wHP{McD;aEG~n*vEEjY^9pNvI*)8RI#i^Sx|I=Q>M*p| zH*!l_ve@$`i6|@*Q=j*(G!VAl7i3!EvI@G@Orxn{$fjvD4Py~gC2q;cEuEZ>P}z$x z%;zNkQ*nFeO{^?!9fKGGh#b=8h{j&r$OB(yyB-?}tul6{&>W+#>0%dzWGogj5e@W!i_=~VqCg;Nj-@nE!g|RmvJ0k| zMTf~-(eW{Cca2i>6<&j3RegDx6rGFJN*y~WhF`-YkDo)O32b$A8*j%8cl7G4L0+QaV>?cOayMQ zF^Vgo4zu^lVnkGa2q%tkGo$m-h11D)u9LT!!a@xTH^>^){!nWM(*%m2$SlQ{LPilO z3MTQrUvWe8Oisz!Tl&J~87GB#jcdK~dS=U(A&m|@S<0L0D7AUU*eoKY*f#FuG`%D) z&V=FsRq66D()F$=!4O8S8Jl25m$=l}HXs8Cn9_n-nNCf+t!0d7ekb!`82L`M<*o~a zft;mnCF9(I=gyzAeZGVjxkQrEI?EdlxiaMWO2W{wIJ|#G_2Jb8o=kbBX_gpX7vR(9 zJYIlm_f}=gWX4X|D~Qzg1|7Dp1GK4463vQrw_TSB!PLtN_smr-^S`1(KAEjc52e_L`bEsMS8r00* zvJN}R1<9ADaWCZml}Xy~laqv%A^7*6u>FRADCu$vA?XeI&y8n*pPT=Eb91wp|NTMh zYyS7^|16XLJ%6L<45)h~(=cQ>FpD~UiVdG-E_S)PBF!d)yx+!|LfV^i9*f6D6${_T z8pTvCo1FtM2sFqBYci&US$2JJHKE);ATv;xNH)0_s5D5#gnf#W$gE_R!@v?%kt0H! zMC_Q#pXh9RUZ7@F@{tJoA?oV&FEaJ2kpY1{mm!*7%qnRzd{`*}8$cE(tXjsb^2uxs zwfkLK{RW`7DtYOj)^(TfFug36%F7S4Y5g6D3-~&V;!qHN?8yDylMia@!4JDp#Ao!o zQC)botqF(hQ|$dJE?L-5L=rE%A>OaRucZOHWz(m~D9K)md$Qy*B7kbPYOIP39GqXP z$(sP2dLX!FiFNgU6-Kg`8(cm2!R7$@GFzA>*Azb^1&v~$0l(mpO3eZqQ}oj{rCkfTutM!B~#9_Qg0D{J(B+5B{j7|VRN%1X;I z!Fn4Y2>(&`C|Lh7Vq_fJ4QvBFIIXkZED?vpVJwoVLj{AeD_u+2o zfUJlIBf+|@F8j~_@jqF2eQT>*SOFXg$UG73in1n91{3^T*S=NtOJOmG;HDp-d)=Zv z$;sdJPQ~+*Cz&R9F+z5cJX^ z+hOJbIBk90Uazy(#|K;R-|cPVzxd?Ax>Y+=FTjGC><{%8Qm%$B?n?K+uVEov6&EX` zP3laUM$6>$GgNn?32!$1U(w zCsbWrxb;t=^$Xa*TH*W`t^>hBeSf!5_u1MfG?(ciQ~e(M0Os6<`8}}TB+h+uRizg zlDkCnPFWjpu5z6t1^g!^bY7aJ=2f;;>E$)%5tv{jEup&L0%FKu8*pW!1Z3k#;GWMy z;G!1}D@e+PhYahkI=4oye90%pDy-_~l!{I?lJIrpO)wACyXx2rk`C2(4Mz8BN@On< z%Vb8W2IHqxvM;-HcYWp1+8STwzJ)_DaC(WD#GRGymSZAEI-tVh_;iIb8RiPgn{Wsh z0XVZjCICu6wZAQq!SDL3EFMT@jD%1t@H!X?pjV4Xj`VYYk1(TY0BoO_#F*K`lfj=! zm~j84WJbK0wPb!wn!&Fk3fBnB8so}pGA%KLLJ#&e)1lP;lnTFTW}&za1#UD@OVXP$ zJ{ZXJ;zg1$EF{XV;T47k_fbfT8cPEivkdfjB%+2~0uguUQxYZGWFJnpP#MA$k|}ziyQ;U=_KMxM8dVdi^i_``*z0QlkTnED)R5T z^?IT8=A70Wh1L(tS{v)mc5qw`x!vDmzt&$H@~=hfXvSn19Tdlq#X+*o^<`IXH=7+{ zpXw=$yN=_<|8Bgivw8i_8!vP)cc4GW1J-I~|7$cFPZj}{Yq#1WEFr;l?X|cI#=F&c z&}g?ys2JXmm-3nz!W;Ya7YK$h7{W_~JfN0DkrIcFNhTOEPU{K$UV@u!x+9Sk#sCetRy5*?2_igCe2qumvo!b_O=Wogn6~M zam3Zr7AO>k!{N}OQgA3JY(Y0|Z`WD7&f3Lq)Asgh`<)S^Zi6*$i@q#yI|`Q~*Z8#c zPBz@yTGX^%-n4ktN+Z9R#kN6aOHlZI%2WZD(`;raSa}A2}eyBNy3_jE$9Q732z``C{OGB-yxCXWhM{qxXkz zPTn8Bcz?8e@Y7y5b534{-__f!>#`89nHjYT`)x-zWg$&~YXDpo{fBVEwNvjwf;-oxpo`2?x(-Uy`LVA2J4Sz zy`TQ;PNmK&Jsykg&0E^jhirR`ZTIniL$=;x4<5iT57zO?<`s5Xho0tL1!M^6MDRF` zc+a1)*bgt%J*WLf#uM{+moS=8hgSq~s&hysRLu}_jY<7{fva;YRD#5f>YHF92dSYm z5{aWS6ZcnpDa-Q+J~nlk=g4xcCh(*Mg|SUMaB~Ogf6UJX)mO>Rw4qz?E))b8YWp>& zMPO5^$g-)jFc2Z{mSm*I%zuEd|)#$dJe&%y6pPio zgxSs1FdP#?b0+YEi?ug*PDCW0bm)ezPAphe?*T08Igh~8ND&a;Vh?+4{UO^JvQ|6e z7`Iw%V?9qj@_lIPe3RoX<6y7P(B2FVcHJg@%%oE(ph})0g}|YbG4g5TAtL@(=NnWv z$2cyP0upnpa?D%^Y8{?rC2%-Fe^u_sTSuy&VKhkh7Fh8oG3`@qXmPh5lrXTwq}o*VN+4m0Cy%^Lh7!BX8(?ga@whtSrz*`|!mCQV%8DKdH^7BC*c@Za z?o`Ec`^*a4Ew$Nc-lKpbvvIZlIk+8z)OKwar$9Z@{@69O75E-ZgEWsim_FzwRHjHO zGU1E%gKe_Ec~41i;Cp>#NY%DD8*%Hqf^J_f;1CC&Ap`Q0hhQpl*|1X(A%Q#>(HJ;J zuxrB>;ql`)55bz%hlW`uZiG{Mf!z_hdyFllJ z?@c^uXs5Fz69+(cIs5`EN3wM4aOQ?-7~__%WBR63Zl*=Y;OFoHC`?@^MB*`2{KddY zHW25+2S-4vvnvM|2|UA`Pyp+X)8Nd(;iyYU`>oj+nSL}85zbsNK2fm`Q1lAz+t3>n z!pof83iKy)r~vEt8i03gSNRD)_QQ)RIlC2!8(Nj7h)b|)^_Xgkp94|qc}uv}-J&`B zKyJgC5L3n@jH~5rC@#$XK*Zj0^5LJAd{a9E(TvI!iGnQ4kDC!&vMAxU&yKUoFW*WfF;B* z+4Zw<#6jMmXZR*4eu z!btLM%iPeVcN@rK zR2?#`c6H-W=}knGch&G_ARlpc#Ssp=e$VgcOHwYO46lL^meSS0%1%8oc#2@kC)xmE z)veLd08U%)zW;u%3xICgNJ0ugwe!BRyo#vra*|x2b6OU5ZyDG!O%bZV$0gjTBt021?Xv(iJ8Wsz(Yt2i%5(%Q=SMZ z6>5a1zUs;1>b3_!=Gq3&lZ#Mi2nIRa=hH934cIbi;z)OopY886?oY?OC!k6kKSO_E z;sQ``rjYI$$(*)%C^y!OydUJveBn}X2FCBJS#3?>exrX$_$O{68N&ol77Mm=O zKALOWb+*>7t;AnC-dFd2NxgIK3t24K?4ng?TeU`>Us`R1>nn|L^#N{PXMkHP4RH1G zwVmUe$8c^m%56JeKKH2Ry&MBs5^hT9`tpyJKg`Vkb>oS@-qiy^An9Qz|zwdWKv@?FQN`E>na7Hy<~? zZ8q5{Zl^#eKY(K4kaLzB9wyg6AJ@bZxO3$J!bF; z{>m=dkL=SW>qu%?Rhi3b4QTUNcJTt#=&N-BpDgME+C2XDTa+j78#ZI3%10V28_+Zo zF(6^ihTcapP^MkVA4(-;q>1?zn%nMUghAs&%ywVzgV}$I4 za}hz(SLL99P7$>_gQuv31s5`uJyeo>dF!<6GL4`TOOVQE!(P68Os(aaS-Oe2JQ1{K zr|mjhud|JJb`P8Rls~H3)q0Tsdxr^_unGVrT9Sa^=3=#PDI zdeEi;kazLKfT!8A>}Y8PViRz2swH^?15Kty!~R)>pZt}tF8@v#C4T-Ico zD7Ok@NLZyqC9ud^gBwl4`(q%c7^7gNTD1aFH!02Z!$x~km%LT7BmzY4h<-~#noky5 zEyY8bCE6%-`X(7Ztm0Qn7-YX$i5h<^Mt{~itOq_dJh;)tM;+srx%k_9@waYr@pnP( zciq*OUroFeVG&Io33=4b%F|~41e4d#*d;`QU~13_q7*7k`RBT5KplF(5)>ds){LDkAm3`1L=+;gV8lqN(6(ysw6w$`Ilt58uY;S zH0(_LfU-vN$|mYupw}K`((g*0Is`IM;FDy;v2g&l$V8x^BL!*YkStgN zUf4+%AIDyV886+*jn+`57o?uLo`;yHO}}sKBDgAu3vy4$7Tn@O{`24dccoUB8OIU7@iZQF)*q#~&$GtQPS+)D0|MtJTH7vWUj+S0bltR6L zy*XY(ilZb?S^9aPprX{({jsZ;UQKzBx87x>;z6TbpbxTe^zP!z-N=0@FA8~RsWqL+O1Q6jyGDT>>v=}iAOI@3emjpOpd$Vz%o&3 zKGe_l&^6TFr76fWf}^eQ_Nz+=a*jj)9C`L`1sLKE+zm`h*l08=U8<@YhkZ|ag8N}l zDZ^MKMqW&Hbx_7qKsh+Tgpsal)_rsIvO%88q=0#I^fL1sGx(3~#slM26|0J5tjGY4 zS#iK!_U7oNlAUz9d&oex+K}9bD5Ay6K7cYeGA(Ea^_RsGtrAA2gDGr*Yo1pBhI6JL z_70~c>Rab3Gl|@1hXLvxg-2OpD|qy$94=Lbu4IKG*DKuy1weo+3#^HLUWf9|AXpP6 zf>;e&QhCLvJhCew>UwEN0+X!p-_+*`IR7&lEDvzkgerNQrBOf{r!n{5;Y%A=hjFE( zT(}(Lj~#Z;nCLxVNT|zu<(1FIw4zEevW9LelEH-ssQ*EZU^W#pt4we%tQx{F$yfWY z_Si%WJWkA;bp1fao{cHC05beZZdt}GD(yML;0UV-4+Qg3(1cxXFq<}fXhwhMPTghx zknOTly1OeXQ+HqQH{rV);8{M6F%e+QyvZa*`ch{Rzc3V8GI|X#7o<%f$6el!!dTPi zN$Mxw6cnUrg20S(d=MA0!4_ZxkVZBeZJnjaz8a)<#Z4@|56H@3PAzo0))}=BlX-zu z(3@Y(A3<&>bOtRGCC@!`=5e!!a|5Fwq@T|qnj3|k)6+)khR%kYSunFhD{J1(FH~-o zR;XJkr0VR`bDr?Od*b4f_)wjcUIIlW9=Xb*ZZ3b}Dlp;-x!;l7MMOp6v!kb6Q5heS z{#JjLh1->l{n$iyvD7HWp*f@^ffzu`%KqUy;2QZq1q zt#msx*=HJs6EBv*p2O4!RdB4U%bglM--1!aEC7)|MpHY9`hD{b<^oq%Jo!d8Yp9a` znpU91Q`B)AyTC*=5D8$8LGp5pj7n+nE{8VcUBTG&uIe)5D4&#;%Ppy#*CTT&X2tcx zUiGvx7QP==tUPu1nK{%3m};w4{L59%&hkLPMwlP&FioZ@2pZXFt6Md8%G#|>2*?4| zdh4P3PrJ?DnPBG@e9ZPl4l&yeV`&y6C8N-?g`lh>g;g389s6$Wi?zUbx~Seq=95Uc zUk38{g|fcOoWQJ<6ps=+*B$zqH5_fhy9JBP5(8A)j#NN-QlU%(*^)RHf3ZJx-DV#o z?|MD-k~o5b)%_MEOu}t3;ZhX|8pGA^Kh)1OkD5%)y~J#A9c|^i^bVInw#J-tQzD1K z$acGT3o`lL!G2)C1yRyQ0O#b^ZR97 zb@5{#5|3!c0`%VMSPVU1G+0*_f9rPGb5M#0Ai7%}0EAZ(z>hg4u#07f;a-Jhhwo}S ztpoD{k};DH=eS z%Lu}ph7eX_3}Iyk5#}6JQ@iYv`XNIE=LPc*Gd7*USEy4c&kc|bOHdxkKW{HRd$nG{N|2x`z zB<<4%pN`V>|3;es-?W|OH!`wRx$kkDv3^tgO(n)uzod~5zmw^unrVbzlPXpU(|_Z8zGjd;)&k;a_(f_CBC5Z>>;&-HZTFET!{(xyxK84V z-CUuE`Dgu6qpZ|~_HfvB96CCiV2l`x{@MKK7-RhEb3^La5cS)25Zz&b1Xhu-fFBW8lwg*PD0WEWrWCsmJ#aYc1zyR5M^nG zwPOt|@1e?QE8Sf!nH1o9lTEU$-HTtl@*MdfciE@pT~ArYTewG}~amf>hO`ZNN}UGOEOw`%8OAlmC2jxrn0kSO|~)n4By{eVY6#*A8X3zH$5 zgo{T}1D0N~%yRMOGs~ws_4!7NZM50OI@{QIQqP{sM{HyBiD`kCE(7wV;2cv`{xCHd zeMv%bN6KAbbX{CAWF$rJUF=D6f|S>^G*_6lANlRD*F~k+F5;H*)Q0~g+OoG0B^YP4 zN@CG2gDl{bzN(AzOr%`t-Nl%h7Z^etc}%E0R7Oo_sWr)wv?QcxMar;^-4DFNL80u1 zBz1@&Oh;ozHU=4;Cu965)>T@Fz$5~uNXq3c=U7s5Nrq82vNXT&rH6Dxi8Y1?JJs4D z&9M6Pvy*^)jO+T=;(SQ-u`dFdWsd?!%f*#CTdlf9_s^ev5lE>51Q#nko^p+EVa2@K z<$SS2i59j1vh3=>@-D7ATe?2FMl5_TSBdxfgG!wh>&q@)5ft3aMZv(0{JNlz&7x(I ztHK~d(~5f3MNF}Da#L4SBZwsmJ029Td3@$gS&y9Xv>%LyUB=1g3qEF9VvKr^ulPrA zl1@sI3#+O)X&E`L?k^Q@HWS@xsNF(VnR1T*#ElmX#8b-V=NGC3o!CT;4xr7t&#&a< zVyxXzX!f0@>O)-}s&56*t=@}+oIMv5K}JLbjehbR7id`KShA3s6_Yhe=0sMtPeSRu zLK-at0 zl_{lSow!RAe1DayygLh-T*_WV3 z%qOsEeQZO@m38s#-Z%dU%2Cvv<~9>oItuCwZynAM4vmX&X@OqY}~NahW~M-6nk z+u7M+6`5m+{a6ITtmT&dbzJT6U6EL?w5~AQ<%&(VS!ijW z&T3`}Ja*6g4FSdMn zG;jzjp)`gAM+K#4+F}9#zzJobOe?&ffT5?5U=tvsD7dJ;$AY}sW}EA5(=;EeM{IM` ze5xK@!J9U28TfeDpv^f9U*>*~+FU;uwm%#?bEybC>o_l!rQbb?Wq zGS`A~GK4CcNzUSo60I^QVsgt^dzYAqUY0Tt&=w-;{6fLR&yPk_+R!@Nth22;+pe<* zXhwNdDzP|_%c=DxrV^Dvi%?d&^*E+Ss9xE;No;};w-*9k4Xv!J6Z}tOgG9yBEwV7HuD_|N_jY$R_Z3%H?4m%rml2Z zQu9=}lt~5~D~gzIB=f=V1%n;AVy2#JiH;yV-M}3SG+&u+F5A75St-YZ)u*JlxS+RN z)WvF(ar@g8WmsG_%LS*T&9SZJD`~Z7M&%dU7z?|wRXL>9T!OG_UQBM@vT8A;`7(5h zGUSdP8b_(l1muNLDHY{Y8J4GDPz5ZRGhitjT3K~5k=%Y^F_F|%A|^v1fL>6|O2m1d zbqi}f%ZjB0G_D&tUR4f!op-(t*(k>70t2+1pB0_02i_1zZsaA?EWsC0Sq$o(Is7h{ zq4EptYULTB#zS>? z*Ndb{at70xWDCG8WxLMSi|#XKR(#8QwxH5%HmSH5+)=x>nFPJ6Url)tvGoNE%y;q! zOp)K2KUZLE?zAi)=C*=O&oD70!$xc;NtTl%YWEwQ@ne--+S-S~rXo zx^xMMgv<#0 z<--^I#!9$YH#QN`G!j@+Cm1MqI7*|IT!fVvIdAfY#+=5|?R->J65qW(!i@(P6Ef|3 z`_vol2g&y4)4gizW2@a-Z*87utUwfTW z6rZe$|Ce`t|A%<(`-lSI_a*QDjbZVZWmxzEE&$d3@+oeX(}2QyIRjAT7jOf7`PURM)MR=t(5@}(E@OF^rP^|TtT!udpu3i&0r zwjVrv)Z#tzKe!cq%6sfli#>SAwzk>ECTp*+=8U}6*t&V-CUMdA5ZipbHrGdiMv*mf zjijtc^Rpjz*!JDvPkCx2_E8$id`xIIv>U;u)ae{V`e-#gN>}+dCvkIF)esi{kSO(w zmsD3osZZ|^rMA}rlWuJTR(;fBy!REQ{!UTq)6aoY=Ssgbw=_F(@^W6ZGrRs?l#vS zZ9dw5u>NSP;3#>0lik&{;#flNdP;HoZseDws0Akd@QM;b4(!cnuye=w>SJ|WRg0tl zf^O>A}zz4cFWZ(rWdy}c>RQ|>@t``)r^ z(O0(YmEBi0#9;g?xG8hEkA&^_7MFRt<>4X^a&3d`mvs)WO+NBld)xT<>*lVwx!1q9 zmKdF9vC(@0%i=w4lNE?%o!7Mx2uTqrje zFRxtp+p`2@o!p2aAiE+rI_A5^KPF@HW#OJLTKK;`-1Bs0++%7NSLmg^TrVe(-XdoC z)E5PG@fFK0i{+l)1(v%Zb7yuLe}`DkX07U_;XTL*=ZBaf!K-7vKMrQP5>vFcwYfcf z_<%p^_r&U%2*2VBz3#umtCz7AU+>-Z?%nM(1h>Ku%0BFwN>R#8cg5mp*bX@b>@D-n%rnacl{L zckN%1t?O=pYOn}^4@uCKb!Ay@v)h(5qTK$vbsa(il_1J0RN>ZxBrG%Hi&@WNBBmF! znB^>IIm`Jq{Yxg!Ir*#yPyhjmvc+&%B#?RXb@JqSpEZDkx^pey{SWo**E@TE7`jo; zMpjKXa96fWIsoQYsmIMGx!l*NIrZ2n@%V&vjW;14U#~|zK#o`o_&US`M3mp@ovt)4 z-|$XvS)X^aNv>oH4*R#@S|9d5A)bH~2Af}QSnOJtyUtp;QACm;GjwT>gOHlAHbsJ>WOL=^H%bpbq?7jO%&E!&xvZCegzH6CRj z{|fH+I;^7jUy~cxMDez=K!t&{Lh)9*bG3l}=vud%DczR4aBg2H{oUWN?oBS3)M~AG z#O|*uF5`f!xoE!&=Cp|Ph$ZyC`Azvu@3(qYes5I2F(Pk+>J!!$ zss1F4dA1c4{wNM4n-+9Locb2l-hkEijt?I^xc}g!cXV|4;Q08y*gq_pYL>y@B`sd& z&~5C{ZmIZyQJ=BX!i|n#A?cU>>VB5JLw+Y>-W38-bwdZ?Dy|AVq^6Pzi-;vB#KvW z#n!OeBA%a7+CjM0r1ZYm@7}wAzkB%LLGQ44|48f~c1unnzZRfKM(m>y!8~Z zz;e~6&;R|&_ov^y{rbmmzkT-V?b+#nLe*-jnJIS&6SP4oIL>Bym<96?>d3MF$G-rj zI_cdj2p+g1dn){oY^v}-va7=X*1r+GZI&A=9TJuaz2x)WNqa{V>*L(0uo4wnf`Ut{ zCRSfa-r45WyGa#MYgSlzy(;jr!6Q~|@gfp1{R4r=q2**}9XbiMKkem1mRQ zNhr$2gqgjE52-#cY*dC>|I9-w_aGBj**Z+fF(%_FeJhjbJz=3pYm&AzH0amQG3xSNy-xs5Tbb_(pH^{Ry2ZxgktW;UH>P@KL&v;JX+ z^_zeLeaUW0+9Db2AF`vhOFP}>x^?S1=IyLT$o=a4*V`#rx4j5kb7i+S-z}8GX0L&q z6e(wsRJy9BhP1Lc+f~Js3WMx`Sl-gm-y6_N@`t?g1@~7|P1$%P#H5NQZiCiwAL@gO z2^+0d5O_y5mp%}!D|@KzjMm{1?wH(dEh^Z#cORGN*_BFmMDc3N#T6IuK?&ZijCQ&a z!TWk0g7@{V37#*2=8b^neI|H2A$WE5O}0t!wq5aUtF!)KT%N1R-Vv8q7-R=T@0JF0 z-+<_mC-l`s2!F!IVpo;j$5_o>_-yhAV&2NmQ#+$&c#J!yWm}5~cdpYX#=Nah$ku1x zJ_H^6y)kd(roMAJHW5g~I2(VaW4obayXVQa7Fh3Gr;kU+D$El^wTh6pVVtl?ScyHW z9$*!HF=IHvHj%Hd0jBb;3%$AJbvjpzhIXCK`|bX6(G%P3_p9s^+aPb<{ss)%XG?+& zp}Lah?NZDyWp#G0m#-ONC7UBY(+ZmoNR@l{uzR#CZU@~E{y2Qj2hu%lTi1SL!RIqM zSUS|FLJm*>>h`*oEW}pG0k}?mCI`D92cM8mcjp@2nh`z|gf&zmMzh;J?w)k-b?@(t zDAfBH|9(ls2hxaaTd})S73pWX@Tt%R%_!_tb})X{pXtIb=)x^y8LWF=1izM6k#Y8~ z{DPm2lVGlbCw>PPPiH;38uN)5@zKsq6r&MXDULWhTGMT0S%~!Kt0%9XI>%e{B!9kl ztMA>{AL8B}P2kc^1RIS$-@D!1yIc0;Rdd7TTeQXapHJtG-fw3Mp?8G2>34EN z@7;qFdN5%<&iWJP`|Mb-qwXK+ww9BS?BurU6TLOht&x~p4!TE7j#P=&-_2HCWDL+KWI>~un2Y5K-SJ{yY2r_8Gm%6=YP zh^SM951mAm1&Ppugdv>YBnU&{f3!3x2M4%xJB6%X{*$w(r>AT@GsHK0DF7Usq zo>?~x|D2GXSaS=BCi1tAN)%?E@pmG{+VhvOTw_4_j#g&$u+e?l#ra#_?f3f)FT(gf z<9+@A4KBjzMBjyR9A!L+U`1p)&}&aS@)~4G9*ub>{D*KgqPW_j5!S(co^h6l89?kn zJczg&i@9=!&LC;UtxApMp2fOZ6Y1!9!&5uy+5eSJtp+&%^;gKwH5FG4hvD4*ui-GO z29fDT>;v6a0U@GhAQI4TcmXe`!FUS98L^5OK=uruCu-GJR2d`fpFo)O+|tkRMIS-BLIL!gs=_IOc0I3JPj_y-V&JO*bk!fN06%R ze(Pu4GxZ^x#EE&|CXRR{U$9yRcKswTh%}N#CE)Bg>m=B3b&P9=iO6^UqUk>#$isUk zKWLoy$zJLz%5v9!&1=k%<8hq$@}S{KGf#ou>L3EvnEoiEz+L+_i4*o_Xf|f}b9`IxW3BU8swk?eEA^zM~z2mP+olL15=O)^&^*9J)FD#95pz=0fAk-Y(u=8tp)iQDWUb^t)8N^L#Y+#bot`h8x1u6nGmh=_$y)EgLaM zc_xv1e!Q?Dqb8 zz4lQahU@is^K(V}bxA15kd~eiww3-iwZ4GQE6}4*q@|lfdNeERYRB!ShzN-}Kt$Y` z(6Bu6i-Ylug#uE87lB&|UQ591WZ&LO+4m>ZF{v8@*P~VjG!q4xRZEp4aUMh#_63oW znNKGy66ZV%E`%hu(!c>SG7raj2#OsdIYfqil{bBvbX$-_i?5k_AQfAj*^(;CBw5US zk%?p$M1oX@LBx{J}A6W@#w;&Cz0*Gj1p-H#7yE`tZh% zd8mYZ>uu~vy$)_o$m@3|Ws^9MO3J^48(VAD?tbi-u|{H(+{TRrH`uMyZ3=G=KrLr2 z1KGQ`4oqhon#pnN4X{d>>m6@PnyX#bA`au5OL0{v(P76oEZANR^=Qq>-bMk?S(%p4 zG&{4on6}=4`^TG$ou385tq6oqq6Op0c@BXaReYObuJI`Xfe;GKy%TKs{+eV%jWoj! zjU<_)m3%d3;AtWl+PJez;m{iAvw*mL0nvGQnh1$@hn)zDyOI&zcVjI%vDCFnR@`*S zONHY7Uh$ac5@xyEia9ruS4+JUaip#{IZ3~Jv z`hHYl@tJdHU1^d1!=p!RznrhG{cR<+!tvhQ7%jJlBZTZ!0m$D$R4-W2&=?6 z0Jc4|+_GggwaZO-nBH&)H?hsFhX#mOE9Je)r7SJKRaM33kELZKCkN_O@2w4|<+#XP za;em^$oUZWe@Gz&mqA+MWQ+PedAhYUn~-e-dOeEcQ1Hm$%C-LOf+w=Q>h}}~W0H@v z*rM|kRa*^;L-bRGP= zcT2fh(QS2}#20}tnFDl#$%0W32HAo<(L!;~#|w5TMr~u zeHK9_VB7m95|<1%ufs-S%)y@~n~DWG*3hI=s$nb{nj&b)@ZhPyF!MzCJR@c(h_WR1 z^RecE7IW~k0pAp*@E(k@su}T7FMJUF2`Q)kn)BedA)l!S-i{s zD$nyraB8v#hDkaj2T__qRcWU;ktSRaAZ+2@1kpUtD)7({3ypp}i$^%7A{KkCd(AHBD2w^33yQ9dkl~tr9mXRj zt}+q%DSL~5y}z!z$V2#k$i^X0rL=O6nnTMC7rl9ns08q;1f`)3Rw*!{!7nLlE%`h+ zkh-O5HVglZL++2lcvN{7_g!s-wJpeMgz;#AI2%vojPaJLWxr=}G!tpc&&2@f!9&?2 zh=8wt&92#F_S#{aG&EXi`wq?Z&YlN7tM>WZAQWbw@vkNO4BxM_&j@dO`#cFkQMJ$g z?$UjRS**9u)MJx>P}!6Q2M04A-9tJN22p+mf9}uuxk%x+!vk#Z9U|q}BS%Lz=5skYm_v}V zc@oTc64*S@h+^*E|1}JvceH?O{eBI;V7MPr2WRQsXr&I7bG8b!Z%V}$rtA@QXtzSp zTD)oPhf}Z>ALMD$!aBw{OqhCU=Er&F#ZkKj&t|K`@cGZ1R4ff|ByIzIdO`L6lumsVUU8#TJmvU$WUtt z(ugw6_Nlo62ny`xmk?NC@EDUVq(aVM$}a?NLoma|w2?!VobtX53m@+x`i+BZp*?#I zK#Cs)9vA@8B7k=V|Dn{xe&PtYS@1o8i1Q4jqmckMa?Iyho`6e0HpLlP1B}9W{4Qme zJjj$W5SJdzwRV!4}We|=haw`IIR7$5J3_av9G5-BM zEGdWwtQDL`aUxm_4AL@!abhn7tqXAfQMifHe1>)&O@+qsYzEsK#__v+j(51gOH;r- z!cILAU3f2_y#8*;M061(@We;i7Z?YV1Xw!;R8}IokReM>?;(rP=9jDjm?9RLhNg(adZ-Qt{QQ}sKj`G8m)jDlzY z{~NM)Dg;}^d7|QuqjQ!n(oD=+IKLT>avtKriz_j{n2Q7YcdrA({S-t#1S4W}78+$T zW~g@E?hVxr(DLO$z0lw~c2C_c#S1y+sn`#qR77b2I!;erK)g%hDj3J-37<~^J#+7`yeG5Ze2QMK*d$2PT%`8qVvZGQs>Nd_rv?R&7AEfnUU(oa6f!;!1?^vy zrP?gVX9D)2!_s^_g*Y&I9!UIN@@zV^?~ePXN#7a#OCGyJnR&X1#?vH@;yeu(9RQ+` z7-@;RYl>=$3pnC1j^|!!w6jGtHm|5*7c3jL`jR8>5MVM?GXaNPAX27?w;7k^Q5J*_ z$=1(IfS#1_+N6v!-;nVWH0WxNNE;Ach$sLtrbB1agze#M$|HZ0hb*2T-L+;8XThBh z!b~I)s`c^Y-D82~rLFVWGfuZY!*|C40e2}-`CNt1VtUu&Ikb0y$4Lcjx%#{6E1(M3 z1BDozh&j$H$?*e4g8?0aNMAN=*U_E`xOwt9c3)#uRl%hm@$ox@6>vF-NrJ_on@eF< zAXmZ6h*z}s4yP=gZNE^yP(kJ(x16*eBx0O}3ysV~0`rA8C-3YH z0^L>>?+`>6F{C))xH~#Kj6@z}d3eN5Up~djMs%TQ%L$0 zoii!1rdl&4Ss54}akjjPc<6(|^|}yAD%EGsmRc5nxO8dDt$IZkNK=E%W2X@ip@kY}8ef8r zv!lq6L#&Xrrl_Pv3J#IEzytCqgR9EN@Jy)}pM(0s2gR;r{y4?47l_;C6!a(s!X{Gp zy8IQGfH!HJCu3op@6Lm4nvcA3Jd^4b{O15PRtFdTzISyH2BU(Q|4X{}1?W(U+6$+Z z(qCvXh`jWaq3s1RLP{(m&Br9Y^U&?|WE3ZW>7v7)!Fr#~Ab&~XcEg=0biE4)?Vp2E z(rSqxR5Xl4W;csOR-DMoU@kiBmEb1TF0SRogz)?SWh03ZGAVhSdOT`2lZ1{t24Srudh^%Qq4%} zP`j7bEIK&-zD}+Bgbg*C5#9}nAnLuZVA5Kt5`F7zKBth8$Ytz61eDem?!%h`3x=v@`F1p*GvmrWrdAv{8;2=LiOz%koddvDqFtl@a7@r!aYq15=M z`|}WGDBv3^vic5NAbYlk9UHKWfDKaZuQmiv$J&VuEnc2>RC*{xJ__k9{W1Z zrm(kjun`Fw&xVX@aV;?b$Bt&arAEN=WaIz~W%#4j6r8%1EbX56m@IN6Q>XbDKAhwz zQqg9+Mjn$|(0fp=PRA(?3|0IMok(jftWVfbk<_&@8<@u%;ZE`Zj@Keh;*u-7-a~lxFpDk7b>ZP3bDj|lt9}SmeQT*xYrEy9;AA$B{wp- zIR@lejdPGG>7q$+4ptA8`fb2-0AfI$zZB=v*uWv}NUOX^ zVic7BD++zc7$ZT${V(`-k);z62exqq9jkek0V$Hqev|1F=P_1|C#l_Vl2$fy-t?_J z_O4dIwptb*Z)xFq<9^B@ThYM*nu7H1BU+KSnbc9aT?o^$A6{y8{L(Il;Z6Xm)Nzt} zVD<&gQ@e#m&O8IV>Sb#Wp?!n0r43IcWcPyPd!hjEX9tz9YndH7G!I1iarW%*IS<4x=zlA1s0&HN1SKtb`eQZ*QGE;`~59J5?5KmHvv@c{BvXG z<{hSbwt1V#2YtIhqnzYh3rFq>G}b96N;IK@ePC4uN?RNc^d2;k;^;PH9nz*|B(o!z z5KyaE9LrS|o*l2mGn!CE97JIoUtxF$i4kfZwhw?lTb0ZJKU+Bz}rc-j_ zshol%o<4mJ<#mO%&;S{mtw8T%F<3oqi>Pgt|0dM1D}6mQhgiRW1uN07R~ z8lJ|ClhTm2G`zojH}w=&->%|5f_eIB?2F26M03zpkdd2I<(;b);`P;4`!D_7JJN4L zC}nS@NM5l>HB$?1){-@eY%X1^q^z3OjvT64v9<{)B05ZjX~RXBNes}=_^)T)8Ge+m zy&Sm4JULIT)fAL4@N%#)00)(cGDh!*LFDMvb#jl2^?@QL7|BtECLluJXwB3%GpybqmD{{TQJ&m&^)0MnG>1{U==Zn+T0#7 zRz5G4u$0B93=GT5RIi}0&^p*;eqzgE8{fEsFewwWSKZgDy{bFy33{xr2zaXEjG$VD z@&`hjm1bow&LR;&n_c>lWsc z(|`Hy$Cs!gsCX1{VR)u3YS>y!igfMR(qa$(BEWSr)OsUR+8Rp74Jk;{Vw}U_krW?& z5e63`0pHOx>C|IizM}C~Dh$Dk4DS9yI#4_KBGXDm#7v_{JxmhSjCllw7gDs+#!)K% zo`Y&P_1KwoQwCqlj-0roOsnJmwOEn}@chCQ^k@_y<(XEXT5oz$8EF`0Vxtq z(n#%6lSkrej(nC(ket?CsGrbrhTdQk`3MVzQeA)zLuYn{sVos;U{`Ug$61a(sv5U# z>Q^@}qIWl;FcV~3rFy<@7~2{55|a+Rd~tUAKNLY^evE5C9ldgn!moygs+Z~~-DTv+ z?RT`7e390ZhzWBX3lf{r6LOT~b8x?FTV8zl8vNVo_usdMP9!^S(U5pDa-&FxxM=cE z7a53|m$ptAY$z;UnAa+z==m9J=oEEQ1V1vXI3)N;@ZlMCl`yw>+j@3o!&{ z%I9-I&W$?C)X`Fd_n^Ub?SB|2rnDM(z9`2W{8rl)O0Ft{rmsp%h2D;<)y=yw8M`k- zE1kAF?nfo%ach5EY{SSUm+cF7Cl%Q#xb9u>u-&eDmssI#Qde>wK;A^q_rqPcGpSIo z>kd2acK06M85TzWxuo|tn(tN+O+^x*#<}9xp9`R_oxkf%=^}d_%tV}L)k`d~at~3{ zt+YxmNh-RjI`JCLOWR@nZnt|=9RtpY$jReMAxqX>TqP+##R6)Q*R~NJ*L*E4(}t<6 z6yE!Vf=Sjq-<&OGqd4^ZAf3ml__@6|U>9*vuL42MgYw>$W={PQR)iYaaYouXmpL~g z@PtQnf&y7=320AIW=lpR&nm^YkGaFls?d9-;LwVcYKHzNrEV+99}cZj=%ak)I?^9q zLzl{QEwqCR81ehEiDHeG8QNu2b{-3=ZkC@z;EVK|q(l!8VZ{^JCsMKM(tytUECEqi zh9d9E;LkxdMFMG@fQKc8nJk&yw{c>OlYw)lWTaFQ2@6_WU(Fk2AH8gI0&l)?mn=avhpO zXoXyP5M=}Q^t;pVzj0u*_Y8;-#E4zSN$9t%lsvcq#P@QerVRWOVpD7^r!(uYVT-n} zHB^$8LdUl#lw2h0^Vkn^*uw3FFa_BgyMba&Od#@4 z#vG1kw)Px+3P4OtE@WC3;MOSKrivbqfgh%j9K**-Q-~Tt8NJJ-SUFl#?1bJo44RcN ztkB99=8cGW_=5|E*!#qUZ8Fs`TtHN{oU8LPKbg-%8TFE?^e7zOT{)mTp*TUkj)-(+ zzPhi%syT5R(mM+fwatZ%IXne==OeIQUe((XNdO zrasp>U|&Cd$x`yzj}w-Xvwo~6UGZ4Ib{w=_6&BerFrbz|aH&lf;~39J&fN`UECpk^ zK+j><6AUe@dCf63H715pI$mQVg)BH2V2mhH)UV0~+lZS=0;ZR4R3pG{QIAyVInsO% zZz;`AO1jMsRjpb&{%GxhS^~vy`HW98X&zP#g?pYj-w{S(V^vFYWLoW_cO%H?{3=ut z6cFYB4x)2#%94jR(C&qivPWZl11O#-;ki0=EIAy6c~XnssKK?jz@Cs!hM;77wQi%f zf;D%lR9;#?FDZx2r%De?9=`;>~MKvHWFvwUQfi74*S`PCX zC&Gz5r-Q&3(N$GTCxeQ!BzD|}s)Pa^Fv=!je2Fhq5{Gqr_vb(V`OoYbalQlVB~)|^ zPji{(w32>GVF9L8JZ+iL8rM9fKquEUG~YKad)80Kk~aO*LYTs#|zFuq)uYkw~z zhh&_UqalezojL`$_BECFjtT|2{+5Nrzbx^;KR947Kbfvlizd;9v7LAQGLiz?S_3oFW5f9Mr9Uk86uvID% zyy-3K+3H9TH;5sS?=EsGC{EZNt~c7>7wBYe_7NZWOO{S~vOi?Q#>qRR)mkmAi-xBK z;%K;J%p+1_*R)Lq)Wt*6QQlL~?UO#kYxzMyG4%_S$?JCOuIp za%$PN+GodRl56^&k$C}(S(*C+CDl(*^_x>*$Y|htw%mDFboznInA#>nGM9pnr!LEb z!&&%Cr+g=Z`0(%!upW1$NO}hZ`#1@*#jSm}Xx24v7MP!@LBRs8-W@4<*Y}n!mKd3J$%L{I4uNP~jcr2yGTEz&KGk}qL2t&spohA)XSm1gN>5AOTI zykv&>>Zh?Wop;Ig!2!98k?l$yfI>6REBM93%OhWiM9kt$Jn{VmnG|@8?j3o({;}8V zgST_H@=>Az)Z2`Z;BBU{xB_K*lgOuM?>3}wn+&~@`PkF}{g-qo83>1W zAkrc!LABKGundj>Ph`C$#&3fGsbv&w281@U;;ap>RD6l&_H-&R*N5_X4g=Ju({@ng zSSikfP!@%B?aHY#ni(1mNd-u9vw4RsmB=`z3v|@r53pIQNZWd{# zIS{1nU%pqJd2)X7rvLM`#@S&7i?s~~>l-rl1A8&_X8h`@d2fcqDyYpqbNV6nf)C=mMO0roN+O@=XFbF@}=8{0Ymf%63=RW|I2Tcr)X z+1?CIjt{G*nw2USOQ=CPh&0=$j4qHo7kXKlb0d+-tJqN>k*M7eBuOYZ)i*;s<;Xg4 zshRCfcwl*!qFq+U~n+99Kxq;dw9a|tX=8bs{5 z=p2A0U;mh%)6yjZw~L~;(dzITds-`8bLokxk7m>u@mH!&JKW16Qfkzsu@^`$JN-2nGt7h4@%irpLSTx6w; zf#2yFO+`5QjAqTztcV3S#K9&QNbVb+oioq=y64fWVt>~6tk=Q*;?ScA2>Y`muSDvO zJ@x+EpPtA^vvMWe_rFI)kVx7%;WB7Rw87|*93JHWFK}5Bp$efu9T*15oW#d5W|}8 zHn6WQwz1z>ihj!-R=~9i5y$SX(QAVZT?N`gqm^wHvRD|hvI`-_4km66f4vi51$V_E zmpaGM7HEnAvTIUejkG=mu{v)^IBWX+wOg1-Dbws~dHfSXeja zCI|_RLEA@42dbk}E?}wi-FA-1(MC63^XB+l3GHS$yn6cxsc+BjeE@W?9JevblU4WN zK)EENR$tnyC%pLG8H~;@9Uo^{^5BZhLknfq^fuF*BkXi zA>sE!`wJ&yvGa|SjMjY9EZ3cjHo7E3gHN}gtFD74g4oCO2yS%52FdH{q5Zre7I2p3 zbMjU@TypMTFV3LjUrzOL%Sq}zXD^ChnOYdn>c0BQNIex;gkP30>9mYOFUq*{tSQo* zy65)7{qtEh)_gLUU{2GugIe1PmO^lNdpxkJh7|I+5il$ta{A&m{PT$2i7!MFLcE24 zhyBLxK;BjSh17`jD}}E+HB8_T)GQt;aKEu9kPr7S`p-MTd<-Cn%Gjk%ihJ^v4crd& zRrCBMjU${5_bzMCjw{#v7xz0BD)(3olif zC)r(m%@JRBgI(Jq^ zSrwL~J}llpNzDE)*ri;L(npV{x{J!~2-WR`jP;UrI^CMN zmZRy!HI}&5bkQGf8YHGW7Lj02*d)%AY^q0bo$76XsYPg2hJ0N_b|e07De8~4ED%kYAj}_ssnpu$y1s~ap4uYj^fr}>({`I|3z=Z8D_iJ zd!^T8!S2|NAvV2vYe-<P;A}f`9vwM?E18(OaTIr2Q6a#}Cuvv7R4=rN zjFNscG9l`)qbh-${HRt^)F5I*%(99ZC}VQx>d4QO(@&}c`^#JgeMDK%#@Oo!a%y6YW_shY8~oSfUig~_x(Ty#K-FG zQxRsV(3?6afVbQwl%s=c${s1Sx=TFGpd?n^B_?K|{pUq=p})F*Xbn;r7UFb<<4b>N zF9D7aqT^s|sd`|XETof`PONIDKz5S!%UJl#&ReRUg#i87B;_Fw6ImL&G#;WPflzQq zvPL@=?$&AEtwejS#~c_9QwrvP{^Hs5*F)QT;Vz@|#yWk*tI#uzk?T$4l9!`G76r$h zNbyeK24fj&YlEw6cw6OK1-l5e3nwPL6_*O4lK|4%Si6w=us97n**leA!OM>mQ$xxO zgvG8hUJy7Ym2Yntrfff)GN_n71b63oMlSw_!BOmtW_1)ep;B%yy#Z@G3#m&Jx&_t1 z6=*-40$&J|H6d<#*sxJWwNf=TrDiFXQM0^*3PWJ|l!ikfqPB-hano>+Qij>3D=1tR z%=MsN3tzA=-@`xEV^$Cn9aZ`SqDK}?gdp`on!HQCkYXbn&Qr#(*l(0YH%+HSDBHn- zxrGCB!U29|9sL@qeD%!cjnTxaDsY(unV?2XPHw&_ddyR{4u;GdUg99KmUgHR=6G3l&2snYw zj-knIrp&Hl{7(60LlPWF@{4z7xEl&yRT^`|{kQVjZIw3F@~VWbrSv%+w7o4qzt*?3 z9C(>Cp4dZst%h{(sSIh-vG=S!X=F1@GD+ zW!2TG(%hm7D(%#aXOdCG0lPyJ80O^mLPR3muw2)nPEHbt3sX!wGie%}33Z){3Ybx$ zR6APJ56tZI^oDFzK#S)2eRr`pZ+8|%ekDfCNLSaQ4gjJ{WD@@ojS*X`DLY&#YV16|X~ zWfxk-sjDrrQ-6UZPa#G;VrJiTLMpRRJoL2UzMD1*F)$hMSr*SLN{W=JL}f}}9c!ti z&euk$a24#jB?#o~ds%})D#5fEuNsqzP3Nkjt(I_&e}{w89LPA=cPkjhR(jRX@(8Vb|85G^olxCinjZ%xthuj)5;XM>f)3TYyLz(4-Tly$T?=>3etsOhT?-BD$=2^`9f5b} zRTzRG9ULHI7{=VkcwAx?@a=5Di__X{W1#Eff$d^K)v`)kx8x0~+?cJsMC8@DdV-(U zQ?=_=efYO*CoB4>kKOiGbX#7-U7yj1eJ*!>J|Ffy-N|Y`+Jn36)$Hs=uABH8Pqnd- zKf4m+rOr3D4O%)-EOVRC#bi)ImbIZOTh92^*O+&Fh1b<)?rKFR32U8ngs_BX(Ktp$ zj9R(98)n@?HXAUSuBb9Rl)N6!luHBI@i7fBS>k2RAg$jt=}~w_tvfOo zKB;*YT6qL<0hly4&a-)*sg&Ldj@-jS(!VP)F6M1VA5>%OMe8)xU(j`)C=aHpZ($q| z+85wjFybktXnli?O$sj&d6&VvU=F5dOymWB9e|SOZ9I8vdu+T#Jeen;JWcoZ)MO$- zQ^#t5Jd_$zJ|4#jpkTOYrXa*sH_#8Nj?li{x^nMw%;cHF|3JGjP35y$UlayNU{NGkY8Ap8B~G#LSb!aBl{Oy@W|wC0;3D*&5;)9Bfu`+*sYxHq}Nh) ziwmW~b)Mp{u|_$>CIxW>{tgSfF=iplrl7m;4y~fks+_2&rl8CdcAaBYw-m33sq<>N zQ@F_^T}LwMj6qq-q(6qW?aQnU5|8YW2pSPPa+4#{T3tHb$r`0>MF`p#urc=5N;o`a zKfeBU|Gq3n2I(ltH@7%NNzB#Tt1LPSWFZH&?bW2wUq9Ts8BI%i%c_-HYc~r<&m?Pf z@V#l#E7Te)FJnmmGLFw9yu5l?O@n0T4jU5RpelG6OGeG<)Y!OgM%pD!9P^Cbg>#w( zSWM?FRwDn6U5?p)C=D7o#J!Q#87Niy zuDpCn9;GS?Ak9k8*N*!r`KU#*HXGE>MN~L!SU>mh0GfM;vVN{Cgu6&HF+-H?6unsy z`rgnu%_U+U@^O*UrkTw7NhL=xhrX~l#8~l%wnJW}-PfdXvaB#SIR)CC^VoF7#`S>3&kO4tus$9|#u z(6nQMvN+RHjE^f7S5Pmp46`J!WcNK$B#oFP>V6s9{=7#9hZPCikF-aQ{?J#Xs5j(7d zDCuHLk?eY^*pgJSrK!51iRu??p3AA^AK2TX@r%1tXA4^YBZ(o(*|KH(S#`#n0-B>BSd{TJBz2fYp+mBo=*z7$t18C2&XWSS zakYN3Ds!@<*3n5BB)g*YgNh@ezYAFz>MVCAV>Z1!cZdVMGXw@y*0sa9GQ+6O1dmcV z`hg@T91Fisf+)bGx{4k3HrfHL&$KcvI!ZD%Nu?gs&92!$*&4PRY$`3lY%2Y|*``8X zUG^@DFQaw0k#=TR+gPR5-0m)J6E(TBdzVv8VhoXDL8>>Za#P1xj6ej)kAT3hWu>IB z!=#>}?730Q&U2pdC=)VGup_GF5gjPE2B!+O`CKFrR|=W}cZWaqb7a4ju0`RCjZT(? zbGw- z-~RS((QdalD9^~f$nJJLEPiM0h;_BUdbnyH4xHNaUqWD5vp07srD?u;I_m1x7r*=P ztFI%mTUz|bKl)F60gsy#FqdepyF^WtmaVm-ky><>#rE4E6iaRK)oCwwYe;7s=0ad= zXIyCJIqi>MKd~3HAp48+ zoOjqA(DU8-s@O`R*s~;w;-#(MD-QyV9c5%x86RZy`SK(OLM{PxIJOPZQufFUCD8I( zs&r&w`OIjO$%9p?iAUN5<*`>BwqGV^agzE;^G8m%bO<(&p%v9`Z2r8MbwL(y2r`z2 z!TA*0K%x{4butOY0aZQWk+Xm*a~*-I)sD+#w zkopKY#f1DLB~xIru-NVfal|Df+S6?r(Qxl!dX|o@ti3CDF@iTc0EE-0LIHPx>4yFDfU2RWn< zyQGg{IbQ1yuT<9DZ09yN4}aJjduzAh!&u30iZZT7@pnx>ZvQs?QCtFUinNY~cpHbc z9SiM8$KqSMFFW^#xCuV}AxYjxByc-)2Km4ukh6XI6ZrX!wRd>a_6lR^*%dxtTUfi@ zg4HL!-L8`js(V&C+7vVZx4=`O8Z$PKLZO7SNobRW) z7aQ=(AKF{$b{_ceW^-0Ez_%TTw|%^y&dRsUJAQh|d*h@3G&ip3BKU2byjxj0u4yGT zmA!jKdLU@_Bsss(&8iAU;i`gAMA@44=04YEvjP6TYqK?}d&X{5m2J7l=p;_wSyiz} zU8{01Nna(oap(|vEprW#>n8}@3-Vb5hf(k}P_A>ux}$g5_mCXHfz<(LDc8+P`XpK2 zOHP`ZI`1rWu$b}-bg{6!l)$+pk7OBJaBGVqq4P(K@*vFiRT?ZT&6%14s+18*-Vszu zal-a&s*9^yi7G7TJKSMJKQ^>VA*5KOgKUCu>_J${An|WP%)t|D79dh{?S)!hCV;X( zsm?*`_HI{}+l@>I0_LTfG$B`GOg0lh%0u3S}}2Q+{D1_Gp2=JLu&{FSbcJj_HA@hrHoDn>~MD{^=-b$IKlU6{=Zc^;v|BUzo; zI8U>9W=~H#;VNtr+RH@&b(d%D2)fz$A{{5eJOhWwiN9y3cF`^MIx4DuvElO<-#mN! z^t&g|pFjKl?YG}l`)w`F*n+3oZR9dEc(~jrh#9uQbAZvx%WuSdeMX3neAJY$S!rD&hmj2J|(W6JKg)?b6 zPNAvDUQ?!^cDv~ER>-yVoe0C29QwX|Ux0u84{oiY4(q+`cDt5$DA`18kA3AW2&dY} zQ;@CiE65sp3$lX0AY$5EOoIh_ZtxeR&8sO{B12MFRxR00-4a%q%0{(It}R?rzZ$Q^ zW3QOAV;1{)D1esYMW;Viy|=(Z{cV&q!SgU9x~0AC(k7N{wcJRw0%C0{`!&WY6t_KF zL^b()YYNGt=dvx=$uO-aAo!55`R{?ayjjj(WwL%;k;t|X@Yb-tv9-=6A%3MT*)+zl zYRsA-zXoGIE`|B6vFcY8-{Hop&jVkbfZ26&q#ZCk%D=ppLs^OzrGa?ue1!T2=Odow zsdd0^oHx;_$_P@s84|3=1DSMqBcUu+Ti{A&l#CZ7E@F?yJhUSE1@ zs>_R!Jf)_RM-Y%ver18JpX4ww*4y(v_7nIlb0*W`VS^Ef1#s{=9Hj{g#Gnv6FCRSg zB9f(Mbu*|wdxRAGhMZRMPxE;0P%9`RB5;ogSVCn{ZP6P zdK#-LmaG_KMKY0X2pSb5E=eY`Eiq$t`iyniZptgMjO$h`?(dQ3cIUhX=e;GCTg?zQ zqnhO|2nVoxDF}=}wWpMdB#!of6-jKO>^n|w0-OY9zVIB}dFDjX7qd_>K$S$uP=3i%kI6Ypzy9($B|Q0aHuD^O~uuRv*r;Csw1I+GOunSq&Q=_w^UP7>5ut zDlMyb%BJx<^1&BZXiC3JH}Q_!20;Dk^Uufrfzvw}hk2Tb#Phu@-N6{$ZujKqi2bSC z?cF=>!N1+!$qD}3?Vg+*pLE%udPnz;PP&K3z2lQVb$ch>?lJpQcL#GR{p4xJlRtI4 zNghQa*&Gforpxrdx8TR#Q~P)O2l?u|>?vVD3U6%LYpsx15j-h$Sxe)aXS#l&d>)~r z9{>>mwera+`p$t!C{G>t?29so;+EGRY#920mu zlG_b-?Grf!mWj(O@V^;$-H<4!fKN zkhhfl0|8-xHktyT<#nj?u$+PKT_{Q(joudw_a7yEIs-MT97gbT!NyS8O?sRb9aojl zEla29!+MvcB0=2;_~NJmq$ie11}F!!-J9qmaBR}eU<>Uw@VC?8z44uU$wAN(VUW&T zzo|HNx>RH!w0x>?w&e8`<+GKbo&4l+4mDKti2`35M(BZC2@fu~R)!*D0ei%{4_UzeqGtM#1^@iddSIqDSvm+l z{6ZypmGITq=$&Rl#5CcYEgZ}-VF&wK@b-mNM6_g%(G=>IKhndNw4kY*xk-+Y-0xO=e9}EWsrdL9-d*csv&xAiD=87E^w&_)1AfAj7DnhQwf2aH0?G4$q(@?z35tW$2Sw0nX z+3o#YJChZWWQ94L)$fx=+7*-W(l8i{c7LyON>Zj;Yh!+z3d|D~CwSZNf<>w#Jp4&| zvQ|nq*y<@xc$kXHDQy-b7e|xeJWr%z4+jQBgEvc9e1?fF$;!M+B0|Vt97h-nlf_yp zmCClU9E6ydS)OM06qKX&3h2Cfd zvGD_J@2$fVx(a4s3IFVTgdnA6X&;bbU&_*Zt<+xJ8)^2x+0YU;g4*+{PhXntd9-MV zj%OmHLnrMb>c_K1shoJ5HZ&Dk9{47%BV8HTK|NGxhgW@%^1xr=15h{X^CZsaO{RUm z_O#DePWybLX$KKlI3PF&-+_3dh!Hv8OF4^6xa1IHG(2RG;O|hqZjm-n&B`3^y01e! zOym_45M?H5@;OdPMw!8cI-u@O(5FTCMt?ddW~G&ypetXD^7EH*k`1eoQ7#l(*xMw7 zIq2`bX8UG&(7c0aK6nJ}H`h4$05L_0Ohq0l7R@4JFBNxl!NZ)w{@Abu?{!P2U2my3 zyXCBn$jTG>U1197ALLxy8{T&{hka+9J>%=+#yzsePlOE)e0)mWOQSbK23P?e!G==- zk2uknP$HNcfK`~J350J;Z!jqmy2hgF>o>mi*W(Ai3zQM3@UAI=K?Vj((+_5KjKG@; z40sR^gVKx-Pn_hNWsut1M<4@`VM428j!O*V6W>ojcs7h8r%%cmBA{p4#lNsGXiSwL z;QZ0j2=R3B#7h3GRe z#b&MCpC7d-dnWvT(t>W^yu3JqkKmV+8g|SqVZe^qZ|sEq#`b%_g9FGr@|Tl4HBL-V zm=qSZAByBkQq--?^HCU#Z4Wyn7Sf2wN0@2R*lkuRTS8NwxxhfRiQD3^*;gIwN#zJ8=~j~9m$*O2+=LFp8%1VZxFOx29#{>I>Mju z*`B<7*)88E>uezDtkNU7m`HG;G!qXsD=;)&>yGkFhyi)f$L`=q;kbp zfq18{C2+Dt-jpp7A50nDP97t5yYG@md9hQZL50Cok_^o)pQ6Uf@#uLobbX^KN5st# z%;cN^aB@of@H?$cA=ti(i>}4A!Y!&^sI?oFOVr3I7gskJ;*z-H;PXScEymMWrrtnL z5Xm1GIsCd8-wNZV59&4Urj3eSmYDLWtPQu@%9Bk=bhv+EG%ia_+e8Evv-$ z+pj+oiFf1*Ck&N!`Bz20RDDY%W21!))q0s!nikhEB_nHMxD}=`DDz-+=p-x5k=vu5 zLvidNgFGCnkL?5K_OGRog4`>e`kwGXS|PvcTvGz+n~ab#g9CDY}(eDh#*`eo}yZk!DG}P-&3>UoLs#lj|qXf>96#*`m?&G%QRC zTqn~kr3!Y&R^;%H4n?FkZ`1~_@di7uulxg`%maU4+Cppiod??Ykl6(G4fT4|lK!f# zpV@QtM4U*464=ejgH>tcyu(e=K zkmYJ+o*Fjv%miernjlL>IH?=`DOe=ZdM=xCGnouLB>>n1SWIcvOr^IrUSDbZWnmm) zNXHn9{DRbL_-~t7-^D9peW$!^sV5~50`oc*pCkh|5=a}uJ!eG9-hy}HTe^vO9QHP|afr2x?KL^ofe9+lvluiqlu?fk6SiFn>xAnT znrm-$`}WNA&N_!HCa|f1YC&|q9xe4Pq}+_24xOt}H@Y&?0m`y4xIq8!(qE{_+0K!X9d zI*7vX4MtNmaj>yYc88}Kww)sXP~GJ-j?^HHX95SP+vKu5MD7CGQ=p|h1zL3i%=RTH za7mK8Qa7j;vp^Km)CYtisXnb1h#c80o#vSzUq-Fs_`02qr=>P3_~lV;iZ9bvLnKC` z1nauP`c^hC^~H6q)ab0=!if&6nZY;|JW;chQ*S=pIzlR)w7jX1J}fIZP)U7xKdicZ8vjBJ!K>i+lwNE>$&+*A=K?17_(tC3`dYQ+43zV-{oqBtBFxh$IeJ>v`c& zG5t`KFk>qc`#t9i8DR2+C1N5H0j)qM<0{>m%OKiUVFkbE3S`QhOX@+TgfzNvEjS@v z1osvxq+J9Y{&pTD^O$$o5Dim9;y^BgR6sg|25^Zox(|X5oR-ROrL?jIJK3?841=bM zh;I#J4^c%&m75!+Pt_>xwI$wV8{A5rAU<75)@N-h^yV@JI^(Kj3|OqvmDsq1p5-pbWAcJi(4-TVPv)A_e@v?^y{``boN z!FGoV=V1Hm>)LtPPQ%dEI1Sf4Vb%_`%tiMF_Xn+xdJu#38}Pv0TjwoZ*L`_+^D3nA zw2rKaceCfXHFqlgnhVF>z`@yFZKb1gxe0Js!>4Zg+P_5wgdLXqIvN|RZF$>jpZJEa z;xckfN7axLn>5TduN+DA%+Kka^=ic*6$R|}Gh+57qy~~Ql%%(^iw#8fR$>7`(fzb@ z#!{7{a^_GjjgVn{(oIYb>&r8?pKlk-xfUduzCB z?0FU==6==pD7mKl>7j>naX&orjGD^*=Gaq`zx(-#$KogqqH6Ca?)%>(Jdw0<2_{N4 zl%Ee++w(k%okeF>+p+`*`*0bwJ7&>$9GL4t!ToUo*tVB7fn5cK$-qS!Xg5!l5VcU? zvk`24I_?14E9{9S**69%57q^#&0suQbfhtHfRgGN%BEnCfPEs+2V1?zTS zcx$5T-E*)rZv~MIn2k`$>V5-cvY~7Zoh+bRKqw2^ZAU3|r+LclusH^#*}z_%MM>t?+XhQ5f#V*6NH1$A>wt%P<{Y^?^mU5u?9V_R5T z3H+15+{&3Z$KIN#7a1nKDn`Ll5!p_2_E1Z0FlSO>V#PI7`2UntS)g3Ryh^5SPSLZr zIuwe0ltgsF{!J_nPz}T8JV?;8#eFMU+0B-_Xbio>TCwY zFU=D%Mq`JB*hAF?+s8~RTGQ^?pmk!YApL>EK{e0;Cb>`wKa=K#apM5}TE=TPVV$2`9d=k#CcJ2(#uY4uVs<$?V9et%7%w`EOk`$G zXHUO-_RZT@ugEbmiSx+cPvTJ!VUU;G>iLW3&(LWr6i|XP&@N-3E9Piiqo_NB9^9Ui zj7>=?odRl2#bg3%{tL)`IZ5JQMMU1Ga+)S(ys<&ZQjtjM-V8kmW1h=>T{EOWE{>vA zWQrw#CeKsO(}{6JD=ZQbnQust?+#?P#EI4_YRyJV6j8B=5Udu4r9D(d-&8=Orz0E5 z$!p3Zic7E{L{O>Et~NOr2?p4~DAS;R zscK^l`n^Q#8zL=6?;%xmV4B4FIi+@$r47IT@$B`pS8r)iFJF9r`t(1Bm9-E(_U}9l zd^c1$Npzra6i1>}7hBfrdHu?pR-E(dP&2fkt2%xk9wFOw4K|2js~8Q#Z=;L7JrxBb z6Q5Kh|F-8qp$*iwBa^Z!&u@k1bWBTMYEu*!=qm6RP^eUTi4wy53?s=iHsevw3+{`K zdq{6NAyv~I6qCHH_u_t-^Hw>|JU1jH%jfirRA(*s)qLThq@vMI9N&wW1S(H zw6&|e$AF*I^w7ov?F%adWSqE9)u`552YGTeB$`J`JRC<_#wK}|Cp2 zQ7WAQT4J5A3T_t#7Z#8v5nzSEbZ4_KOupF+D<9^Ox`4qyt{r zQ)iP%(F(?b;6GLZe53RyPr$KdO0*w?^@+A~8i6dlcueWg?@1`z2 zCFh+(54C>ohuiV!VT|4L=;^B5-jC zxdoXM1}?2=j&QzRGWKSs3MZ=lV|fzY=q;Z3JyYnL39smA#69#_e*52f{)xq5A#k&Qbb!+ZNLzlR% zUc$;TZ+sEgalE@lm(iK_?GmUP?eG@vWF_32-%HX1k{(j(8+A`=A^i!Jk$J4Xt1D*c zmYXS-F_hmrpx&l>d~F(D=qKf;BfB8jrxPKq@Q zF{3cn{x}B>q$-_2DcDnJ5QIEIFA?(D`d5Cz&&EkG&vfIN0Dl|EE21j-V0tz&VxuI! zOl6@xH7Pj@BC{!)=5$^$AX{++HWO8N4fFUvRV$$M_LvZqa%ZM2&7pu}%7(Tf7qZ^z z4=~UGKSC!z_3(o!M%Hf-h--n?_Vacs$_67 z==a?Q@V%t)?UnFP1}EL6bAr+^2LSRd$(V!w;o#6M3Jd9bAFv@o{Q`ZX~J1N z6Vv!oR)?h~B1u*?nJwgCm@Dv7FI|4x#?+WVkX2z+-C={vEALw+h_&u+3D8Zi?tr~% zbQgcd;pq$;p^};6){)7wAaEg_Q|s#lmfJTbl%&V7j!j)3_huJ&6kaU#RBo4y*}$7bq~Q23o8+a!N~LD z8OkqIB2v4Ao9yd(5SoOTR%oHzj`xn%MSeOcUM%=0OL8c7_R#6zxbiURH7xsr>vV$o ztdYC3t9}F%Hbhq`^d)`+>8Tb54SaDSLI~UOX7R5<7;w2;aVUK4NWE=Q$Gd3ebeX%RFQ8de$j?>xa( zV|6?pgu=f=v3aI^=TOc7mrm@7uAo!|{bmR#<58>i{LQf=vPtk8L7@L*ks#aWoVgxu zH1w%^L|Kw&(~ZvPHTK*Cc9JNR^zvIZfr7^#eOSOP^wef8b&deu@s_IuT!4YO(K<}h zVD^vX#tr1%5B%tFt*i_YE^G0e6)k4at3|GX>rJH5FcrI0{KyK%@_OA~>1ztVrLbE- zZu$+-M;4T%ES_}Y#Zyw<)ir{GV5TJJNTgJiR$>lN&0LmjaM;Zv*aPQpxgiKds(EF< z$Hw5`d7di01er5umLHJoFwUy!6lRPcN-2|6-LGH&M@L7TX*!14kdchR>jt-VHmBVE z@P(UDk3heE{U2T#KE<@+7@1Yr!baXzcLHNil^#F_HmX?I;%q_qyuc)S<0MYgavWq4 zI95ZTq^}`W&+#DlC!57-#=eJ=v1J&Yih-$-(0UOQuQJ3oLzV)E#AFp=&ne1Yv+K0g z=vSH91H}v|y3cc&vf(U*Kg@zbC_$qR8==im$E@Te58;2XNrmo(s{@i48PR(THc-Ij|(jkJJwgF zVbxdml}J???j{#@E0>2(xWpUW3>k4Db)eToz8g>NR$~h7)Mn^{<^^qK0{ekec#G04 zV^u4h*!#bRLG+G=@%ip@(ixT1tu^O7oD|4)OuF9>3B~xe4z_3k=~+sfa?JW)MPUR$v;cs@!T0wI@)` zRu|47NZRq}7rFVS>Yb|`XpTmPTcl9lf*l9LlvPbBh;P#jc_PLlxNyRv$}qJUJWpaj zA5*gM|MA23N;<7zOxMB3Ai0`_;1uNZjIW7zQdKR_8w@tYr$pis{4zZD10V({B+Z(o z)rCU0JDRU4f~MeUC7n1)r7aZ!7&W->2XuFI^E4l&S&*TMpa@vTRU4}yTAhL@o3szr zof#Y)%y@JUFH8umHT=0hhw`NG+u;Fq@DB0Ll-}dEd&(3gADU?OT`CS%Y7S}z_YD22 z*dumadNN$2MvG*{KmViOB44aZ(OBsoW#eNIyHx(s3+c`PbVg5iA1ynv)D5omt6{l1p)K(6eaU4Oq zkBCa9fJJbJNLsq=D94s8f^H+1!Y`+4gh^X|Wltk0t^ltU6n2j?E!_jT5r5BN=Yi}& z{ZUBQG#11-49}A|pP!mOLl%nYJexL9^2HHE1JmY6ww2DyXe_B}B7FvIudh-^Nt1R3 zB3LBTTFR1FzCNkovJl`hKC97;p2lIw=c({Fo!U2I$49>Iik?M& zV-1GG-@?thF?-wO>fu0JzIiU6fl8Ine8#8DXXH_~l+i$2E;bu5$!6qHwv-u=t&bgl zjFr&01$s53vEwIo`)?@h(w6V>>jag}V`Z;|l9`x&Lu)t3ahT7dRFy)O^>_j*6+g`Q zC=Yq^4bS)xGr&PEvY}}-L{BmXPE+Of@J$$l6y~vSQBE77KTV9qT8dK*WAY}nuNW9c z19Y@&Wkg#NMK@@mjqU`RmLbDOJzNH|Ssgax4z|xQ>e{VIrQxeDS4_`^s5L^BAnWu+ z%VEBG&-j4#I&3sxt^a62u}u7=^`9;Ltk150t{m>a|LcGI@BjLr_5b}p4LNPn3Qdtx-C9)m zNr-y&%puM2^k|x{h$f!@at$t_h()C3Gh;wM9$2X>QD$xa*qo8$2UTTGDt)BER~s@B zVq(7Bm}?=enlj&d3`*@LWqT|!Zwsms4rggPoFG zH%#$aJhfQ1BIJ0E^fR58xi$01G=|pDjBBjalQx9Ne$H@ zpi8iZ-H~kv?C|8+>-X=?V1zQ2@Z)ENdG*^hz)MJ6zw+e|-o56w%9V%+`{E)ZN=w_Z zso)br8rxy(HTeGzSZml}lNf4tni2#bR%0tYBbP)d*x5ekaT<``DUyPoU*Znd!+IE{ z-8!4bmux1MldiTsG4xnM*DGCc^l~a7kOsfjYW32ZAv{3tz8tlx1;!5~Vjd3qg9o(@ zUOjvHJ%vDf63L!H3dS~c^nOVP{iFMX{=Ld6VE+-?BHDfou?g7W{=Gr(sJ??WV3J2) zWA``U_Xm*_HlV|9chKuM0`wOi#nECG=jm5w=10B$(*BS^>O~}2TP7C#B^})F5Bl9k zBSL4pXYb^}V9737Jx`Tywf8oTz7Jpmz*(aD5Vo(^9rT*b!GaW);2a-47~EeMOqMNv z!U#JD)cyWR)rqeCx)z8PUYl*}b!<(u3QAn1X+|5(&2-H;)Q#41!1nj|mEj*XXuix- zzQ4b}df63Ldgal=qXjus=TQiubSQI3;-@TniRW(JJc%bkDB63aBbKA2N~WjFYO2YvCXccpRQoR5g1Au}#bgf0c`2xra~<-_%DM!whL`foIgdoB^mS%o zHzDn68(KdszK8i&6L*L}!e?X!7~~O_LVDu+O7%}`(#;EtO&hLuxsTK;mkhQ1O}(0K zj+7)MSvh}*!z zYCC%yle#jVa=JlO z?}j-P>ep4srBKyylbi~x=US6nq4FB62#_x$-0Cp-N{nuvd%?M)jjw$#&n4{JbgO3jwIi4aPO608geDz$^#1AgdX(iK%eiu`&JFCmgr-$P~a;w9h5Ic*I|&pe*GUq<+iX;?)S1) zf`&C&y6RkHPhqHU#5|i~ICe#lG>x1Hn*W7RB9bf@iU^L9fvf_RqlYVG?FgI*CJ$GY zVt6}LROBhU6k)g=qhMPaVH5)YA@+rXPIsXHoz3uyq*tMqXcd{1F0DL_@${;C?>gS1 zYS${RnR5W8n6i!U8#;e4an@(3s-7d%mKSD_cR(TR*m1cZz2Svie9T6WIc z@uTy2 zL?S|Q!J|wmO6_9ORY}PZS}9?e8HcAVPM@kjJM0Ye&g&1{Tw-x5Gl^9L8Yhc+7T5Hp zFPHY8q&0mfFfMkK65!R`h?oC_d1K;QZ zqc#sIy|V5rau=gINx@^is`N?mMSdwn@)Y6}CIPT1?n9h~iUZJ6-CcI}^5333rDS$? zM|ey@E%6E>ia{5v?ZR;qoI{edaKX^>435Ld;V6jDMV5~FoQxpg!Yoa|lq+zCJ;AY= zCy4pqz5e0*<5tRs@5JI8eO%yE0 zU~elaRdf%JR}7d9C$rxZpX;g*({D&PH9q8DsKZlWrW5# z6pP`RVM1}k?d?<>t}U23=I$|6$QfQAI?CtnZpYv+orXrO0TIJq7yjuT$S?QP`8z(Q z=wY1`D^yAJ9A~?pcVB)=iUQgl8%?cjxObZvD&8~qcB~?Q#r`;VX}^G9mzgidQ}Ek~ z&OvQ%jp`A@_f&n`{{Pu~_x84pBwzUd^C|jxW?xEKiV~@dZDpK{EYY^cwxlD!{fLWZ8qG@#SmzjWhTbP&3T{CEJog}kjkdD`lTL-Axk zPWZ&%$>fMH8q#!3NWKN&aYnX|Ng|qHKJ_oHlaq}n{V?#^l_1k5H;vle8v9ZT?CP`9 zx!+~45y$aEa3xlE+3U%0IHUOZ6W}Zw{ChDi<*XC+>pafV&CFyZd!|$NH<}#?Y5neZ zXC#ZX--(lQb8T}{QxDP(`dXB^^vN#gT^{JfPJR5Y=x4qIH{OLY6<^sbNs1}HxI#l{ z!2l#{&JbbXmWdOF4wc`P(L5la>)(;Pk!bVE~Zb(h;O#!e{c5JxP*}q#b!L zN%)lJ?T0|zlohYeagb%BDwz&!y=0W>l7iW8>drgs9)$Cvqc33+{XveL_`jM#(q%=_ z1I*ohi=$&S?Pf*73>t-iHt6 zL?22=RjSCs2wO-Eg!-UywD!5X|MS7S?i%I00h^0kx|&hG3-o^Wp~tS+$W!U#cb^}QPid@)qlW5E{|56N? z9|o8n3-JY*DwW>XG|!yd;~&pI9rgC!bk9F@-|p@I^Zc}X)O~w=cDQ$TczjebT0)!0 zY|V+v^+%c;m`pqriHLke4@2LB5>hn8h718oMJVGGxU@Sx{DAilPu_J;&wJg|AG)XK zC#T&v-P7*Tes=*5g8}bD9pFX^!hzC06d(d(n;)Eg=$*gbJAkb>iRIQAmPJo25G1NJUKf)IXyl<`_SwDbawvw)7u5;lTk2?LwgMD z0I;LmtqpcP3Bf2qbyO{3Ceyi$G-DgBm#v*aHHinuM`!1UN4@Up*?ITl$=N^8-<&=t~K@?;G#h63MXqX*{p`^`CcG^LV<{lMob9z`!h1{N!br)wEHB)x*Qm^*` z=L^({gi@HQ2{<}F-#`9%a@y_nDka0ro<)RQu?9(XYajRaXLi*+Le4lpd)GZW|G2kb z>@WYu|NGQE{pb0|vrkKq<_PMUbkz`#6$cYk>7nc?tY3Yjlg3aQjzt2NOAv?kiRsZ= zoS$}kpFW-dMd$cwITA^%42QUtt~)b3?tQrKEZubVX)BxFTw)19F2_T5`euJ?d*gW@ zk~ae=yq(UR!L!5t_ua*1?{FwJhna1E=v}v$Z@M+V@$jT{Q! zoN-E=oE{#Z9-bZkPxpNP-QNDYy(M^99imAbhKSO~GfeOph>Q-9>h3}3I6eOG;q~7B z`|>lC9`7E#Jv{23f9#&UJ3cr+?Uj&O_TWM72jA7~dGF|;-jm%*+3!9_OIUIwmy&t- zw%aQ^zsnvzdEfmf{=LZad%dIfA}^KRbIKk(IzB4V;ONPNcjx=>y8G|XVV9kqqh5b< zdib&K3-g}+bhP*SL-+jbSibePd(=JMJ3B79SL%0=kWYta_~zUfPJ4UjC-3)r?emkp zgM-7PN=AkUd%X`obT;ced30RoDeCxmuX|GG>7QP1)}m4lr`M}~7$iea6>&*W6zb{2 z4Cspp{kSzq-TQQQT*VJ3$A?E}puH=zj8dt)mC~^A%BQ0xUV8V>*QbXikK_942y{$f zodjXF7DTGPlDwR=Fi?omeUrt!0^#t{S}MR?2M%D$Ian>3CfVG6oQQpF@k5Yi%1$_o zAWqo;v&gX_mlSC#5q23GE9fJeo(cbc$J0v{;*J;NfzInbOL&xmMqf(PSbm zH-Fk)%!rexiK&QRC6G<+V8@9b2IDkmFtq|k_A$gKB~)W+@8!&c>Gou*c4?x$ibJ5e zB+;nDE3EuuG8Xgj0(8mCk=J6!3OUA;h9rYn2NY*X9IB;N?e)bazYYL6V%`ci)Dkvm z4Vh<8t0$LEwR_hUbb~|8AZ194z{CfY(ZjEK5RwH&J(wyJf!av6&bnD(2n9%urj{k}$Px@L%_QjDrG zh4|qPO`ehFrTk1uqIVSoDMlgcSvnaZJSqc>lH9A7H`RDj)n_Jy)lLN;$TSW0ljCF^ zrpm!;d1HBUaqT{)5dZYE(h-~Q4)%%FQ60zZH*S+KP??PhWPI-YT>hLJlE>3a9g=VlO-TTk@%?G&4_*J5xuMl0=H1NnmS0 zGi#OgRx+@UrkYUBW|ZLOMn{%Q9-z1A4sN)nE$%~cTnIBo?}z&q zULB<@Jij=29w2jK_Q z8(fB`|EC^`BknJMD8kDRa42rw@1Y1QUUDd2iK!hR!+v90ve_qQ#hnpO&k^_K=~)^p z0zn}ZqDMg?^!GXalb-WvaPD97g!`FD&Q){{4FzQ?(RLP}iQBBJqLN;*XAm>7vjqw5 z^3O>U;-^b-OW)#)GS(lP+E@M9?LZVUK0nEZYx=MDPAK%Z`a=i;r)@X+0plr38|JAW z1U4nuoS$~oA8Q@ECF|AFA^%oF{%=+N+wJZjyn8REZx93v=u)m!F(5*s+!vSAei96d zITCo7(gl}7(D78my!>oRr6z#WfG+!T3*wk8Xou=HZ0@_{=EhojLj=kL7vyeE1bxHy z@N!K&=xIp5ewS@e2t7l83IV6g^W`7*p5Gz+cr8DVUG6CBGq+ zHPuBkNyySm1E@ADd;rh1z>p$wE`0|>X4$%(-8$8Lf-iD1sRjP3BwfOj@tZf(BYY>SsKHn)a;yW%~jHx$(TS^Kz%t-+sO`+!C8FUv7%+jhP3VGs6f5xzYgaB^q)T;}2#* z=s6MDGhmL!*?foKwZRw+dNtV2WNzoQnHriNAz;+g^(_8-a5kQ!rZpf`v-PjEk=N5; z)+lMPl?r{>NIs%pCERBHMOjcN{xL*^%F&#~!TCf?S1UBn6?f#l?#6jm7CVg$nX}3< zV0i?_NpKCPi*LYJ?A(W(!$2EPFp8+mDjr90ONA!}LX4RokEaH3n6lw8FTnLC3>`O$ z)9x%l-gp_Ki(@mlTU^?Fp0k_VZ7$~ov0K=SB={y;I+FNCMr{GWKLx|WFC#t>R9|aM zow;knhnaAo<={GAzHJSHxCExJpsSF}v%b#udFW3de4KF%BvC4(lUU&F{L0B@WyFDnYGPdFQ7A4FaNk>KE^OT#XfiK6{&r^jH{inD1_`9=@{ z@Y{Hz&sEQvnZu!-izTDDO!;sHRwv6-IW|Nd*$vs$c$5~4&kKM)_8}w;y0V(_C@BQ2 zw`bF_7+|7^2NxUM-IM1o2aA?@o*Z6r{r)6Mj2g!ixGStxf zI7Oytbf5TB4A{z~QqdymygHlFG^)MgD5|~GH<*aunye$cCBr(M&ft1E#u@nLfsHek&+^X3nL9fymUKkm+C2e74UqBZhMMQY!N%5L__8zH z+1wcpwzfC={)?@)|8lGSLTtb2Z2Rr!!_7@Tc1FvXT<%xnQUrH%s-ysSlE11aO%x9-`v+8o$n8{ z0vLPrKxd=X1_;i5SrOOK3-s}Ux;OrW0M`kgB20aD@uUV5K>`z+Qzn_TiKi2Mj0S{c zrE>Hqsc5ki3T;psx78=3IS~ z&(*m1IWNz?_c`iq<>im`zMO!b$y4@k#oL~Bce5^f6}P)8TaR`BsCBz@Pm%?$bx;%_ z_cq@2WJUKNGPgYvSMzRrWi0h1Z+qy#*YOyzWx;_@2OawAN%+#AB>of@qRs$#FQ#3D zMUm#Pzny7es>1@lv&1ODz&{&b`Dq&)PRCai#sFVYfJ7>M6$JtRQGu;pc4p;xV19xI zSt-Y@2kstUCOj4PgA(JZB7)xx>>oE*`LS8UP&7UJ*Ui_iQ@niD=%+%=vxZ2!09XJa9Yb_jv>OjB!i!#Lv5I5?w{{ zO;ojCo(dY9vn2I9 zRXI@~-@a+jqhNF~Y`G7G`EXk_c*0Z8G;&JP;->kD?{{zm5`{%Dub z%vyt`esxEoK2vkHc%0Of|T8||pZ~=bU>Q_&XQu>Xjf=Ypcdyx-Pb{%l$ zjpH=?NMgX~uB1dlnm_>P2^6{xoaToygs?kN_WE9A(Vz<{N5b-{qZu3W3QQ4YkKBlq zGHKlZ1-#vMyS1a-lFltuce?bAQ=44&5?9LGN1MlcOj1yVbODXU9_NCE2!FMx zT^xh;SC&rtSxA7Hb`>0aWwtN<3ei}pKWe3AWecq2y!jxMc3A`NK#ivR6C6CdtRd3? z^1qTG-({Wc9XAf3iIAC1_PGJ+&|nv$6zRs#bAkY_^n|@KlSd$(S9xey+fJn4YuQQ$ zoB)-eo|_%E;)q70ZosLunp@zqTTFX92lQD0(^Qo2Le*-C$)`DOb=Qosl3m{vM0naH z#BW{KMT>sA%i?WCo<~<=+G0JOZ*(P`0>bblO3vyc*j^(^dBbBX$A<^3-RiVnYylSb z=JwXhRvZ3rwdDD=ahlG0XQS}aprn(HjjfH=R!I-SFMD>o)hT)QwzIw6ercZHY_&Jq zt#%0sw_95;iqDnwKB#E2Q}SqOo14YqUsg`nraP#DrAKoCR2S5Wgoif4Nt6gbzKDW< zyFy$oJk$kNoMkr*Ojderx5aXf;kmu>;EMb`ayMR<>u6E#V8m^JG3(?+%5Q)cJHSLc zw7ErPOz(&z+%3vBq9Wd`den^f!AGI@%aL-qUOHu~bxN1pb`no6E^|9Fmzh0@f?p;A zY7`Ls-;{9_IOG?{xc_*RbMX^YqSOPd-CV&7ZwSBw)MzOq0{spf@k}HVU``$F-f3^I zM=z|Q=_U183iTBtUo`WCc+Ld`?3RW5fYb~;qpj}(g*UM zI0`N<(W0e_Sb;W!lMZ?pX=Qvc2xNpI&$1-wPjZ2Jw%~qVhmYkg_50oO%WECJhJ`7L zZ@?4<>^~sen2)9P#NwVR!TiQp{O`3%sY%^eo1|8vc@Q@!<;SLK(-N?!7?`$cvo$GZ z@}&DQ4`iWijkYl!pFQZFVgja&pW%!Wn-s?@r5&ufc6-<{m`GD-LALezA3we~r6jUA z4%1d3vLWVCLGsjkGW4Hsx1X;%T}E?4V1Hb&?cAhL^%6N_O)^pAHYqF&PnT1tk>Od(;mieUeJo+y+y9Hgk>b7f!uN+y&$iO1mv(FILH7gy_hr*9Y9D|O4*wS z-Fc4WL|+AurusdoxlA;`*Mvu{^E$LBd7&+inO{EMsp~z*0Z3IG|X90nXHqkXF2R@9G@?P!D*pePb`3?!46yt*9 zo4hj$-iPJTWpbK8;94lIMQHynU0x;~9mk^{aBFjL)ir69P<80^%|6@iY`k!*t|UW$ zO$>r8PLQROp%4EL&$Y7KY!&qq*_1^JtOYjM-s-gLGzib>28--$7T0vLs76C5=BDmx z!Giy6EJn}1TP@hkzpZHE`?59$BEdH1zFJ~uU){Bg=anbWsf&XSmIqZC+Sa0OE`>A~ z$X$QQui?1mXg?vqtdXmtOvj>0z8Df5s7C-&mI6~W0a(CjpA`Z*`XbFLi>P%ITtPTW zz;TV?)B0He7^mk1Y`9v!c+cS&Z?fz5P7Cg0&NDKM8OCI;;d_o6i~@$x?xh}vs0#Wr z>6IJt#4i&brYmmK)?KbfVFc6)sDxRK8=cD5SNfbzLcm$J+nseA$SctcZioEEdNCuZ zG`8f;mpN05F~XEl*Xgv{Rrl>I*6*&E2SA_Gxz^6t@ZWFNrCjT=hZ>=K=JTg1e}_T9 zhiJ|@K@EE58(o;V+E0T+*M7L^JS}cBNHm7q0}Z-*+0aKSM+C*=oo_E_h{* z!}9tUh5o5_R5|!T-i@wjc5yU4KFKc6_{9flw6yUJ^R7xg!FTLsE)ZV6%j5mm4=}L# zfO-2;O^+qwL_YS4+joCN^5M}ywJG82gMZU4;96jL`xP&^_6oo;7}ilg{SWEXsLVV> zB%5(2bLv#166i6A*#7=U*!;))uc>keV%jjTVQs&Lw`x@M!$`pcrUEa#o->&`Wf0?V zuxRpt%w`Vmq;zP~39X2NhTte6PZG=cg+8~T3Mmv@-2aGFdPv7x`AKFjx^%>j#;!@} zPYTF}P{Or9Q;rx#BG81x&!?ThjmNtX*&Y$0!cZmXCHfoNJ1&+Wsx)3fY3uoT3Wg2gIeVG&m?h=nCtaRDr>gx?q_EQwHB z051!!DReMmpG$Y!JZ1XOdFh;9T5Yk{kR_saVQPT0R1~AMk0|1$_p&KnmuX1^BQqh4 z@`6vJ9r3B&#nx3j2jYeN3MYdD-G!cYnpnrvsGEq&Wl)nQ4!VXxMUyb}^6Ph-~;Hxc2TDE-XjGVHxq-_Y9jm8Yf~9kj5v=0f9;RTd*j@eBv&fx>nY2N-)O= zN(|R!s%nbhJ&)YxH0itS@CVvO*>o&l{MRJaXkt_s1%`%el8M_)g_fjj5@`ztCN;t2 zr&vw}Wju#b#0gcO)@&8SMNy_7OH!(a+(e-`>|ue!p8#A#+r|U1ln! z#d|^O*l!FZUm1}Vx@C^m0tD5e4mnXl-b#O@APqa7M;UBQp=f&Mks+wYA;dsi!buU1gSzl*wf+U4om}rEdi;arr_cLh+RDqObz_W_XmenlYb}&06rJ{zU zBR6FdNM}n0WVT-t2B^Ni$%$T3qiV7SIC>jR*4b*Z6_F$eVVKVYg?vnrB&(DP0LcMX zrseuN3?wQHlgmXc*XhcZdIe(fJ_S+s0`<_9_RgvzD!9(mG>aK@1-lVa$&izd zH_~gM8fBQ=QmCNFd@H%jTP?deS%#go*jIUJua^s_5y>v2DHNF{6<)DM<6EZ>>bQs? zRo0e#7*csbyg(YSe>sV+aK20@|NV;5*JVAy%OV=+6kt0fOE7MpVP`DvN6T#jT~T1+jjOMca# zz6yjtk3h&PJnmK~R~wp)td~vZDnIzYu3}?vp^}Ho)tLo$b-888&S#(rdDy&qxdsF~ zfa%!Us+vzP*A5w#L|+UA#Rlx>bUL%S3o7@BiR`QD(QXKCo7Abw8dvt{St;|D!MQro z-X6t_2JVn_ufZnGYp#<>o=-BEPZ~}{M2q7F6-%7%p^agwn}uwBHNDMxlkb3pLAz00 zAl8B-Yc7K?Ryd@j5h8~~pi;`q&NOwj|M!^ zi_pYhlv&+wS7OI(+-`VQnlOedtC#DXuer%L5=u>yJZSr32$CZ|{0f2aywxs|2cNA~ zdj-M6KbP%y7_d6)FKO3TwUhBz=WF;6JxFlND2uaF|9x@dDa}yeKRcer6*QIMXAeHm@1Mj-AzbUvInw!& zcL&0EwTL;z46XRPKULseRfyQ{9eKyxIZXn7%r26}kcstdQRdAp{ z#oUNH!$vh??##m3QFnRu|AFJ~O1i5Td8Yy0B`l~DenQu=8F=pG{p?L6zu;9ibNE#K z%HU{yU)Nha$46{6Im=tTzRo_$U^1RgBcFLPFH^daSG5hP<&KVkzsz)(I-DH{bzthl zALwE>L4`!($8j)To7;)eNOD~U*O0tNm4$g2#{Nosr^z-}za@`(iT;&mQd!tRHo}K2^kET;|R-P zZwP6K?cwv6{`SlEw!hJ7KW_`+@ANzE&R~1HvoYA(+Iq3^^5y2>`CzBh;m`dozcb*Q zo#Boc4*14!$V=9ff(LbX1&6=-=F zoTdhfqFdHMq2?A1ds|qo`>Mcv-8%QRb)4f*+Mu4w`IlF9@*5?8AgX{k=U_C-Np3&o zpPi#()KoAQiHTDy^{`QKnnCU}E{@$>U>sXCGOjZCttzI?9>LQIZ>tIfSunn>wB0)e zxRo47ONY1>kFc^Jx3U9}!rY4QS40EZqgXyL=uUNh9x~#s-2eME`fb_hw<^`DBL1!5 zyY}5UwJ0u$fOCzM#R#|(8sa1ejf;Sdf0!6JHKMOEa3lmZGYQAQ02s_Vo{FNlbX1jJ zkcs6{Xv7gJs;wBoMgFL3I95v-4Q~YgrSPvL?5aUIqA?_56ko${^CGq;Nu)x^bl>rC zNaPV1Tbx`ejAj$-)<`WgV~uz>JKU|_>9uG8Sz(r*SP0qqc%c|F%h{&YORaDIn(GMT zdS=HO6(WM3Y6M!TU9e*N1^>^&V;GWbBGejbZ3?MDuKBrrJvw!sghke zCTK=w0j#2SxmtGjQJ;=cmRBr=!t5eT*4S0eqQ@G#s^@nX@-0vC9vF5mlQ@beX*kt} zAh-y^?L(#n8q8UBj>rH*I(0l5S43Fcbe001?@2|V^ zzIG)p;DheWVlAz*0<)!Odl`g&W!c)f0sXLJagRFnhNy0YRndVA04iEpo5|&IZ&e3u zI)x>8nodS!N5Np?u^2Txt9G=?4$$UdRg}bdUaX=#1Cjbk&eC}1wG&nU1|bS|0aTkrtA{yHtmW3C^+EYdx(pyI zkVYr1iw*E$Qj9qd(^z)*Q)_$UCG(+&A>>sQT74~i4nocA|$J_Hyf*%Vh~t!Uq*i?XbM%@bvvKrxz85b^|~F4pD!Hc^Z~9a(qDLv#3i4(=1jRQgX91yA|aw5!E*8MQ7XV1s74>)Vvl(S;#$p zAu=owl77KTyjVIAUxR9^I-J|2H_4jZ#q=h2tWxl1rSGA{lz#FbWjwa0v-yf?G16I2 z=~;T5x*UsgY05InR@Gx!?3y#E?26Ti_0BY*5$VLg1d-=8peAAO-5wN=^_s2-&5u~t z48ol~NgX6qKTZ;nj$Gk(PC+}_;Te3n_7IIjgQsp_<72 zJx4X1`+h!=KVY%u+|j0o?0j9fv4;}&=?3bkvB$9Lh#Kzj=bP6}MY({GYt zjXxAX@(PU6V@eLCn7n7F4pT0UeL$n1UbYiLXih>|giH>gG7kqE&IN0hbY{a{+xo2TU~b+G%=woR(p9RBdzewOtd`VP zSXE|}8Fj9~SB_Bz>-VOj<*EWYO-G+ncDBx)({!jSoIqmoyCY>=)|e9>B&DIO&~4#M zBH(Toy6fFRqQmuooz0h5?S`SMqGRAG z9RZ3*WAZG^S!bI-Y%1f~;YT#z4{-|Z2XqcGFk*EqkLNSf{vGU>TG zgvuw2q$=yEe1QI0(aX`a_qei^s`srpPw?YcTT9DAxyvMjBqAS8_ors-B;_t&kK(~3 zoTSQm+u7K9aeqARpk&@RQ{N9a*CFv9*m)5?F4x)Z_+*&#d~CAPvhO7{St%71ELJGS zhLM&{6<{lCKM%>tV>hX6E}&rK!hfA092cO zg;{y%PeRRlX4@k)U8q4Ul@%0R*nK_HPyJk8aDqhhE1t5E@#@Lm&+|RiWe$u zHKaa1w5di~YLrn%VWKDth78e>k~+;C`^aQG4k7Jnz9pt`x3X_sQcrg6G4!R)n)S^w zG_kV`GWl%?$R`EEMj7tO!j=?>ppnNPEUH4To6Wbja!+JEta`6G@evjLqWb&Bq9~ZD$E#PC(BajqbM<$1 zw|_+S{Y)9KXa))fWXLB9D00(RcPUFoqZm?`C|EqZ?aXPra`W=ChjQ6sS&mHDkhf#u zXF7JsNhgv@q;<`h^K#7!9J40z+EqfWdkNi0@Ny#WC55wU!AnWu{X0~Guz$U$=pwsG z&4HB>Mho7Tov9=3Zko|IE*7S=Gr}-##I#^RR!;&*wVR zW9|jb8CvxXjd=&ba2SYpA`C}7LX`&MzAkxmA=DsO z)PsA~`8oGnVP>j&uqLQRM3}P|R**V3rLAdt*0CM{ooT;U4)*D^Z0qkMvCAwO#eSPB zxQZmO-xg@%_oKHc-3seCOS0Vq;rad@E}bV;fB$*EAMzh$8S;jX+_6$&@4!LB_NB+y zF#mDQ&1HhZhMbY(S9Wk2o{js3VkpTe%vZ$Nu-Dsxisa`~iDps$_>KOT)I zD*Sha2q+;-zXg=J@2IIQBk}mX)+LacT2$4c`^$ufD;7EVyt1b0vzT&badGhw-_C`c zOBgJBah5hbDV9j}dkASsmy6=oSGiu3C=_W**!PG8pTB#Vo zUwG{-lqiSjWYh?0`?k{S`Ys3zf`N%7A)N~$sL&TV=1Dd!n7_oMxZZ3N2MS!k-e)%n zACIAQMS^JkpS^>3=W6=SuLN9AO_hn8o12!bmVrek2C<*6k9f4%+Q5I-b1%0pvr)K; zNhmP#01Oa`gHDD>IqnTqBd|EDn2O9Gt+@6Yge)Oz)U5S%3J6#QX~6(zC%=_nX!SN= zw!SH5tC{l=qg8p8cAVX3g%P||WnQvN*8){<%+5PG+T5ZLOgsGRULHz>&H@CN8MW$6 z-u)7slai;F5X-rL^v{14{mO*TZSXwCii=f8^9#*PGJm zH@`pN64ca-Yp#L)*j<&}$6x^fFOxUk-N*Ojzsn-yn}+M8xPPls{9iDtcCBhA`v zsP4Mw&{66vd_H*iJ{G=yi+6O1+ZSwoYj#R~D@9L2_ouNR;AP$3B3&7RJ+RG1Eobp$ zM7H~cdoA{yB4I?KisBmaNJ9D3Eah+g5a1B!2q$Ma3$puVd~0pyalR2$b_DMNykFkH zUAcb`NvtDgCEwD1%%bsaaVLda#g9|YT4X~1l^8>N=}GZincs$A2v zRNopFE~2ga`Si^`>uj|egAsf3Ts= z?aoe}hTu7DXxAdW&r=P-^;ZxWAzO^sgyO9~!`}aQ@ZYP?)*CEM z{B@YabDG0*|H;H%=sOR)C4rk&^fA z;;ZHuS>##p!Jx%{oWxm7aC=qHTPO%6JL(lX9tGLoTt6v*^_nd$(R;1^{Or4GbR8@Q zEDwoN=~og2<>c>!T{})d2_jy^BMHii)2V}zma&ggkq$qsI9<|HSxi(89*T{EQQ)T% zqg^dd|Nt0cslpD+HrLZh=f5XDgIqBw?*=@5bt)`Qh1}ocuZ0eZDz)Ol%ciATRs;$My8g zaPZggtS{gzZ@IRXrZmszN+;HKqStCpwYt9U&+LHp}U%)J$p~1Quy0bZ<*BW6#0~ zXR3bO+G`GXJ&5Bt5Gcoif;Wnk4qG{S{r=!hXH~VR)jQG%*&a(pNbWd9#m#53Syr_E z6oec6>{$hIxeRW_0x@`XUJPpQlRH!L1zNp=1t2 zkRcKe+$V>u4-I{e zgObmm4YK0553vEB)Lv9Yn%-n8x{(RDbU^wU-pq*?1C zzFvnv;G6Xi;)46r_1+17g^S5Uvi#r_%BEW5!EhDj-auqL2n*|qwSR!!FiZd?7s*Mp zTj^Q|Gt*>a7z7141p}~c`TSb&EG4ALiPH+)gn{X(f)t+K7YQF<20q(6IV^7W+3Lc$ ze>E6(mW>3Yw^tgZsWeQH%=QNS*JL|e@ZBZfZg(204uRR3OP3=sO;li=H#VPdZHuiJ ztyXK}#bEm-7Y#kcS@j6^tPF3XcuV1~#G{V$OaN?DTqN!815Aq#X8bvqH;|tf8-Hitp_NK;uCNwkiL` zNG}~1uYaS%u=qW#S1}Y|b|nMDRLaCzvzmd?HrQ8Pqa?Q^uM|LJ4^F)~ndxk8TBm=- z$)wK!b#ZkM@2|(}*W>l+9k2IQA;h#+^T@5P6|(TL`DkZlovWfX5l`lT$%PMC=Yxqz zclZh2hG~{SnecHcCWBb+JSr3_)3E<-Wnk+AA~kX=hz7WM6sn7sOSE4teA6X~&sR%DlQg z;-o_Jxw_Rl7RB;Vx)o!b3LT}Je|_DlNmeNnXq8_>d&>$1tBIA)_Kwo5`;+0)Dz*35 zU;C3`iw^%Ua>?T%vv_is(K9*O@x?P@W~OqjLLAC@!$s#ny@a|h;Xc)(TLR8Rix>2Q z!lmBa=FRmUaB2cF*~k4*jBGSxy$$BEK<{xlK$ch%Q3gW+!Ju-Evy&EM}u13Pw<;%=$g!>6NM#AHxgPFEzj+sg!GSlR2giZu86 z=A0XQe=;mw)tyVaQ5aFbI$e;i*>ByMI!i^Q2wldNumR^Qtd$pe1Z{^`HE$F|>~F7F z#Qw%c{MKtR6awXT1ID4Jlzm3eWz6~kPt6@oM6H|PDj17Fz%iBrKCQnA(o2#2SGV(D zFE;+`<>o&@X+2LbC&OVV{_+vqIfr&uOMS`cFJ19Q{Fbf37V}p1HCyIZ@`!c5`DW`y z3x^`LJs1f-sBguBeNOpMs9CVc9*AoZLikl{6#qL2L!wf~XR z-A$Q1jIxzYrAS80tC6%@lzj3p<5UF)t!y+|yU9AMpj||@wZ`QYtUJsJwHRsT3TLNW zv07@x^N0B(21U>=$zA^*XSnSqdtNbO*zE&|4@hEg63!T%DYCWIYHzeQn(VsWX|-P# z>TP`<1<|XGpII-H2d3OhQm6!xA5PNXTCBEmFM_n`MuXxj;zAtH zo@Qc3{MI@+?2yN@hXZ3iV2izJ9-ep7pp#LzJo_Y^Pue~7R$l7Y*65`9hp2fIgkix~ zQU-tVtEy7-#fHG3((;XObNj<;9EiBf4U2khK_HXA(%vZF7H)Sda2cA1eztK{XnRPhu?pFO%S!hj5XSPH!FHygQSGrKl*i5l)$B#h&Lf2lB{I3bdHY zQ7V5uPrZJ*egA3j2xqS_;r~+*Wt$xwStXN5P6EpE48vDjM5R@_qx?VK0;T_WI79#g z`b5}K^EpnkwIo^1{R(`r)(PlecmVy{1L!*g=r1tg{I8%E#N69*Sx<|8}NPgv+x|zFVPociCA}((}DJb%1Ic=?wygl2Tb# z3pUldN`6828r-gfMB-BngTzAmRu1?^Xse0xaR4gKtCt&+`py6%@vpJL>k@Uq+^8%1#)p5?M z&hsBJToA*zQR9c8iok|m^WKCpSBI>$AK+IzTZ)FvvWV#2rR~H9eb=u1CvOfzXeo#; z*2Xa;iI606tLaHVU1_r&r)Zx)tyD8!ZNy;EfxN- zL!PI-S%dT+V30F(zM1mxKi1=dEAb>8E;rDda_ctTYr)S)soW^83_sYxJNv^CxK*kJu4P{*lN;($abqXJfjG zVr99ygZ-5q?Gnzym)~jRoNvDDZ*I-bDl*>BBILC(P0&!S<8iq-=Bilb`%HRyG@@nY z!(CS&`MolEz8>sf5BA^rV4ro^%{zqiSxD9z)XJiIatG})`84%TS-0aWF>SL~R;LvQ zQe~P=d+{UmZs(?^yHkg5=OC>dL}&5SaH%5@2`xQHiU&yk;IK;NIwwXhveVpiPgAZz zJgjT(l~wfGzOfE8p7yLuqT9TN2ddG2nvO3Mo{H~PPEq+~H3zNtcgen(@6~QtKN)%BOhIq3 z7Hj`3J|(CvF;ES)Ttp)*^QkKps%KFO8)Id@AhiX_=|B#-No(?{18TJpxdiyQSMq+d zXkk!%?@m=g-HM=|TqV!I7CJ>hTkP1N`n!~&k=r}%?VX>z-|w~0kN3JK=O=py2Zu** z3ulBX6M5R(yPr~#^~*%&aSFG}g$%tXIdH|@k&ZO@Ew_7rQybQ(pUPlYZrNkM)l3YO z43w7ff6IIa>XoUvYWV&>d0EcOe+n-@X*O=R+Ephdy(RhPX*00}UE5-JXJ$QJvv}Fw z;-##d!#ZA+qwUw{GPZv9_m|Q&C8Tq#IUvAQ%v6_&s@X@Y1hd%Z9uD^U{4?uV|MT-t zCF{(RO3oSbNQ^TV25~OmG=Mn=Ord`l3d>{Q`w$J zY|KpKF~17MbgjGJIa=FB*LkAp+QR5V<2!aH?Hj^X~Q5Ir#jtOjEZ^JXT9RLR!PM};j zOU39~Bx@u7uQ*|eAX^m1sS%K=RT2ZiZ*eYUJPV-NvtMNy?=RJ}@Fp1J9JJYQY@raBv)O|h!Q&VbUVS^#HJcwhJQz3iZ(6Mwd@2VIZ|j2RRc7S5JBlDr?rBF+V`fJk^!8vM9rX6rdhhH%+jkXA za{E;5rAwY(T0*HwiK`Ip**GNvI@>!9uf^WE4`OU1gjOpT zfZCbSQ*~)syU5ekgA|d~==FwZa$Q}CX=U9T>)>L=!-!QKNa}~eSM|=R0vXh+@U5yS z<|OEB?_9Orck$73`CrktSw}iQWCIp@JWA3gvqiz2Hf`>pR)Of2PqGl&bbimxUA_OT z8CdRp9MvPg>1>ao2>E%!|Yqk zyz0p)6|NqzX0i@QCjs@!U4WmhC#@=F5UJubi&@QM%8FeUB?SMWz^zf;_xr`m`+mR6 zo`sve6|(x$FTMaSSrDg_BR zRx)T&@d1{lSc|6ZM9rUgGpny^?Iv=nfKmpGvnQNp6CR~Qkt7CWpXy~{Y4=%m*XpZN z)jAYuOz!d7nt2vCXCKCkpT+a*1K+(Cs-;Ui8*#~MsLSkQ_Yf>An`-?&yJ~9F>>)VF z-izrQ{5-#!>OS3fWaT%zVvbZ;3)SO!YFN^43AwY8+B?DyJ|JfTb~bQ3a_Dqgw=;R`RR9U@k@_Tc!z2h9Scp5ub zWqCQE;9wqk-P6t4I42&umH$*kW*jN%NFm=hKQ+$E2|wM>ZPk;tGPqN77$ zx>|xb;!w9rWmub-KJNQ5#(jp<1%*y6H6%aG2hvE4d~!`8Zuc`PqUOce>}FJ5RA&k* zOG7W#b~%a7-2Bw8L+y6vYC`3ss@AU-SFh&1F<;adPFCv#U+8SL8-46!*1}sU>TESj zum5hP%YQ!|?O|24KO!U5)z{{*+)Vx7szM%_>p(Rt>btFa5u-vO7o$?WD`VI~Gxx1D z>Qd|_^I=tEucg*6Ryti0X6MFLynTO~RY|mpUCUZoTFts^JZkB!QmKC2wbzl`%7Q4; zNdYbPX-wWy4WI3VA-ZMV9j%ktk#;(SonvibG}&532ciKMY6(iHyx;BjL@TeC3vbh4 zA>vxsp^fJGHfb_f%j(g}%LZ4CS|x4s9Mqpmge&+SYD((ayR$36*#8wBcXtD5+rMgZ zNf$uP2s_KntS88-YzaTi0X+j*&lQ{*gxe?K6l>5D3OHn1B?3+ZgqDH|7I>9f0<|es ztIkwO`!yRWU;E}uVd*u!x;}a+_!S`G;|XgpNswgq>J8eIs9Z24*JENDWvyLI06{vA z^p%P%T+$*1C;24EaD9fR1TRe%^k~)1!eWflP#~)_h5=Mxnq-$E%2cslKaQ^gs@(Y5 z=VRWdXn{!*rfyC0n@!9BJUd-CkFCLD>jgY%kE;SF5)=e02ZNF%S0;6rCe5u)s*MCX zx)__GLdMcIZ5Q#f>Ry<pK8V6G=WCReO+B*i*ODN%zMm_;G1tS zwGXG?&R(Nf6c=O+S-=GuOY=dLBdqKo)vZaSPjaF;WrGRcz7Mf6$yj!`(U`k5_VA%1nrJqzUfS9)cglNkH$~p!cct#>zOnAbh3^9!)f#>NY zNdSv1h%U|<7`jxez`oeh8X&{B*gjBTIcE43Xf6=WMWznbqSYX_huy12fr(1?@&YO6rbPPdQto7pB8KUr$yTC?pHoqb&mqYMM+N5(XtpU zlBFs#=vRY%+kaPiKU3+gUISlJ1_N;mFla#r#)1RNdE7P6lq=?_|Jg1+)d+GmzWS_2 zB4=-J;mHBdFCu~k5$gw8T1p;P<(Q-dr{{vfmo!N?W4I#5kye1ETvAD(8@Esbuw6bG zlo=ymUnG&Ww|CO({YOnfN#8cRk3^dC3n8`1(yky9c2DWY-_K?G>edOVv_EAZ-@Yjy z)#zf_ez#b69|4PxhlIx?40;095C#pPi}i5`ru79sB?0Q3HRycvk3irX2jr1z+XmGV+owuwS0aE~&9M4*po; z@y^G?pL7}ZHDKvgRA1G(Q2a5^ja2vx9UJbY@E*3upONpZi}2SODx0C7zB19=Df-Go zvnNPS4uEWt4eW1cZ9NIvn)X_v|DScLek+}(U3S(kH=3PwDjbt0sF}c>csd=81Z1V5 z2Xf4VMCo|ag$3jFTA+zH;eXandc7v-9!=KW*GY?AvVAsL7Yv_GxpkVzALKnbc!$<& zlUS`YSj+qz%q#E$*`$igNZ=+;aIxhhP>mKba-`iJ6!jznlzoj1A@gAYbuUY$Gr@*( zP;E;02sjfU)5%5(Gg8}&Qc(@p}pcS;NHp<<~XVK6yjvSDcbX;L6~xy!mgJySb859I;nf(6k^Re;Qo3ii zPODj~dF24uB^Zs)_70(H*iV=>-erv}9!nQ)IhAv&c(~D3%=^_^AZvW=i)XxL;qV;}o*{G^D zQO5219FYecc)UuGfr~~tbX_&cgY}(;ttuXTYO?9y@4kHmlE9f(ha`E%J}5~*OO07l zs=#B+k|b%~EGd%e&yr0^83p+Zs_8c8FPUHK9Dc3ILMfrA$&?eTbdS<)Vk zs})5Sfd1@2w)$VqWGv+KTh`x~Yv!xJZef3&s^VGdhsziATwiDJ2*(Cf8&l+)i7a$C z!$UXID|k$~wV}wc3cXcCS7#hr1$3#dEu^AnG4pgltW1#8qwv_en@O(SiOP9bO|B(8 zaQ}})b{P){Rq8svqAdv9*#ji&);NhrK^hFFu<^x!U5g~ekp!8G0QU{-+Y@|RAYKNf z+REfXU3|j=&B6g$Ly#3F%2MP0AYR6M^)Rxz)kv)<8Kqh>-Pfb2dfj;(kGURs?QMx6=q8%wNtgFEkh{8MpV)rCs~`7?ZTq`A zf1lXyzpKaii3x#P!}+7gg1h*zpOO%`i{tw#?f$!X%b(J=zl)3gDed>U`51y5;rz;%p7Gd(V1jF6JQl6GjxLYjC(-H`G3xIiA!l1@j{)mF$?$J3< zNfg{Yq~|FKgS*E8Jtc8)_u!$YBoJzj<_{?n?iAVdq{P9U!l9m&D7aG$)sqqfcM80E zQX*jfNS@I4N38fUAYSCgWh2n4p`V}Yu!-|?w=hnr>yzcY9`(e;>MoP<7JqXQJPP~D zg%T-priJqH-M5c6oE%@?$8hq+KOSW`Gz4=dQw=XrE zr@PG;8_tv8-%AbWX>9BzGVdQ^yE=YHX9DZ`!pkV{m9fF?l@BC>)!RZ=%KGrr&?P;mh$F)hOfU<|_;3W{3=3HV?TK+in1 zzzmqrffU(O9!BJFD9hSwR0vIekU}fh0YaQO1Dm8+Tf9HHZea0k!3X0w4vVk}oz_NG zNnv0Rv-|X_Sp{%mq08effSW2S5bLL|WN5_)D1!bQ>jf8)UaLbWiY>o1b8Ub7k2H>c z6n*ur4#=>#oQUfno}}Rv7==XrAh((*J#aL8%Ub_*Wno$u`!TgpY%={k0?HcyL^id@OZo6qgCeYWK zq1>-4#e!bq*<|EPy8ow*zm5bYOfo%DHHGMYJQ`0jDMSx~;V=+u??f1mcqH+rSf8ha ze8ycEBb1>w(vjxe*Ku}9+i(P+MIfF?SA(*no`IKpFQ#XJB-dm&mw|stPxl3jBP=gT zh(v4!ww+7bs=_&h{k&?U4X}UN{fgGo zf32u*UmAbVHtI z0)!-|^NA$*8m*m2uxl+6`cS+TAg*rUEQ5BTBhJzhpmQaRkK##`sXi2aD}Q^%wm-gJ zg&wj7z|!$S5KbAt=0V8&p=c=~h{bdyRsG-s)*?_xOPVDD%EkkxRs%i)Fj!e7t5Sl4 zD9r>PwCFf7=e45IIfIEhd~8F3IV#qFA^z(h~$jY^n#R!%j2z|S&Q^|Us23PBt|Q8E-v*gAbgQZSB+yjm22S0;z|Tf6ul}dE{fmF| z>XkEk2`I|i8?3*{wqCN$4tw#O4PUU$HWM#co3pJ=_TmL=w;6A<;gIz?+i1fBzF__q z>p%al?#xhEEnt8ZBCW|9^haYA{v>u-Ekg>_GPl!iJx7__DaE@(5rWmgqzVsOsZN}* z3VK;JyFQ)0S$o0yVi+fa^#v>i&@Bcn0uKcNE)vu^@o3gH#!zacK_c}#ZWa zBG3NMk0;?k!Exf@=B&R52ipJ-b9Dm|0icC4?@Zig#6$^QFzhK^l^C8p)wdQkNT*5c z2KC9klS3^TbMyE)o@C=mrcf(iH7><%<7f6+eev_kWtNT8-Su_Y$^S}QadNRfi2ZaO zZ7tc_b*Iz1UFYLqU9#q7HVXejf2V6a8m#%3JmG#Ok~KA<=_=I_H(;fiE*B>TQgT(m z3?io$bU1xG3?iPO8rEd)$i7!Up2d20VgI_8x;uBX%bwBLpHlbFOJ$AnJqGNCH!dm<-?Dx+6~(W_R9A(ka^kjL z|LvUC4}X~1cyK+p?R-U8Gs5bjfvy4>H3|ioa9_(wfai+F<+28YL9O60|mB(9Zzc7}s;bK?KeO3}QhR7|=?2RNm3j{ItLb&DJO# zPstvsweoV9uxRDY!7sa(0I4w0pGu2-5E0@rOb+kI6EIzo)y?5k{a!B~DI!wFeP4_- zcFmIjm0USq!m*A9<&&Sb*z2j9rlx9_tTCj%T!_qUR5)NI4)6_KKD0WjrW#9{rpo4I z3W-WGTkI?*ff5Y$=&a>|`_8pqD>W({5HyL;yG=GV^s=W{Pr?Q(Ci0YnMPIY1Ur8%Z zG?kOcbl7x&m6g(@j^g4?c-t~GDIEf2(s6PW3@k~O6a^3*_rFX;GOYvX>PO zTWwEL;Q(2+zbkGhiyz;;KX@ax#sKa?xIkzOB;GOidTIbR)#;mkw*6w~<^R$JQ$pPb zS0lLNr98~knnc6c!&@NgIf(a6#z|CdJeUfyJ2FnTMY76zGI3P8tSySuZsr z+Su9IO{`6*>8^y*M%tvk6Rk0*_eKigJNEral7gWnlx9(-UtR%LIJKczBo&!f-*rLV z+%se$Z%N{PU!>`90_JT4$ZeB@@2NJ8NfotNp^aO34~p1l%L-&LbblLs8*0s8bynlH$7;1U9AlyE@ zyQ0h%P1d*)Q}_p%9R39kZ!{TP?FdxftYaQYJ{aO7t2Ajak>8ph?YpFX$+4PiWpNKB zzzSYYR#(48boxeTtG&G=I;~b~d-G*`XM3}uhdT3SSt`S%wFEddZ#a<_r~J(+xEkT( zwA@!>3Y%rbGm$`5bdANXE&Kh6w#5BgB=MS~XzEsBerdmOb}9E3XWOm&Ma)|=lDae+2GX`0+1c`@R*!DupK z99&CyG*TULaJ+T4w>_2xBWaVCx>GzPdSFb0iEm7Isyw(_SuHbHMC+o(JYsUqCyKt5 z?QE?}(JXt5vsG*j46+hx8P0enB#_FMjMdD_P(8 z1vr@U%dUs8&gH+*(kQjBE@*(+i@VI0i}lDA1!;%QG;d` z*(=>-o#SuSq3qsIvaiS2*W>Gn9baw*w8|sw>Jg8yRp(sF8yS1TpCsa);NwpzzYw$S za9N!35LeBo026$fT?#%X>z7?L%!(WG*4F6JHF)$@eDz1qFNNvw;0s63RQ3(S;WOiNVV1Zk{9a413C>K|K2O>F{8# zRot>`!6<_f2t>igB0(ctkI7=?F$rwJiJ1^7|FcPwfnNILayERbLz!+#47W-{t{V#72q##7QQI^Ex z=|21-mo=FP&t65l&A%&qoj2rRD!kIgE@}FE9U@a@;76Yc41v93-d}$u>Gx%==3ibx zNw(`N%31piYVTIN(=jUJ&CN|K8TxBt5P(e?^u=W8!~er`t?V{i)o}`2NFE(VNNA8+ zYAemM4&5N-=py0c%fM&jR7?i3Bt!0I`D&b$nFMzzIA&``a7?0kdc|1p3XHzGi?rr9 z#82BBFZVBne>HbM=oN49@P<#*M(L8L6Fi8%-(}C}F?3MLSMl#iT#MvcrM%JI0Q;48 zaTA0CpC^O#`&?YwQmsLa$bg4GF4HKoez{nmgjw)`_r-lT49pb@Y`Hh-58@FIqC(RJ zS=x8~TtJPv-G19(z7#VA|T3^arQ&$OSvn3gJo>?n@1oJGS7%$m@O*Ux^5LtuLR}dI}6U9_qL4mLWv0JrnZ(DqSEY@VjWbBuB%L7J$lywwZ7`nE zZWzaN$-|+{N;1Cm5{jD@>r3J0cC(!IMFySwmvP{W7W)w$II2ykg*qAWemFJ4le5d< z0$g$-7@>d)&EJ8;fOPDK&C)#p(=p~#W%7vtx)>Gz4Ebavlbz$e;#Hci8z*tMz^ZD*OBYF9z&mL8IJe8wN!wm z1Jpo_D}~js=rC=uF884zbd~_yT?CQC(P&#W;cyUD8w{t~YZye@1zb5K${oS`n9J0D z9L6MvG5i*-Cp=AKKS0v8Sr=)m8hV!}VIUHv6=Phqx&#H0A18_M@n)K)lM$w0@Jt0F z^PxcI9EU-Mb8R=Q<3f0bRAe`?33Owr_+* zv=|(YVJ_Su|L7ebDSi%v41}Mv<=?~!15e2fPX;J3coy_AD!-{2OUbshthE$5H;Ae^ z3a2s>pw#jNO^zHKD~yl&!NnxVrf{hXlEE6>3Z@L>C(}!eHARak>~1k|)-7h2RLdK= zV;rYx047P=)}$y`$lUspZ7BJDB`fs-? zZZi?3M)RK`5XtZ*(9o9`it=7D5GgufD6|H}A-+Y@5LeUPBSO6?gNT#}v&Er&LK*U! zwivW!U%usPF_>#{xjnZy;dug!+Y={i(Jg5=J7;$;wk7R`=k3l#wq%aI=Izc0-jc9C z_Hd;Z+l~?AU`J;Ik?|n3qJP)~43+6zwPPVFuf!DXpNhuMKhM;Pf;62#z$s}Nfi!{3 z;|Lk*-YBE4YUyf{D%(!sW&|r2X~~0>y6dPtI#;TK^q2KWw=U~|w~(^{)QvJV*|K(W z@%=JESr*)k^Fn4qcuH|mJbKVQHTfF%skbNmrigt}rn95t)N+2*)y{kNiaG8?lh;l*mGmHiuIY5C?3&HXv;@fYMcyzz?VY5wORb}f$$;Fv>z%${=q|8#P zJDpa0qc+*l+%ALvtx5PK%7XCGX7(&za9-z;_b3y47MD#c8h?`sgqp8Vyo&9*UacG; zx-=l(R$$gwPT{poD=N|$bgK}+6%vuARq{ju4K$=)-cW(zXs%Ln9}X$-tbq@$Auak1 zLa(ria7>)?iWo?B%3_FM&Lv-K3UxV!P$g&VV!6@l0ZZo) z1&mb_?@(Adj(Nn>LSlL!jKMkXX*h*xx98eS^WDabF0GO!w)?_oTvMIuyvYQxU{JW2 zse!_%XBd)dNelLOnQWnwMLe7`udG|SJ(_u4E6DU3lzaDm*mhlLcLiHF$$iE%c@p?n zf6Kcao9vk!-?Q&l7gDSj-szWMMn&__>@~01N>c{?NIq1nggot9A#~;kieDYbh)?QE z9Hb1~azCRMDGsU0ykQ)-1SOTX{CMQ8I>zq=R)(5TTSGfZbravX4Yaf|UJoT_NFMVf zNWrj&{uG{ywIE7ij{@r{i;*0JGi;)ShiNSHe(i>Jc!~@%g*U*p!hAjsGM!)aA0~ni zj(W-}j209`6$)TsrIf;m5i&_&^g`!F`$e7T1$d647gnCVJ3BjJ$JZiZXCHdcR{xN4 zUQJZNI`UP-7ezdG_a$0@lqjQ(*DSeFTZGVdcHWpF_}|58wqj?|I>3ZEiT}V-{_sR; z0Bq&(KETy=xYS zCo92NSGl|!1LdwcH-O&;_8lD?Eax5*@W8_3EqW^>lCjMd-Ach?ln2+U$NZN0sLW(k za%|+~WdWMA?n+ZAw*g*adsVIErovzru9R2BtQDn_NZTGuGae1VE{(QkZJ>hb$cH!K zsVclIhDWU&!kZp#S}SWeRFJY69`h&A!l&dVlLq_USOTpLp*NO8+ksL^ zWcV+o_~3R#>jf>4Pa9Q&S1mkFy|OQ(eJS88_ zj7f(7Xn^x0muCDVG19y#U8m59N~z-%Dnehbt;r|}P#;$0cdWh2)>%g; z2;!X+-@~8Fk_~nDd@zt%jq003j68;0P-NgQkV#JlPiYt@zOWEjRlAA!WfCL;GyIy2 z?%PG!#5@|DI~x_`fGUP=%v5BB8A^E;q{FEVdF#g!QAcy-(bNA0M6*}0l?+ZK_K$a6 zmk4?7acI$N1v0RFy;QRnQFEwi-;ow|Im?ry8pS!1{*(pC+VomFj6pl5RhudTu`m>Z zr?rS@-yvI~dm8kLgbxBgbNg4VO4h=&$Q`FOLoQp<$9JFf&}8i5dvRYaB5BMdZg><0na#`K1HZu zJ0(XmUy#~#@-j+6D#d;#GDC9o=tvjJ&_EK`wlY{89GT3K&-CB}&_zels*R3ZmV5G| zkPC}}wPz~Ab_KAIf-GHCcSu?fJCXDM*ypVUM`ImHE6|osI-HX)k3E#9$~#H&6MvjQ zm#_NESN-Ka^cMteuur@)$b_1&HtVP$tGkZL<$jvBm-@lzUoAhl3(&RFT3lwXD1&3w zae*HLz|dbi<^2Fm+i{;muyUF~;&l>0<^}|~Lo_lqo5jkW=NRaIRApv#c=QHa0qB!e zs9R#Xljc55RZ|HrQ}C(4E+%uzI3{;F!_<6;e9tJ4%jn_qxPGb0)rB{%t3iix-7oV#7BISCy)t#{vm-ky#&kNhH zu5P|$4U|9Bx@u1+oq5{Fsr$ub3Z+#-3ZH@r)AA^THq(@Hn7xfwXPbTVjYgQIjp5DZ zBb2?m+Y)}VkX-W%n)eJ?tMMV`l%0agDJ+4AE`msqph{x`pygqx#fhRVg;YEVr_`S! z@;{Bij|-a1_hg7QOYhxG+rJu54*O?Tw%VL z*FAcBc+@@r*gbo9d~m+^;R7JjDSb>4;k2Mavj-CyA0{lk-Y-P7J8 zq#wTR_Rbc03d5@EfvOlaJRb_Q2_gfhXJPp|Nm$2O}E=P(nLZ3)>A~QsxLqd2ri;% z3AUt5Q&gF4No13BmAiF)hy)NIvzW+4WhO|WCC-_5m^Yj!ne#2NW+WCavQ#Dd9E;41 zjP;9eU$|`DmF$_U-jreHub98^nj}swoPe95VKHLm%{3Y)airYX;O_iQ_QWm~z=8N{ zOtf^B$E6X0Wp7o*oh6b&zCe7PJE3Y(4ioCWWswcvZ>2P1U41TXd!!#vw583=h8W!A zY?Aloi>B$bBTiO2;$+cnS1@BbE+)M)2@ykkRh*%O3isd#9cymK_=I-7I+4^rJjQa? zNkPdI<$O`eC@(3e2cOUE0w-A7#7qpToA~26yy`V>ipzJ_ByY60K#ySWg1vt9ml}iQ zq2F5)2O7-n0~OCj)l6QInDnQ=$mwfz;ehHNf4{oGBuL|ne(@B4%cCo*>oLBFA67pF zH3NLe9y9bY8vE%hED{&^j`Hz6H@vqHl!yt}_ptgLGHL!4mqpF1U*xp%MyBD;z^|h6 zaFRl~l2A9~!ccjvntN;8Q3){iP0ZAD^HhAQIELV7Pz`I&r{<~mEyP|Ab|?8IoJ6p9 z63pcpcKB^Nlhh-nz3K$Y^)1TVafjg(jP6@vC(jYD(>a1HP-Ji9&U8zl@Xac%U|TwOiNAF zd3dW$_(e|tBGdcW;F>DhH7qFUo~Nvf8Bxeii+AUDhGvyykhiAj&u@qQjzCa9wak>vq?4?inoU zdg{dSTH&CwD2QfP7ws_Gi0eRo=L9RsZ z*IuzfJ>Y`lE6X!N7~%ykX>Y?DtNJ*A#JI&=w?y2QZP9(5WKsEellw$x9elLCr5@!H z6~t6JasF&)RNg6TH!=bH7#9-Re$smKc)L=jU}>nSR|W5Vz|>hkR(7Q&?ClVrguN9n zYIVg60iVuq?`dD>=e8FrA^x?WyH?u5fK|>}}4)PBjtWHEumeM*O#$q6yx=H*Uz5XXhW$uR5iKm9N^0EHcFs zz{yQtqprzo?H0YXib+nfAZ)kg56MhJn^8Hi5>Z(~5w(IbJXg9uw@OoX0pU}vbyGyP z(zTPRY@BB!D5q`;$`)C2sYGn>$o$dr<#{M7wNWv1SbR{4jjzI825W+K<)C&>}#XQ zzJGHxYttp^tsAEL0H?ZqhwB2y;enh=1tSo2Ur3}_wudBytTDp+XF#|hobqWEJO0h@ zqzf+OUCyOQ1yrqKmr!o`$r=^Lzt%fjRZxLnu_eWK+4&BDy?yH|6n_IW>+vbxe z8_(c(B%qDowzi%^Ry%!VD|2^|&D~-bqf!a6viFNyXiq|K)E))j;eLhQKmpwFo5P=e zdG&hpmdHlKyM(dS7021!<+3`w!0>W^3w&>*J}QCVyVLQG)uQ;QSzT^BTX)o(s#?MYo-@n(_r>SgtU@D-t<@24rq0OQ4`eSZ-eQU z$KIaq!^YPdM`4}$8R(W8AS*}m)=fAfv_>w+3{jOx;DvAk^Ux1uqp$5D{<=Ss zX7ok3WwWXj*0l&m!s4W16v8zd>t8;8x>f)3$wn3XEV(+^ObU;;mvYdMRG&5-LKFBn=WI5{a(p4D5FFf9MN!ymm>IDOkC=&mE=e8YF}unY z+UQ%&AkpIbR+X(LXm5gEIV|Ajd>}dQOSCRIYgmBEk9F8WWGPJH#Jz=SwMrKgpapoX z`{4k;23%@DwQ_Y_W-@fMUZHqsn8|9R=}BeL-VvnseQ)8OkBw6LyBP|-T4R2XV48x zmG)M_<2+S@%^Pa(;~L&jxs6BY%sghT9gIAO*{kws+TY4uAbh_9IUFC z%+~<(6Fq^l|bx34(wAUqbEaf+!+-H(JVVVYGbX+1!Rj5&6rPu zl}VN|V*@e?>wvz=3;N9x$c>NtOOhBg=*&ZyONbVHeZOR}qAFBK%g4gM(Av|2DYEC0 z#|r1L?=MfX0Ee#0QjShqN>~ih*dj!YaD$@COaaG<1E=X~#|9+_XnngD1Qzys_CyoQ z`^phax~@0`<64_>E1~1YP9YTu@0(n5Z;a~V81**H;yl#2D1-P}*~7US9Evr)et`d+ zVbLWkSoAW=h03H2VX)bd+hEw0N`2$y`{ed<3YBQQY&Kasg6d>vvIF(Bt!apt;>2lL zm%97?c?!2NIr1@z6?=^^j-7K2(n=jn+ec`NM<;=7Hl@3*$sA3xc6vi;rq#*?iL zcz-Xm@qQ*n8Rg%tuji9AmHEy4!Nsf#{qGm>WACZ`yZwXw3v&?&p9l+G1+ymaS}6bi zudfb~Xq;gQv#ft1k$z#1-EQ~q#RICj03eS2+S%gpLE{H*&P4%aeu=5d2_i|^d5j%5 z80DPG}Sso)6;#5KY!%*_RQ3ynRDyK z>7co_vH5t58mz5}!#qyQq9ZD!the#M4mM|yd4PmcO7XrxZrs%9JB!QnNw3|{My$@k zf7W_Q)?2&W+-!eXOX415vcDHA4}hln2pHcg)T^@@?$E+8n<@TUd8t|L}6#N^S)+swRQ7E92Qk&CE1@iqk>0#vSxFqcWN`Rh`x{+)9E;x`;2O z$txUgI2_Ea#D;k<2uG-z6o4skHztGec4dpHty-Nv>j`c5dS;zp1Od4br0h20K1TtA*awk6-YO^BL~td7ABgfOL&Oqf`Mn?*g^- z#o?kuZb3NpV`|xX3!GaK5a||%b`e4%5Yo0Eae!$tA;)MT>l?oQ=3ZdafNH|YUD`;^#qXk`kR z#Xj721o#H?(xn_znCG$>XXI_(MRc?a)r~VK9ZF@H<58SMxufAwtcvc3rs@}SV{VN8 zAReKwI~UK<7v38Zc?J7}kEB*h#I<;CeeJcH#ln4Lj7qFrOZR6+T9n12)_2EdQGeD% z*4D%uP)M~Xt;jT+h^vUTO9`f1g1x5MS{uN7qE7b*YyZ`+ZV9!=`Y|aTR5jC`%P6Mg zm+FbhWM>tXBqS(y$};Mot9Vkv12U&lU3w$Cf_RR$IN*web+sJrGxKSnsR#P9gD0cZ zr+h*ki-oa^fl?1Y%os^i0Ea-|#dsEK-b?$@xR{^?5YJG{FKSX)=hMI1@8p&Cu_(wM z;UIQEoXUljPzswM?G;{YNFi}cUZJDvRhAD_Xd2>joqvvJSvsO*4rEHXV08N z#XQ@*872v^&6U=dFqTQ8G{<==6PVH8GpO%PS#KZl`vak-pTrV*+oa#&7k< zU6ZD$ghcZ#k-_gQQenALVcEGU88K`vmK7kFeA`89il-bxCO zDBo_q?qo_^2H{p|cW>v_tE2sQzaH;(?F8Lfzdy-4HIud|COu&Bj%VoPy{AWw9|Fzm z)gHl7LKWR;>DH-MDyk?{Rqu>aE1=ajz$kt=PD!<|3ZF-OL!5JYo#oc$DflMq zw3|tydN<5{3ryW0>L`yl;`2=g&bm8$Vj&4mH{RX*Y3J2ztSmhPzXY>&+Jvck3dB=) zY(-4%j#l=dA7K?`N+;yd$ueVP6%dDnBNCA~g0<4LBm_xYb>U{Uok)YY#SB6NXa@qO z*SoVw4m(F6%~xpG?#>dAXk0CmFte}-VROij8IU)IQ8;%DvLQ;QFda-vT~KXYS;`j1 z*BG@UGm|LXAR{r*_FS`VigU9tb?o3&f}=VZJjV5*aTrCv@C-D!OJ?VSGyYqHYx}G# z%Bn;(w3+8oJ{nFEoqyh^-IGENCrRB@cUbQ9wBh1H$}s__N?|z8GprT@_681X&t+f6 zmk#rx`_WQ+&A|IZeOg06>@BqVvP#@KBr6x;ekyY0SEE9Trfi?J13RFNh z@rI_EUB&_P1A-?AFy8@$Zr@Tvjd3}Sn!i<1>AMoSEpr1u^25x&miTgsrdo4gnJpF_ z%i}M0wQ>iPym^AuM@cKdMut-Z%_A+q0rB}z1@?&S6#56Nuw6=S;H{cbsHO--;-?B=!zz42T7Z* zROsZt)af|yEfu@nuktxVWmRt~*kENDH+aRY19v$|ey0H3*?^^4O2tQ_>m_hC*$}y* zNiHjAZuOu)6j|QF4@fMFYq=<%SGXd>tYj0NfZOh*nkSw)wI4kIyjuA zYPH4x3YO(dLshx#neyCxdIP{svO}iJBv8df38}pRAX-qkY?J|~Hy#%i$rTHSQPRj< zMn#tDqleo%LpBQPikA?dEt%PYo;(}d%3hYEDT*Pi5M4ka1-;(4Mk=V+F+l#)udiS4 z9i1NU|M%XF6g^Mf5_viU8dt_VI6d0^>rcPF*6^kXZVyd5=$Ham&o6*zZ4#6=bQ~Js z{`d|qU)Z9L-@URI4L%mjt@zmS%2;5<8UsCTKW(qKuz2Cdv+yk6nQ{g&3Gt7KoKV(9 zoN1h%&79YNLi2l_7Va0+dXPnFdz#0z!#H0NT}83hT4)qg$KBd<-_0gzxxnOq(mYN} z3sjLqJ5U!1+&#=8$@&*T&5uvuCN+GkaazMuuD74HH-Z3+6PP21&9y$vGZS#`W#YaZkWB~UEKbXI z2(>Q7H#wZ%&;xv+(wa+Kmcyc1?<{9t_$kk#0Z>*rOs#}T&b}L?;>WlFyZIgb7s%d2ixI?RT{LaO~xWq{~Js0b}JK#d#I zA2l-Yy}9&xVzqK~(JQn>n|eeyPVIeyx_B@spx9*UY?Zg_W90hC&Xg*}lFO}U>7~SY zEY!T1*4fZ(E+(v?~YwP3R;6OhR-n%Ga`mg7S{Km8Ue7x6+{SvA8cHl--QyW zR`XLYhIz_I+II-1%;jaAO$zWlK`vXFnozU@P>9n38&T)TxjU{?2ZqJRKbD??V+2ZhC;A(qh0+Jkl`s)c;LcR3hTU5cNtG=if>GuFCCmx z`gl9z5@-0`qQ}lYc(i#b&lF3T-+6U5{A; zC4iQ@b#}sAn5#`h5pACeAfoo9K$v6SR@}#P?xGDHG#kg+ND|}WxmdAlcoM_WE$rz< z?c1X6+%_~v|V$WB>r zZh+=oJXzOx<`t>B!p^!g^IZl;#hG|JTSiv_D#TPUZ^2?KE3>r#Y^?TWl$S-QALdAW z<+CdXhdx9od1dKU&~YHpPzg_VTP=nGO4vWt7RA8lwPstjHiridtC{hn%^M*E2C(SR zSdLn>a$W%IBR-kb&`~<|bAh=oHO{Mw3D|jSn}f;uOrZas4wJ+qm=P3NF)n@X^?fBP z_)@0n&Wdhscw=W3?EUKD?cTTHpKGCazZy@;ek@DWSM(DZ<%PDA{&aM(^J;hJ_@v^E zKmkM~d{Gj=7O*d_bdKs5twv#?JQ7Hkjl!oSYw znGWcmx09zk=&`~!Clq6fem0gwMnUhx{zV|LW4oM9r0*e7g!pez-t4D?xGxKnYD1>& ztN0=w%RwAr(p30s4L&&K9sAQUj50V);u2WbQ~RAPRv>6L?vuKKBjrIs^Zw}du08v$ z_4V(~s5O<`pwS9?b}{fnpbYwF?H`^xd%?OxwE+Y90XXBU926=kC{((Q{lkC9*A1nt z=f;%ZMhE)=gW&d^<@Rd?{Pt-L*dTb@R?BQso@JVIN60gsWsY_fLADQ7P+iNIX`X94 zD!ZwecZE#oxY;Tj@_hkSkKJ=m>g=1mzquUevar+q;9eWEF-^5ma1w>O+w&SZtjjGg zT&XzECdq)J1tjzfCH~^GNzN_@Y&DDF@A3Jx04qjtE5N5S(f3|mc(cWh(N62E3!_F0 zZ?Kl)l!FtwC4r+#T3VU-(BOuL$8Lmk_F>!79)}Kw_l0xjX*kA0K?9IVE0!fII92n_ zk|aH{+lXP7B-s^S9+*K3ySj`A6VO2eiRl`vv?B;7MTYB>A1E@^U=@AI(SV2ykbeZ0 zN1D?qv*U10vx#!Qnv%WW9|4C&Hz)hRL7%=kIH)@H2H0r3 zQv(+Yqmu_L5ChDagRYtbb><#p{kfRv$L*(cxA;w#je$$5Fw^|o?0v27=E=#Mz-GpY z6elNdIJ6S=w`BzBHHKMkclz*zZKrSIOZl*+d2?{3kRM90&?>8M;rWK_AByvA%+%Zo z4ra|QaIQe(NmpCu(IxnXpXb@+?7U@49>e5-xiUvw=FxB%_uFDG>bs5@*@QLbXHhB9 z980W3eih{dFy`^lP&G!9lMqb$*v^oYm8cqjxl_Q&9{=J;cj zWn%eau-w;^KWL~RF;qs2YkDF5-C4gBQ!eqeDs&Yl^cuUO6LR%vAy;AQip7;hn=7cxjef3 z=EW~6Ui>Y(PF9&<3eU=LRp@(Ebo?`7h_hr*p3f=J=)z1#0lC< zSSCB0heH;Q!lUeLGg7iSa?BFh*=D6=Gg-%|GR!fbgqwrxtIyPCVksWCHz+7;v%OI# z$EjW!*t{cN+XoU!bukK5!gY(Lv-oBM7*f6`X|Ds|WS4d)(d z;{41?RZfzQXtvw!C_gJYSakwcqbRofZ3n(Va;#GM>4me+IVZX=Y3)}cy3d( zjdS)c&{3A&0lb?|mIHJ9yXBzU`tpWAZS}A;EL-2+DF_44bSKAQx>@!>>@Sx+66@O= zABxq-4UWb7`c4mKoTIz+9g>Ke9+x|=+D?``xw>v{c!+h~Eq$JK9o@&#Lb9g2Ki*KU zH#*{QM>jg=U{|+0>R^{QJ?>yNO z{ZReCI66zSqKx~+DT~N=Sq*Sz{l6#M-&gAYZLUAw{8s<();~9^|5t^DU^T#_E`20gN^YfMtLtT^C+L{$O+7tiP6etFfpFwaQSrs!F^q=C+brwA5z0~>Iw{2 zC+6of#F8EV?_ObOwi{Ba#ModAA+1FCC7V%LIzSg zO!DXqtO<|AV4_vtmP$Rll=-=gFeq}6QLfXrJ77;TN+kzPF4lM{(-_p~EgaM{dSHM} zTwoM8Mxg71RC7+J=(nZMdWaQvXzLL&rr9J{TVG}Xd4mafXIh)Bp$M}aP&6L-5lu#t z_aT@4Y&5dYlZGK{${_1coO+g5&;mjE0qOl|7gQXyh;WfwO zF+dw?>nm27vpu{)n1Is^+(%$YK&QqO^w}^zuC@;bJ#TEM!q=@(qSGxD zBng4Qc~l&mJ#RKf(^b{Q%8Ff~Yi$jP3!j#COf9vEl>FD-3HAB4wL0}{J)rY@3g5%a zbV5mE^i|YtILF-nY*2b&bE`U2hqrXQtfAJt`6?$1h!r4`<{k^Y2$`1obQKdbQF4uR z3M9iKHfn>=;=?FPDDxyi_s-06LyI#q!c z`6RWo|8hnUv^kmK;z9wI)Cqa?C_AY}dz{mT>PdJp!FtX(a+$|xXPD{-a#^MQXmWO5 z>H?sRN{z;Qg3}OO>J4=uvn5REH=Lhe(Qs`|94Sv*Ao&^<&IW081LK66%YrlqcBd); z92#1Hp_~NOw}#0Lfx20B5IS3CoQ@CVjseYq+fhcDjy(vl(nsYC+X}7>_!9TT<@ogM zu0IoC=zY=4_K$y&v%dwj>2X&Uf!RsAct4*74%HExlN-3O383L4XL4>=E=w9;MBte? zfsBb=tg75K`O#`BVcOeq6L7BM0jvVSCwbJ5)3aSAYG38icx+XIU>^mynU>I0o+%}9 zS&6LNg0dxj?=cO9NzKQ_D;d`U(}`K^_`A-ZKf(}DE(KMSki+R(1yOeOqpmfoX2gM> zQO(TSMf?HGMDf$~9c)^drzoA7hFJ^M?b@2i@^;%_gg@FYRE8z6T4+oQFJKmp&TQsK z9h8}A2S019v`j}b9W39COb1RUD54$TY)a#Oww4%%}bs*vi`#O2+xA8Z0P8fV42d&w&`Oy7wCS} zdU+7eC0uFoT=Sdy7N{ky6V<`umSCQR_HTRR{;#@|TQw$%x!ia%5g$(YxE67y|d9wPL+f-i?yP&eo z!0~*qTZCW14Ujyz)#eZ4T=vUEixQOP7V4WT#ENW}aa&Vq3@g=?Ys5smu5tyatlQ$; z66;#n5s5m9Opv*#x7;nR2djv20Tr0I8#S0k{nQn@TXmRNOeI#CM{QQJ8?zLZA#SUu zsC0;hfP=cWN;TkHXxM};UI>@cEpi#G3*msXJL7=+)i{qY0UhZ}oaHsjk=jde$P0?> z>fSwvheg7lrVitpUV%jKPjb+>kFXg9MkmA1d8e-hM;C8pc;+b=-)X+%vA~Z#^JY%kb4{^J_WZx%N!lmj+GTj~4Bp3Y?8( zU$2l82E_&xGj|5#1K=zB$m<+CdK9Hb5v$@?sL1Xqu@Gh2s+sG+)w!Ww&$~5d%mwv# z!5egYJzlqZd}jIoRB*bm=5Qe(UHCFo^nA77*vhf+SD)iD_$s>PuEP@QMR7MOMj^Z~ z!MnIw7)qwEMm|YV+9;aLjbI$WidFEkWvLcb6t)jCiY#GPWX=T)+!gffmQ*knNRAQ3 zCg2mOYM(-yRJ(8f+&%!%G^Pb`_Eu2@O&aAmiTX+uMC-o10~ls zWz80_4~uuT={1X%pBc+6;5*UqeJAFXJ;xJzj=Natv{`@i?~4{gFe8F&6KB>EO*o1W zCFbk*k($szPz z$g)(ihBO+t3Stj$-#XR9G^&XgEi(y7?aBRiY&`|;xc=g^(sOSqpPiQf>)kRht+}S^ zGn?J#rJ|utW&<^)`Sh2%xC!;G+@L6(&Mk9{6tS=f2;N{OkX7)BQ^<<~ZaE>c>F|6i z0p=vvPKjm|MbEg{my!d0EeGo)eBBk+ULzBMXxmG99ty5i^U` z-e{c_rB^MxpjF}Ax9?J^@M8>G$bL5B?N=z2%5HgyxAcPA%XTm+4?N2ORmw&!ONZ>_)`2Y8v@n0pfi1`mBK$%8sxH= zBxPNTYby(Wbz-*X#1}iiy)Sk5*sJ3M$A;FkMn zZ>e#3a~En)TN?JX@SWkXcwpagZmIQ&v3Vc}KRc5cBO^bIG3|IHAb2d1KbYb@%mO`UZ-sNc*!)#=arbzj=xk zF!HA3VXC~&Je8~oc0v1iL@H=Z131%^14*DHr0)!f$;R{Qvnyk3nfv1Ao}|@|)mECF zsqo5CUK*CaQaWyJjk!%~8S?sY$e!{JU8qZR2wJ2=1N;m1Ynm_7{oaC;R*e_j3b;;- zZ3dP`TA9LhU-0^ru}A6yS%n0US+692Cb`;BlWsfEfR$4W^8#QkJhCT z>o66s^?l7S3Xp7VaLo}H1U^#w>ErVVw8tj41HnB39RNcLr;`cvaU+Ftpr0l6$svM3 zQ@~%zo)@%!1~I)p{2xzvJ+{RT17A3hV zOXvMkT{TLSPG5Xk7U!_C+3h3{`;T6-DgxdBIyp8tzbU6{)_ zD=o;u#!s5Z10H0xMP$)4C z%gYLiV2l5jdA1s-1Ni~4iXzDRbvDEt8hr>vQ-l7ih#t39@F`OMmN}5 z|Fl@U$2|1w>+9b?c~X=ApVQ?#`TsYz9aHN{&!jL!T*_6|6ybO z$>YsU|NNhxaAR{tR_biD^91z@JSTozfv!vAX!@jpc1XW0^_S~6r06O*yn zKZHIbs+~x=AJ3r}C1%4{IsbQ(@*GGOCr?vk=>4l~6ve5)jnP4>=2~&9W?ikbxW!BFUoB*dk z(~i3I_ceS|1gly?FT6A3GCD7JeeJrE8p;W)p+EymW?(sqv}n`U%?3jP z90jB|mU-S%hu;#zXcQ+?#p)?uH%nwY$Fv*lL!*a6uR_sV#gaR^Qo`nk*$#dU(SIAr<*kSSzN zJk$e|j;wm#CpuS@3wXMiy9EHR-W@|<|Cq=;mZ;j2g|y~4$PjK+59r`lko!$PONa59 ziWdccZFVN_O?@bC%Jx}Xbk}6rUxWKtbXVG#N~83KgB7!~k|wAw3s0~mdQ;%}u(mL6 zC#-(e0!(u!ZU|f0*QMNQHlng$%I zg;%HK5$H(=X~C9o0q9g3oH2HFjRTI@&#W_j>;?O1P@zTIIYk`-hj?jJz?V+^Q%I zStHYoTA0P4s~|`GV@SLz>j9G-K_2aa_lXMjaWa3J4I#CrPvi^6oUd~!e>#38HrCr4 zD>GL7*R8iZhlhKwX05ji@TeMMpp&&)UIybpe+?qixv{S#ke6cCf@d7en>X$Z`K^g| zdxM07Wd6d^)cD3Q(kx{8fKRV2-cAZk7uwzGwnTTk+X8=z?s}Ji6Cn92%Av;5XdIPs z4`{`dYmpZ%(QUwj8f=(?Kepiy#0aI#$GI$B+fY=%NYs2A^7O)HLS9gq3rvsH4eQ!w z!kRuA6XV1nljY9tk(UYG51rhIdg`usRn(TFR7Q3CM=%z31h}_~YtaOx)ssnfwbE^g zURIv-B}%IYn;X-Y8?&p-KHSIX20Dp7BCdc|070lH1;u1W5Mfc#S%gX*Z zr(-F?ZoubpS{C;1%-;)2sD%#7E!PC9OJjoFQC(1TgqWH^M0p-f+u}gEC%3GMnjC`1 zpM;MY-J64JiIU`{&ZoM>QZ8lQi^_P!%L&Zf03Y~GQ%Yq1I38ba4dc8hXMbH-*p$ZZ zO$8+Gf@AXN5U2C-v9lg;d*SiCLAD*d5EyUE9`6-zINj>lkTeVsMP0DnpGv?eOaAZ( zZGZ>)K<3wQdER$dR|jdaO18n(3|=gAY5GY_m!{ec{%<7=FXnhf)7>L7UE#NK;3Q4Z z#aTBY8D9|C@Uxd4@lXQ*q7;2R_?H@bF(fnVVxexjsKt&fsNtmWH;_meG;+hpKwzo@ zBnlH~u_PFR3p6BBZn+weL^lIUU#(4fR*u3Lgq=(9Vi<}poi~q;s2<@|Q+CICL5-2c zI*-rJDQ{L^4xp@JTfCE3l-h+|43Jv`0ZYTZ?0rOAhFKP&Ld- znDl8K33XR{ErELi4h=Z9flM=PMrU>$fSdc$yqpplEN%(aY&G*!JX0i+_(Ea@OytGr z>Nq*`dXqDC+kK4}=w9N!)GCgUQZBp|N-Jb@yp>!8M}$sbmRe(}^d=31y&K&XI8(NG z0V*UhMC^zrEPh4%G(8eKJ3I7rdxg2=HtM0ebUC`9fgH;m^@niTRHl67IJr?lJC~|H z0iMpF`Zr2FaVbWI-{x}^|KI=f|H275J-`uUIUW<&@@2_MOC~coQ^aSsyogKo%ijD= zW$5fiNun@-a)q)Hzp)^Kyx&!Hfc&p0*-qEj_HpsIDA)CFwsSj^1KZQyQ{)b$+^w0)hT|Fatx3? zqO6foX@6$?L};%Xd+!cTULXAW?p33UM}{Qe$~rAfJ*&Y~E4s1p2i4^TS0G)io%DcW z7{v)vQ&Qc5o=%`) zL-z|<-5@i$Tx~VH-YSsVTs;wK;iI&2-<7s;N?Quv3sF&I{a96|Hu5qIX+d>55Qt4c zl@_T28J^ZFN@@1Rq*o?bV_Dxq)D=OQ3=pX0KPD2B{INEsC(onHn6X{Rzj7%f|_7q zc?mHJgY+Kig~8|BR^ca<^g5`EHEJjEN!ZF3Q{G9B5;A7=vk_FiqmgG=HO$~QwriL& zQ;t<*b9;Tev-xy=y|cNw-r4AEZawX6Jbm`Kv-za|w6pPSYuhn(Y!mC2_MF_BWx8foAVNKIFe1b{5&D z)-Z=P8 z_mSoC8MyAQ2&0DtY^1%niHs_hrAtQR($Xt*Sy$cV3c{j$fCQ@Rl1!K4Sv0Ydxo5q- z(SGJuJz{oNy9zN37)=XX92CE41Rj_BGS3y+?;yZ*5KI2YaeFV%(@Ynj5T6A3+@Y8@_YU_17hE&oEr#>Jt8RoU zywqj4(-Ngs%+*E3a4=mGCvB+{y^^)GYZcWCiM)*h)f#z%wbVdm4}GA@-eYKec5UC1 z?6n9FI;9wdK*Os*I=bmtvh1Un2C6OOFzvh^U061gd7sNi@Ufv}8<%FZM4m+nMm8-r zjwPQ(K@sge%VTjvr%)xv4J<0{-IV7w%+)a+f3vZ%`F(r6z24qv zw8ZA7?_JPRaN^ezx7n;};~z}JwKZ{=6YrdW`#nNoQRr-n!AhuKEZejcTcq}dFC%Zx zJjQ6Fy|J|bXQU3WP9J9o0epR1?x>2?cs1(54G09UU_PBNI=5NNtY4~yY2D!4dif6 z8!Q*yFXbqTlf{~j&$D#a3~RRG?T5-PV8mTqPOG~hKalp;1b7+L7?O zcvIf(9G)D_-k0O73dU&>#;Aa6M-kNP32s>&0{mPKb6K2+UX*zdM8(7c5jKE zT`DM^>kmI!bj^FHX_NchnwR@R;XwDPg$KMBMd;~axUs$^-eU!3?qdx;6&J=|RYZgn zLxCj|k?~p7fU4|vs$Y%>gkHeQmo28`5^oy`H5ZB=s@jyu7DN7OMY&>_bdoL6<(FMs z^Q~=%YG5@VXM8+-iWY_x?HJoWv{J;fO1%)55nLwGiwg42?dCar+x5*MKXOUJ7vA%* z;qfy|wczf{$I*pTHWF^p4JwN_zt>MGWK^;4;%5yC2143iOA((e+$TP{SVerYB;8N;fr(Gn0Fgj$zh)5su3iP|TP>mj zR=oTTjD)mnFOiu6FLC4&;1?oh@Y}m%{09(&rTkS(xQPwVq48Fq)=u22+qb{jy_z$+ zRi{LJtbU#2zE#(N#H@}r+}y6yqrW@$4 z1!QS2dZyXk>1rWYr%o`oEEbn7FIkg_hytnDcR3(YYmpG7V^kemF-;&4`f~x{zWcuM z{Z@Np^GW;rXYGyktwu{Y51#lBwi~~9SAtUH#sfR1jojxQA*ZGS^Y_lAzTD2-_R^SRMaKT0#m^OUGCH=2bN zdQ+K?vZcIl^rF0N``(B7smJZjMNksjqP`TgRJj5;ySuywH-Qw3PJMPb0Y|ippHI@?j9_8r#i;P=Z0_@MYn=VYxo-jCY+Ua zyU_sJ?7sc&-qP2+&EvEH&giyEU3 zZ4WHl?RK3wsg05|!R+madqsXrnKCM1_V&ZApsb>&S{}%9c{WKRT}&MU1zV}8XjOOosgK+kyc`sVjXqKp1vUF(5z0Ja{HPni2edxP1JDeHmtz<7Z9 zPScK4xE<9<{%Vav)d_fHd#g2$_YeQCSDU}uFO|ny!+mJEt2IuGc-%gn493pAv6{03 z+v9cXneDx{v92q)Ut24v-nVD%jfMCPRHohQm0Q*nSGjfA!L2S{NRhkz-AgIiV@^p< z^mRM_o`M?I17I69a*cn zdHz+j6o)k+f3GnnBP3@l9|pF8Z(IZf4(}PM+y({?Z;4HA4FnNa%Yb|YT7+Q#s%H22 zK+87>531W)U~x;J;Gzc0l5BEbw#lq9+91_od*Bg*<+CyPM4_SRkk*1=s`)32*+bpWM* z3RSp_DYUrI>4OjltBnG=|PFL7AI)$Ve~2+9w~%&%#vQ46;u?ly|~b-G;HkRIrT2G3C}pnq8%s zm3Zgfe^HR-qb|b!bj1yp&tm7qhLKkNLhu1p3e^e3bqoW7CUadFH(|7HU5rnl z1X^~IWRsN&VjnU$Nw`jDmkuB$rVG8)Bc3$YR*Djfny6mYa#Srp{+8yrXtc!75W7Gj z5{%$=+yZVduh`vO4X(3D(R=Zc1BDtp4U6?~0`if2+I;p*Tw8=ke}@*PMoR@2Iq8zZ zU%dUT;ix;Kq}*yp#d!3gop=(op^s12!=1f5w#N2F@bD)mzn#DYR6y8!q0wI2PbLG| zIW5LRyC0$OU$DF5gB_cvbvWdWI?mT)lB2;WPV3t$K6&HG_V%;w@3%Icx0+FY=J36m zQT87zPI=?0_d;>X+w0<5%*Z2U)d-4)fL?>F6)??}wCKZ*$F~JTU1nu5{g4F{f02~kao}WfM(&dnD95Q^#0PHi`>s`* z#AIT;$$k#fLe(;%e$;AK*(1Z{S7?Tc5e>+MCRKdLSqLwYvwvF6+V02Oi+#LZ{aB|! zpZTqBRkcn(oo|#r3+2&nt}L1%y#fHos$i|jw1fwYqk^^+sYqd$>%?rXT$TwIg{7mY zH?R5>*|KDA%T9y>H10rD|K!<|`KTTm{fX0zu5P2eHi}BCc#2(Og|0hAV)OcT-tA~G zM?M-}HlI9RfowgHW3?v*vv)J|CjsCVvOK1hHQyWh+}LX4e>Q8-c)z*6zR}rwy1h>S z>pXq>^y%+T6aK6Nl?WI3)@%3stjtI|s=~dS#tL#LM=4}U!Yo@>{%n<$+1~;@O>gNd zU6pYOlRpDf(Id7Np#+llMiz;|v`nf$%t33ChCAb!l<_>$wHhZH4pC2pd5B#G;RB;E5y3jqKQlh<->=mPQ_`Om8Tw(TdB^=k%qb#_&~EUk{*Y>dPzW8f4VM~0XuuJ#RXqj6g?dHR z5sgspcGaVd@+1a!H3gv$@(*W|68I0!5vvNmQ^sgqM>s3iWBrtzWz_^`VH~LS4CQ?< zWNz@zAnVV^JqGE_#M;)S;rVo+*3bYqM3d|q8hxZPi8*e=`qHvJt7T8B51b%_%#AUu z#xTemLjHA@x|6A0`U^;%u7kn2Ul$L+V`r%ig#9enxvO~~gmKZI6lFHj2pa%oCK8^9 zbwh~rE^+Q`jje&gS|YA-sGsk|rOg56%vAaKx_Pq#I1gPuhF7#0XEy88*?d{;mldwe zUYGg+>KB+gHx_lNDaV6Z+o`gOp?jn+flHNshGIRGeZS{7usY8rp4HB7uBzcJtLCZLsIVfcL%R_PIfxt z;U4|=@P}%f*9S*$_l}OB5&s%$b-Z`<*VjAyZ=jj_J=9Jy3^XSFUej*>?IE|?e|s2e zbF}yR*W*3xihm8Y`f2CYfBw36^k2|S{a(`!w3*z@%ADl4dcE^@|BdR7{-|krw0C^S z?cmo?tKEZl@2quLe}-D0?7!VR`1J%@@~@#*dk3$f#lh>~aqhptHNwB)jeooMmiGPa z-rG=%S9`}NN5Af#>>s>?cGjOY+i-kx#Jg~O5(FOD$2U8FIaYfLzlZ0hPKbW1>FekH zcPFYZ{Jjpq-tC|4@4VUn?>z;M)|1dTZw_`|?H~U9=5Xh5AHJ~v4z-6e4S(4?dAE1+ zw}Yc!4tI`r-r~GM&x63R^KN(V%^L;{^@rQClCv|PThj7BNi7$TBrw8Qu_a03LiV$C zP*4G+)eWRwswT6ppGDty+A!wJIi-_!K%ylp5ZQ)!c7{X!$3zxoMdsWETP2q85vjZ~-|3p` zYHqxcLYC0HXak2&xyn!+fCj7NKgi+or(JOa_=^HX=z|v43{LhM2a2`pkR)nJL zqz13}Q-rcaf7AdguIH3U(W`upyQscv8udhI+3z*`ZuA(c{n{Fd-F$8YWx4`6okdg% z?x5uyel`?mN!E)Jb6S;Ymc^YP*@8ucwKeeeSAWk;Onu_GvM7UzW{Ij5-$BaK zUH}0GTF>1UA-bUkM!cW#c5C+Q?b)xvq%yMsgwD)vfI(j~o4oxn`#t$_&u%hjj}GT` z0A6IX8|0U>8-NExT>~-)gx?mSV^;j{)Ar-AwiqoW=H^<-gW;w^;=n9#R^lBMO}MS!7Rxd! z%<`NHQg#iU?YdN?x-%Xj>EjZb4g(H9=00`MYz+8AKe98*;)-+|{=3p(%Wtt&X|nA% z*{(F%NvD3Jopf4hwi`u$v)w4FHY3xa*AO07n!f$uw|o1c(g<&!-wq#En--OJ)lEID z_I4QP>o}{d_BgAq_Bg++G|Mk5%}zd)ezTJgrQHm#r_~1kp2;d{N(gz(0p19%3z-hE z8iC?N3?b0+pu(nn3}r^vZf(foy`jtBQj35sSh%-sTl?MiXRETY zs(i0pT2%LOP8AU2(KzaBmn3&=OGPSNt;iFortHVK3R^Ss9+VW%8|*;X_EoAuy7RqI9nlROuCQ2WMdTIGTxLCZXV)4Sm;!ZB*kHS)wg14N~ zc0y^s>jwkbPkq+KZ>>YS zyPinsX97Vn->t9blQfn2&HKT{tPB0`7w}{6sr|eCqpsrh4qIdk88I*4D(kpE`(9@rhWYe@~+POzOYh#6>AnAjeJ_szUT+l3j@_a2)Dq z<5&)$L%hmK+-ncA5yB#uIF^IBB;U-h z!IKiF+lCLhA}eag(d>q*bx`s^Z7t-ut)j19q1Zt@VRmwm0eZ67ZmMD(|Racak`wq#Jl*?V`-ahj})R&T#9SEA2a<8A&QX z;j}uUsU5o9iJjyVsmh?^)WlU(h(3GYYc~Pv3_}aJ9(HICOskr0xVPPh7Fi(&HRD!H z;9l^iatF6>e?+=F>>gZ+r@+O6Q^VBVFJ2B6@gBs*I4b++;Ky+12g++ajLLHmK;K)l zefj%rcw-b1-aA@6b<}b8fE)zfuJ@?|FKmJZ6_XbEf?BRI?BHOz7BsTqVq54!W%gf{VERB+`co@N74-GI#@&V)GY;kdt zPl{3wx^C&)wq@`Jv+yuVpu!uVMbM6*rWGP*YNn~Xt=S*#me=(+)XGz$Cj)2MHHV3Q zwrZNz=>CcN-1Ge$4BXtmlKcNcsC5>o7kPg#;hYll;QYAE#8(Vcz7Na z=M=W`5N%`+i%D-3mk(=(wKDOtboc`@PR9}<03BANUUmtL(l}v)<1NZ8b6LZA3XL2QC5{HoxdeDMbZ)D9(6k%8`DEOYfG`T)b9 z{b&qjX1a=RK$JH_UxcGWZ~6-P6x+Ay|O?hcZqrvbhl($h} zYBlH1DnEK_dN?~hISBuaFN58H(~~;630iM5?4Z~hy$tv9kHhg`j>IRyv zI33DdoFH>|qOpw4-yx7dct2r49{mUBeJZb-4uYh00y26P_e+J};O~_{7l6lv>o#Tc zt+3OuGuDo1B_kmjm8u2rOy5L<=CUv2OC}*C-vFzDF3^TwV*YgGdf0l~&vWq(fuH(E zq1fgd^V>H)7W%$=I4iX+uD=_3Q!9*IYfD8!CTt)Lp=WFD$^Jcv?{Af&u6(Wg?U7eyvVDJP+;VVp)u{6D}hmsX#O ztPUp$Dk@b;`nGrr0qg^LDHG7F6{0wY5EhzMnw5_p5gO}9=vSaTZgtOXNYDZ?Zs(bZ zdT7lDT@FSbz=sdmHPncj8~{=Zf_tq8LX?S$pbR-5CC;Njj2dd_t2ZfmilCOj*olm0 zSY~1rpFzGI4As{bp;9Ox1Nfc^;BW%`Ui*Q-{eR`nBtmf*I|d?74kVD+#Pqp;pqx2? z)r&CY(IWvqu89<9c{UkiBrZtVnXPdr4Qmb|9+vNyC1u0hp)1-QY!3`Tw}FmejjmGu z;O^wvmG%*1TOE3!(6>ac9$1N9(yU~!l{_-Sev%d1n2@EIl}XJRozHmBy5l^9I=<~J zZ8j!pKboAKmpUN7vC>tVm=-N=qI+ep9Z_a58TkSDTBS)$rk<-Cc)7vBfLpWzQ*q4x z9qq05rdWk!P5cHM7E+4$RI=7M5}(E8`J@NwO4t;M|E%?rthYwq#7W#!$oKEX$^)Rt zzSjf2Rz45Rt|5Wjqk|OB(Q_rvWs_Van1x%ZM6{uPh9IrWUWzj9N8@6WsBAypEdd9a zY(fs@m;(Yh3)P)E0LWD%S>j*^Byd8%v<4$Ms04Ru@YW~IoDIf=qb{Ju>a}@RcqiOW!=Hs?KT<0nXX7#KRSdLbXafiyaYbQ^R9=3N{fSZppJg1x zU0lT_h_RVZp==tz*ztq6W}~pYNXksev;ftv)`Pe!L96J8xbz$jUHIfp(csCtP{gaC z2pj@I#GDhQ%<~E9y48BlJy3v!-7VabWg@2t3&qQ{L@L1utJyH!oxKU>M0np@X1T~z zATb9nM|H!!0!>H00c;lw-YNy`{~VVJN11b{jwZxf6_fEe0T*bKL^BQXV`>Y+I2_0d zT1Mbp9Maihs!E%eWLK*RaQv3zE~h!LyHk!dIF+bWb7>1waFQ8E<+dr*cIrHT4mq}X zn|k{dS&T7W8ibNwRK$J7iBHf$dNw3kL0rNPubhj8JO#t(tU!@_PjEZjyE?lln4 z)l_Jcnk!DL0kX)%Dq%>K9Y!TMlnT1a64}OP&BiWsbMV){K?cCw?ep3n0=S80sAI(g zfI0Cb?q7skp~LVAMMSC=pmsctN5GJxk2)kBQTZ$pCyAn*42OP4LJW&`HkN6#k!I;C z`qcsS4dX;Yf>z#ymKYAgGl8FYNE<~$jcof}I2q1g?*J;FyV$k6RSzn;0b zI+jgTFezg+j+tXCrhVK-3NpTid3<&TvYnE;+?x@lqMt{_xhE`zu}VHke>{279Ht%7 zY`5D{4&_RsbjnH3POun{{j?)aYO&9r!$4C8PiBB!{#i+~gj9HaO2;mGQ~#>#UOWL6 zWXYk^LL$8k$+vN7_o~eT*`zdCMEM$5LWQ`nNyhG$gLoqJ8zSOju@P~B?nDp?B%?tndcp>S zl4gcm%qiE%P+up8IF|P&chM0u1i3|6+-y9~inv5S8|x}53LUUs*bafd>tpU34{+~3tOV!Tk*-=5c0G|1FvCY zQVyRsT4K;fYdsi#dkD_v_} zjTF*^B@kGklR98ZJkn>7oy^&!nVf;T$QqTOSedQ8`jY$sZ#Xn0L>Xvht~G$dk0)A} z_L|$iXqptMCo?I$ow*Om88X%}WC_5+r)8#a91L~c7C&cK5aihst|X@4mpU?N)09Wk~G^h6wV=9p=iKLUn>0x@zqCdnJ7JvlqiCZWx#krnX&2Cq|+WFMt} z!{v92%We3aiP3e##nC#Qg~kX9b#&O$QXi}9n6CVAU3&S=DdUg*L5t))#{Pac$Nytv zb8B;JqvHRuz484w|Bu`LEaCt07SbuRidVVl_aR>xcz48w=uKkCCqWVy*bxRXxr{oN z0<^6IEUgZ5be4?r{&`%=KDw?$E=hC;gmUIUb}nK-K2`y;ChKz^Dy{Lu73>l`5P+K) zDE~Hge*=|lS0OLM;58p=m$!#2Oz+tnlie*|XC^&J2mJU`S+*%rfi4%L6+^7ZhJa7<8vY1H*Q(Y~a>AHlwY&Jt6g@?M*`T*$hO4rsQ zfyhj`Qn2;|RT_C<@sui`eN>ha#FN0E&he@sKxVYqdqA8_#~iz%0gVb@Pwz1ol?C4Z1i_<4frmp!d?@q^ zA1H@_NGEPlkqtC;1p8C#DkalXiX6g-g~DhoXipw+;wCw;W9f1!PUEvQ%jMvdj8t*a zkMe<8l$#PwRZA+);j}=sz(2hOTX}RW(FA%^Lvy)-09Y8wZ&IlEeR4E1^KMbLdgZ6( zb_3fS?ueDz#Ci=Ly5ax&==z=4GYKP3l}w^P+N>_c*`TBA@kni@wO2nN$% zqj2@eyeG~Tqf=T!TSRO_Op={78~WNS&h_6K)X}xyAMOqJNbiuNyq!A|^8$75NbFqX zx+8rQI{>A)En6vu0C?>L4d;IL#`eVpBrqiYk@B%?^sxv(xmeDPE zT!Liy)n~#|4)LGj(VPiagZl_B+{q&b z_{Su^j1t&*4}HPxy+Kb@W&)G511fD@fln8dSJi=0%7ju0tXt`lp%`eL-JWDfmdn6T zR&~#dvDV^EYR&%B?$Zr7SS|+3io5!V(K$N!MO?3RP&4s^cRsf{kvvcX-ANL)HHCjQ?`w+`k})B_HL%1`v<%s*-~*yup>SV|cm+P2L&2P7 z&EMv`AY=ZCkUr82TVr}ZH?#X*3WBp0^va>P?8eI}2t_XcE-N-5J3SPJ>mI3AR`78( zr@KGjW5^iRUuxF7Mm{AxLaBhSqL`fXiD?f`H57PylR55}RLazkJiftdkcMl@%AiQj zoNUmKOLj7?+5RLe%r$V%Fl`)e`yJvh*_%N|4ZFlN0{sqzv%Wn zcZm6Y|I6>--T|}0hAY-+zsTuAgK^H=PokKPdRZbm;urBr4dV8KB5q(&W$`G@EVQdk!1qD@?rrOQ*r92Tpuv500+xW-yj@FYpR$&%*U zinZ)EQhBA8-{_M5AC!cS$g4UeXG26|4VQaTpX!96zQ~Nme?Pts;O3m1&M=+tpEU8cbNH?pn%rUq6Q^=VDJ@Do zr%ZbRg&alTl2*9EJtp`RPv(YBof_SM_}*F=={O&AOoiQ=A2sTHxX3;sB^xH}Ve1{g z7K`1GlC2M;sj_HnZO#g5sLty>TDE={&q<6S)rJI*G1aHrpKT<;Pv`V6b7hg)qxhDK zsF!6Uuh%7)s~nHepKr0%Lhf6yyTulKO^%N2Q8+txNBIek(ViTfpa-F~7g?&?VjRqs zq1Xj~v|pzx0~TV!E(@Z#G*UAtkrkJW6}i&Pi@!LUhSXnkyhp5H^=L@O7`x}S7AYd?kj?0KA)MMq>8pllf}2GKjI zmvguu)TJm@ic-W87xBfOKDUhe+!9x~o26x*CCMyMp(r}-t})Cq6|~V(t_-9xs-T{dzpJKn&PIFVG1bmlZ*OeZln^UW-AEAU2(>!& zD4ylR1>NuTzmCSnoND7%Bf>U+_q=?sTRcF*%Wbhe7dcw>sj`R!X zN1;A52-RTf&xPv%y(IHSm!i>&^2%NI+APk?B1eNbu*u82E#TjwTdSz*4jA7swO&jqmmt^dsqs_4-_A9bSJ)_nU zz^W_~778c>C{lDc&v`Fme!f>XSMr^R$Q4LzwUAUd`-d%}fLtOYBO_yZ!W&vII`CWX zc{|=V+rk6Ux5neQfr&B0Uh)L%u3xxbmpnorsN=LwI@rXil?^rWVAEN{$$4p_f|BAA zq0as?-|OLzP42Ja?Y$DXPew}MF$d&Sgs#HE8LD(ikmPiXP8TP7wDFbFPAuILTm1XY&+pYL!>9 zYB6xab1M)s>!>%GjV^ktQSYiC)u&>QTZi-OGnHC6na3_&2ZRJE9Hr_vM;Sx1tD5}8s?`uT1#*)D#4u|i0LH@G5xC2dBVUpnRjSehkd4mL7OPmR*cfCz<*ES|Gz@RbEqJSa^uwk9!k!t=Mm*Ed%ytYC_r1(pC_ zE2gt3486nvm9dk#0Oc?%&I-nm0Sgw=nMl7!^&HXb)3^rOu2%4wbcJ$3g$LIq2aOGB z4rqgOu@8sa_D6-0Zw!Zh#!HT#c1;i0B-<)`&bv%1U##isNmWUxC*G4rxny_NS}HXw zPSs4iIv%Cv%VinM`Xv-=-BQChzbvlegTCmqFPp1Js?jIL{lb-+^xv30X8^<+b10U2 zCZ!KqzNf+0a5|ql?^;;&(n_2uMOs-pHocXx|K@2Tp$6D5Mgy1d^cRyVml^>9g<}ln zML4{T93?-dtR-E@S_Y1T_(L-bR4C);PykxQnb^I8CTMqSPC;NQR3vN=D;L)&RuSnK z&}dHIsvuCu_H?%d%NE>m{Ri$%%G6+{*2dG5>r0#4E{}v`@Qmx}G zm~dId%4{qGlqv)fpwx1B@Ff#4Uox;LKMm6{R`0wpY9x}`T9wQaI|!E1=U#PXVc%mv z#*-w?=P{KEQRpZ^j1}q-D%?IK!%PE@onxVxvoMLUEQ|Kw?qpuaGYXA{8)uYP1Y} z(}lX6NrvY4EKwy!L^0NR47u;4G(47Arzk~ukcH7jcMT>OkCBopr>%?pS8+K4nq#9P z7ANAlF{#4o>kQPPh8$NB+%#chr!N*J%ZPNW25IM(ulB8T<_@2z8AT?UG zlOh!2lbVD%pMC0&$~dc0m-|+c;3Vi7)qOb)&O)5vh&!Oe4VMOLJSh&kFV9VMWZ`Wo z%QfO)2%3mF!s_`^guS4b=i*As>(OwPSM}Jjo42%FyKEkZ|Cn<@hDx^hPY7bzWxm)~ z69{%Acok1&(DpW~ypmAp{WLkpK;IM)uLCxkXE^|wtFPrn)vuc9{R;O^^+esNBps*x zQKb7Ci3+lWoi|PX8AefnsR}&a`tfi8@HK-E{CJ=-s0OcsJorp$G4qsX|KAI0@H1pl zZB|h1rRGAZk@}@vWaZuk<%;xFH;7fXG)+r=yUSdg-MqMvL+`UdT?Uc~^M~8!9#$B+ z7T5-aa!UXz-KK~oMY{IbKO6H>wUFC8mfFGqjHO zBxRq2DEeI0dEbD)$~@76ZDf+LWws8hq01E9tg3U4NJ$I<<@G%b2=Bj#!3t<(2~b;I z8U;!Lj{=IBphKGHxh7D}n2))r+-MuA1hIn21kvS?GL`EBXwai*KBf)y@r#X=dC>g)hEYbG4D@*oYN zzz8PC3fyia#B$O7&9N)p>@%!trj-<8|Hg*yCNR{vj5ViUM9q7gxT@(?4dZQ)pL)~a zYt4AJ*s#yGi%8CGW0Y_YY;7U0Ziywze8g4{;_(*3EKj1~q!_RW%6t@Dlqz5#3^Q>) z$X>jE%4Vx~sE((U+eLI2#$X_lmBs8@q~g_{U|QIGW~)>k_LM6WdpLr)+6MychWLF% zzGxxoLy&!l!IIL>ElN78%9fHDef?W6LwAcnGB^DI8k|x$X@D}O9OoOJar+j`_8|^7 z#sCNfqbZDKfLqivnc_7%5%~CnAdp*&+xCV-&-C1v^bCiTwe7V6lYurWrhx*H>r10z zfZMEy;9$a*4A>!6`o(HK$5?*QDGK~PN?lP^m}hY>$5dA^qa0n#xPTqK=iOJ0tCrMg zg96ax<#)xGHRc3f@$e35S4y{(Euu04nJRl7l`BYLbrUMq<`;rxt0ICSLePrbEaKx7 zmX5UspP>b;o~%ig_X3b8j880-NtKjtKeef&?>a_{b|Sjt0kyDBL=2y;U6Bm8=T69DC7*C$squoY zPeUfR{qtB>x5S(T8iOc~xMa*( z0myZsVBKFp!9C2=aFoCP#~f@>nf}9W1*%`9c||KKN}EFbprAZq{))egO({g#O7kjY zyIBjy@+83v0TPzV(o8OB69pOT{hyw7U`e0x(4oy)l-u}41UdBnPp>9mcQBwx4l{d1 zuCM^UHM@{C5M>=qOZDSJBhbdF@)@hJQKaq0W*?gf=+B~E)cn+51o@%;v>Oxv=Q~}a zw2Nc|YezZ`W2l{KlT4h+cfnWL@>4#|cyz`q>}8Lnz3ibkykB826G}rFPRFgpR4Am( ztqcf{xSZ7i0;Y))xxmA%57=g$9+wJZE~k5dF9R}RFn`RmJWVcqhJsp{>@rfarDm2I zMUmkq>*;Df_RWeKKjyL!7-$!{F6Boy64Y3z8SL!t-RV5b@8WlKh@(juZRu=(Qf!@E z4Ptq~yvQfHtSJHN^2o>n_{&QIprD$p)=ZrvkL}6UuMO;`SJY;?s&fV1VFL-PwlAcK z4~4M8lUUb^lC!JtUa8KaopQKL%@}ag6%KC+e`Hs{vbTf5k1a=MchYH)DigD~|3$@z zQ%c{r?(mlEC|hTlwx@{;SXRbV4YN8S*JV}SD_38e8;FB8lH(vUWRAWiQ$R^U z94!ljXt&0$4EL+pYl$gn?VcOx);i}wMZp^}yv3DbMH7dDR;yW0W`n=uBz3I6F*OaK zTLA5|z;fG65U{OLV96%UVlEFb-s5s+q_W#A8?M#yBLJ z8eD3HR%rZ6z@|73GULfwvQs%GNLno(zRcEljDGE_n*Jff5=E$9irPcqU+uFEsvJ~Q z)AWZ0#1#m*fUq~wNDJXPTE15VNBDCb8rwz(ikH@z5smE!L zO;Y5TpM)6ERI%HZ=AVTe8TxaTRQ9^*x~9K@w@ddSyWowT_f`0`NdM|~j%(X-UqUPmXDz%zN*tFV0Z5( zG2a3idH1gKAZp4*gLyhnAGoU{V1Oy^5giWoM3B)rMGffK8d>*TxJ+UxHC89S!8^B< z0DpekhZ3gfSW4!psFXX;czP?z8zlKbJmR;~d^u?j{JWeyw^rddB-8Ji_8;Sgn<3Fh z{0e0Hdn2AzrCXPx#7F}$MP(>1Ei&Zkw{yBtv^6MLSMGemoZ zLMvU`ZZG|-3&p_WJ|Oc~gFQ8$2^3k!jHeU@;N&e~aV!l;T+G zP!oa_P-q9QtU9zhjOh@SDelu*6iWObSPBO{z$)UXrnKpclm9a!y?i#hi^uFUh3tJM z2@sg+)srv|vs28y6&?}SB#`gGnx8o*J#i5~BQYM(FeWrUL9USy@6O9&TS2^!_qXF<%w{PBP7~7< z6ZeIngQ^1OSTaD!)KN0#&SMEs4#E-Si2_gH`MMj5tn|-CKmYv>m$?TI@nh z0vEUrTPmbP2C4H1CZ?f-S~G-|6ba$160%MX2MK%1qge(Q@3EBxrW-fXy|RKqy)q?B z;!BWHgeCEk3cJZP8PlF3lZ-AEJ*whj8U!Uc3WkuWC;Ks25b_J3ZGd>%_BSaz9h2P9 zk}{8RJbdgzpSfB5d(V5&ihWBNj56q{yBI7%t0CNtQl*IIs^onkpdR&Uuu+9o5(Sp& z_@X}d65$k)Khb*j%fClq{Ke9hTp5>_^#@Mt^QM&2<_;ihLBtiJYpTXODXTXnRK#p- zo`;bq^5{0i0QI%U9Oq_*+sA-}HDC`dutSSBD>@?7Agi>IO$otNsDAqWl{1c0P0-oX zaBDqJp-x3OcLAO|io3Vlg z^;%)A30xy8MWF9zcpv>hl=h8kltD$9sA}8{I>WCZhJ39g?Ve2j?tGPWECkANEu?_;LGF2g%q3BD_a;_i_7EgDfB;KsBQ`oEJ}Q zutW8N<3?dnVSOjYq0Yq>84MY@8B5_N1q_wC)58%@bIwx}hNW*u*3M_(Cmid#Lrz0y zf+OpyVEcIrC6YoTM1q|LWAl>kPl5;wnt;-I4!KJ=;=F1Nyk9%U!GP^yU{{^Eal4Fk zCPk}0#_xB`> zH=yoJl|!}_dGsHbBoNHGbs|mEl|U24xCl6^LDV+r_M-Ixjbx|K?)BOIK6}t**VX&k zK2|(uCJ?)|?>;%T^5Q2puebZg;u_~IXfSZ!js^o(wa+VFcXJC6*|C8-x1koQ%yH|z z+yT#2TbbQCL?w_j`Ckj$iVOExW2P=(7r+|Y`qltBbpq|9ublfr69lxqDck`?e3I$4 z4B>7$cW1%~tpMIFs~627jG0k<#rZ<3@JQk06&<54Q`49gFlk}lcZ-^|>asL@Bc5q@ z#ExQ@jz*+5Ia!}oc=6|k+$^U`Top&(F*nO;j;3_273F3*dx*z3HaDx3uX3BHrS|{B z3PbG82#+qT-1TI?ERg)tULug|q-{=&)3#9#tLU#SPsW)laGN%x+y18ZmAQ;p;?!5Q zq3JY)mgSiv0)b&;k&V@;*MnACZSJVs1)1TCRPj$D_$%cCrwaY#0wCF6{+LsSgXM#8?3XB?d|PH4<4|8+1?&L zdN73l-yS}Ei2pDCWB)R||LFe1?RyV~4<7!@_VE62=K=ed2kRV^{BNG+LHaM-+fYk{ zr;E2ECnEp<2K;Bz)cm*kpICoy?B&_I#<9J<{qX*M_xeA0FnsXfQEB}j-G}$qH6Zi9 z-}(BZ_9T$jP;O5$UkY*_1Hf!X@%|9Bh&YL&pb|y?U1T|*g60!ID^RX*nv6LCcd05z z?1zKH{hyT52s#jTnlJ$j4+bj$p4&POApaT)4(*DUgd(IApSuvRFtIAZPqKmd9+e(( zo))`M$}3z~5X-M~H^tVUN0CJb@aqSJ!G>2111(qQz|eikn(!Z}Jis)g-!OrF1mMz$ zzD{`;$4P$5UMACN692~`w46h|%XrLQA3kJnaltaS@%r#BL~MZWz&ZO!Ku@|v#Yvc- z&X2uOG96Hr4*b8tag-bn&USXZuY)K&266EBZ1WGGU=#pcK%>8p_DS(XM>^3hjA%ut zKRvngo%!l78noCAENUqZg-?Hc|Hgi8o<{aNI1n4+_BV*U-auD(M#PWu*?U* z#b3-s4#X_TPYq2UC?Rxtp@)e^5tR3bAU}N*et}SbrG34aPbNHNzrs|$bAEAfRkArYPhijL}jyk zHGz|5o6mL&0~8Y~!%$zAW>%b2MW?@(dr(b_-pW)vnDO{+GRAZexm+f)vH5O`_cUP+ z^B~V&1Q`d!HBFB&1Mb>zIWNNO6~a6x=|#owFQR1hj&1H5`&~6!d^mDFRLz<{T-NZHN>SF_ zM%?+m%u_aG>2u~!G7sNWXo?CCF@*ApQ!@Pr#|hRefkRbFSJ?<{JtLtl+u9>D93`HwquCE%YEf)5J0KEg=7iw zloE>;O{;TJlp&r^c^ZzyQ6k$t7pb>K<5>>HF2NZ>g!Pr7Rgw@t648MMETwES4&sEI zvRhERCd@ExOx2ZO*?ckyzp8o`?=s(GJ}i19 zNjfgBobUU>rXrsZ3;iPh6x(-aIK1E2&u|Ohf4u$h{*#AKjOVnK@7)_der!Ay`*~l^l*FIctpF}d_r6J!OkP&ncCU+x1T(;p409&N20d(@ZRw8&f_QB4~E;@ z+nzbHY4ao?XH>H+nD%d+*U~9($&nqUs0JmBLDZ5 zEfBTK78UyLnYw*fSx~H-U&?1G&!8B#4DJfV1p?BFd7P&geVOP)5f60zV}v_0KUOd6 zyAqZ@!ZNG!w|)U_1%dG~oDxI^WKvHu?^T$ZNU?W|ShYV0_(Vvv9W12CK5%u7tX1`(1>r z)kfpOxQ;AQkD+)}ouxc7jO7D_0?(?%XopSS)n&M$JaRe>V_hpq>YASPQo_o8e{jK{@7hk7CN^2g?f}= z0!8cPVVltv$K_CL=%7>T4Ia6MMnN9XqH^$3r`U@HO&~ThOtrOIJirx35F&q)iMni= zCw|lrOQzENcV$jiZd38T9UoZmms`z%8f2*16nY0OJY~Uo5azPQjh;79(RZlxg1&}t zY^aYAJZJ*{+SD)FA-Q5nfirb$muwW|qf_)sZWf0FUt-}O{8fKbecwP3JZ-C{LVh8{ zG~`e>$PhlhWm*Sabe<=0am9L`vb|B1AWA$S6XMshEyllwxkFppF<7laTSB~DjtR6> z18X1JJdXIEY0rIMtxHkus$jf@g`jZPO5cTM#~?%WCtU_ODKX$e{8uy6!lqKCs>-{| zwd*r0yO}5qP>W}R=6Y&pVE`b5C>J;GZTf5;=OLAw1GOGp9T<&)`6%$7=N#WhI)6pg zMX{ov;M@>y@#p3ba#`9=0C~n9crU~2QyN_mbfu_yMoCH*c?}3-7=KpGc){&ZS=0Qv z40E8MeQ`%Z!7kZ+GLOV9K{K^6AOedt+oUbfnFsJQAgN%eKSMx)K|}g|bi7*(Q7Dz| zDp33II*HwW>M+c5@xFS_fkBYx5b`#PS5{#Dk0$q1u+Q#bFb(2IUXq>+qA;F+g+I4u z!3odcU-t&$3-6wHnopxmQS!n#<5$8>1U6x{OCkkABBbUA(N5@RB;Yf9hM`1Jx3{f1 zqF1F4OhW+5L6u5Fl|!H}11OEK4gyPaQ-V^cYa+BOJ`tBZo1gTUryPK8!)$7E$ZIh& zf@(`rRb%G-6ckPpZ&)g%EZ?T#$!U&m*kh}bDS`Uv5-6gPBo@rtmPgsYi{wz@N`_(l zq898|SgK1WOT(g=n^|1?Dd5G})%YH4>gFh;KFs?yl<~6~Q^7~wNL%xZ+d9c8oMd(9d(R8Zs7}O|4q{A{oP4hgVl`M{a9!EUO^y7If zegK@DlGaAncwVq&SAy z0tTzdjxBSdTC|0EvD@N_{>Vwd z@FvTX*-WyG{f6WeT3gupJZ19??#WJSY2EKU{ifuW0x#*4d#-Ced8KqCO8FN~P51>PUA6u%EcZgSct$jM)-t8A zNew@;Q1gy2a#@$s_UnMgJqc2$4)V|j?=^#Pp*fgQ8K%uK404JmIxGw!%!o>85I4il zGNWdUFf?J&6`(Db&znPM;_}0h2eR3!WYi%5AV6UzD5{BHm zd$Lir*3#SMABtxc2*SVd3$hvrOdk;{YaALfTTw*C2V$!z7zj~DQCA>V^{XoOkl;iN zwki&qJuMza=6P=92?u$w%Qi-*b4c1!Ir$_?9PjgZ>~2UL@#NC74|;>!W<1_y8xwW5 zINq5-$xU}3sW@k=f4!*sDVt9npIx#)v6u5KPXyJzD=n>%sefX>T&gNg3H=LehkSvO z49P^r30v5NvJohjN!4U^6I60}4)&r1LR~CmL$WeSK~`REbIh>P?Bn0~1%eJ6!<7J6 zpQ_bT02AoI%pcM)=U2haMn@glISs;i2?nK#+wKNhF>eSO`bL(Hc8khkH;$dh?VBod zabZaf2bpLI2n;P1L&Hj1x3Lo4)o$bCCG>8S>k5juoJO_b{Uz`U*jbT+ zGBYsvI!%IB90yflM=YO_P;<;?Azh(53~1YX;@z(?yFh0;AR&mJ?qd>vj^@>r+uWc_G1_vyC z%cyC~dCmA;-V%NTcZ1UL=2k>YueH1#thRZ_{a}?HG~E!^&{yppVO9N=Bjk%=jF?q{ zdnd@5pG0Gf;Fod^HY>g%qlaWWL5Aoe6z(r8e~*GpWN4`06z)9#8fK8zCQ2VDrIcfU zkT?u%mz){6Z?*}LE2Kyjn@WQ)6D7$ZG!by~RRtvB-ot#l0IJ;+jvH5JnyTY^SNOqI zwK1g`%j2;a<_{5SL6jxC7?K7A+t_Itk+w6S54;@;NNbltAlB`&jD%->EXLAHqA^4l zdHGi;z|xEPx$!5(^J}bbgxi>i$N6cRoCC3qqyh`P`#p_B5Q+b*k$!Ng|LKH7*!Ff@ z`j!f96QdVAxvOB;`b=k^mah0jf($gZl8)a#Bk*#z^ZH@SfemPS~`ea5c^u0HQ*npihvxCIHNF`JL7%4RZem-2MDN8Y2NJwu>7=A1Oxi` z^DLWB=}sEttOuKFFp+|nPB=&Q^j+2XM&XlXWwq5BW**6&#!X^dKKVh^hzUvyg87sx zpARnP5DB9*G}M_*rC)Hc3WPyklIHn5En&t>8C;1bo_6P`>ojnkmi2;Mwr0um zE`ppw{cD8zRf?~b2@jlAyR~Y0R2vh&+Dnot#wQEN@kuv9UL3-{fgFQr@+l?VijTh#&FTC&OW%LDsA~uoascubAmRSS?7K0?Rn6dzhyj01+vibdrFR23T#D zCMUo$)J%pQ8$C{-WD<2q4ic>ZMce`6RFRL~C)-k=O&V1j)q!MG{Bm!+F&W!=;b>Bx zjNNKWgW_^oP9m3o!*DlxIiJqtg*N>+p&RuXjG?W5q~9qd*fUK99RK~QDKK;H-`T&^ zPS2VktIn;j?x3D}t&}-)JLoWPWc%ziNpmOPhh!l|bCpqNOtvY1z;v`C&=Deh6R&Rg zy`Q&x{$`Owv1%rC2Qk_FB)}MOtYhYHYfJQ8J2;k?v*ub$k-BaTZL$ItZ89z&r}dha zd!`GjS(A=>))G^0J8kQ|)$2 z)etCuMHI&8KkV-+gl@TDm#g1usM9plvvDH3qznf}fyWAetQlExX)FcrWSuVp#xV&J%ZdwWjNg-`f#bwM+LvsPI z^19Xe)>K8mmg3;BD>K&!2y&N(Bw5_MUHO`U@R#2r13RxnHH+YsA%{FCDiNU#NXcuw z5Ot;YWI1xH$cQRoP2(}8^vY$$q>HeaEG#XWbcRkx|FRpthV>TkFkBzkNaD`Ju|nzV zWe8S)Qv*ba45|{3i<;|6`3n?ty-bL^aNMBCYDv&?WvZk=c_nPb$QIH-Uwu}oJ49XA zHCkX@-PDb)NKuHoZ2qX-=GSp#W3FpETWgyAw)F{%r)4ZJbh40mSt}c6MZs_lq9j_K zQt?tKZoa zRV6xQdqoLqrnEnhDec22Zfr-r?nK|xqKm>KvVdP-mKMkJ>Qrkld>0e1{VDytptIJgk95N+Rx7^fu&rg$KQ z0p2+i2x+4vg*YshC^#tHkKxV+yz4B()R-G# zADbrQPUeMaGG5H}=k|PIgN=?Z8fI^L@!1H)*-jokda!In&QW1aU=p}#?iiijF*2%! zQ0x+BIrQ$;^B_&H$bD2;4QiY&VF(23wlxG2D`@TB&8ydO8UQJz{Q&-57S0&3Abn%A zAeFflF-t~JHVUx2PL>qUdO=zW;wy3!;L5eIB(8m{8$AE8!L)^~JB6-A<$BYh#h`|3 zzmvi%TU~`XopdGgWH~CgFd)KsObg8lq{^g=SeYy#SK2xnuSYz%soK>BS;@nTSt4&B z`<0A@%{%;MmBtj83d&rWc@Py-0S+6AARtwp0JA~aG#DKmwy@_|iBUp}>Q5Q}0)u?I(|WPWB|e(hEn1aA0!0_i5!n4%cF6V; zC2A{CZk#3Z8&_w#?8+9>>vy-I7F2gE=KttJh0hKm9$r_eZD{LIS?woy2A!Mo)2A3d z_$b@-;U=GQ>@g!~*0@}XsotJ1Ysh$*?JXWkqj1Vc$#jZg ze4eJOu;QT|9_R=$g7avM;g|@kKftz(s3uvF9;}#D)5D4s#BgevvT1}OictizbZ=?r zN>YSs;*?#AhD|7BI}PG+HjfB^KFq0p%6X8EGgZ)uOnR3D4_2D4d4*D8x#GySf^)6X zQu7hSe>-AsbN*GquxzpXYyK)!W~i+#CNKK>m0&jWw7H@jxp^eZC&=JnWNDj0aNo#F z9gQ7!f7UK07`|>cj9^VEZ1pI4iM>B%AA8<_rU;?A^4~g(=~F3=I7!(?#B&z1r)>K> z7P3EEZF&?7_#F%X?cc26Slk=tn;*kZG7gwzNGV{~w7%dgo>kJ(4zVr0Y=!K$s&aK? zRsT%p`D~u6+BJN7>i3 z`@766IgC!O2irsA5xTmp)>7=os%;#7aaK1D<7Af&@9zxn?>yWwp3}?DLde_2vhP^D z{=viH@X`H;5AJP08hTG2-YXV+H(wgwfAIL8ckjXQak0j``PRdnRo$cY1t?h?fJ3B|)_jd0++P!zr+kUk3-{oTTg*PAWKDh5a zczo}_%XR2WZEipG9`4-#Z+8iL`|X{_yZ0Y@PwqYX?-Dysf+$;*bMD<6K7L&0oZ(e) z&i14GCC+*5V4TNwj5B=raQN7J{NTZZCeFEE$27!RkB9dkG%(Hf_M=C`ZST?jN2Ou8 zSmB}faQLJ()7)=n8rPfEO!IK}{v+?va9C!Vg;MpEBzC9owJ9-#0(O_!)D0};>{MMl z3cai6qN3-nzN;|Ceq|fbk*ucuC*$rX|5J6faTk@VYRmsFHw!JR_w*Q6KnZGWh4f%` z1fa?9;?bk0d%5I{j3Ve)G_Mt}2H+KSnuE46pgz^k!XU0#Y>WMc=fa1Y2l@Pl#VuJ3 zQ?)9_$~>!QIo4&*=?)Cz0WOMB;cP|YZaeJaZmAxq!9&f%ElO1lxz<=n3-JiTmpk&#F_@r)`Bn2I9F33FX zrsHCug(hGu{fefs;$?Br`xIPTog_2}>uTe&m3{v9gt9fgK5KlMcH3q?7W#bXt@L!>8?Jvh zjQN^%Z&MO3t9M(db5J|?jAy^$Qv|(@ZFYSFTee}zOSOv)9cQ^wEg@iCI%M@=+OSxq z9@mAZ9MRS``VFQC$>tXE)H2gm>+sYvKa$=|2(ljYI1fhw)3 z7Rnz8N#WcA9T9wq24*+3o9pa`M)!Wly%n|JTW6ct*vz_f_yvb+A=>@Ss|(`N$yralhm@T4*c(1j$yrq!H>SuURbRry z^ETt9RgxRx5krVySS%^z@@h@W>8Fc}%e@Y6(@D16VZN8${NsGDvy-t4RaiY4)_$g6 z>Fid%GPWpeH5c2JI;qK{E;&>ukeYeccqCtx2Nw6ePkmX=%71`a>QX zE~~k!8wjcYB?f#gEb@06q+|SP(m<^Pz6q88|w0~6DlNMQtpPmi-Cn&;eOAHds0 zg@#R{ppL4>rAVTt40`eiEBzkJy4vAC$@?bT7MIKa5N&D(4w1KG_U>r!kewyb91y@@ z)o}IkcW6gyr(rpp@I8+Njy?{MAdyn_Fj0H1huOX`@?zDxrff0d?#6^Mxo>*jV9L)a zKWxg+^Yf&qPt3ZK1+Wo<)-9Mdw-72VcSE=$s>w5Y|!TvP>>o4KWdZRusZ(xtn)<+G;+ zJLqk2(dnpV8=_hT7QPm5ZPM9Zcld8qpZuHF;Ob5@w%~CV7f!S;%6KzN10A0k<-@D% zZb&J{P942!?bQlB@V%mt~wm6I4DqoZ%=#sP^hca@ty}` z5j>s5IVtIt*pE6IsnXS`2;}lO;!Kb)Hd~Zs4aOZ6c=^c^8ax@Qf{6LTWM%9vp@u6M z7AjeTmF+|7wRo6BD0_MNKkBi>n zF85Nk!0k<#uf;sbe7LBeOLL)=QgyzqDqYCnPqu}Bv9lnW3#<^a%alJfA%7A#<5kzgD*F#A~Zxd}{Z0 z@o)6vuWQeP$Kf}#{>xH(odUFUd6C0vd3)(j>$TJSX6`wI6WAioYD;*1W~knN*XOg!kRj{j8VCV+|MX_Hwnl%ayzbeIwVYhWLvT z2NJz&<1KEQwsYge!V*hTDah&Z?Ydmkx>Ro!C8QgxdL+}?JXg>JaS~%L9droFFqqL& zo+Z&48h1S~GkfsAK|Gc%x&xO~f38*qG-u2KJTpkc=z`7T@E>#TvA@ay6LLNuhgiC3 z4hFiB7OFt4Ox1iAv2&0Jm|q~+#r)(H&^s?wmkwDEMa3nxk2%!FfLNF>oQ|FdzTCLi z^60rYke_(>=;#skwz6bu1PzoxGlv*^fT4<`B$g&zU~Ha(6_||g@cUL6XFSeA^tBqZ z)=u~xvUE;^uipZIDnN^tlU?)2qrJys|B-K8Ornej`>iP&t2W>+tZc|e z_Ek!+SUy={EE#>_InssA!WkzQl-lM3F%|m7!v{8yY*KFo6j7A#9OTPsJG3pX+K^=O z{*vZnxv%l;M!H!C1-k1jM;#FF_8?!53sz}Mws~PGYvL_0TmvtxPa-U9T)w&Nuq^S{ zD{Wo2W*k_1Tk|rcUpx74=8iNNgI%lP`F8ETaVzxg0^YRES2RgCE#gXUtmf3ro)*2K zRy4Pgi>GstE53lT^<6^Q8ZM%RHW#>zI+lvP0nX`D?O>U(5K@X2G=EZFL1)5kg`Hi?-(fKM>^JW0nq6_-`hpp_@=JW0QJ>@U!dPH_M;mrVey zTm#FDAKGF>+;yLLJ2KI=YA2H|Xo1A(D*cwNLl0v`U2HXTsK2i*I}@jpzNVS1cQvYR z9IKto`njgo)g=E}EH6$6?x7OI{46eRvUlusAAfQ~4_~pcUoc3I1wlR8+KJTVhoq`wkpo z;1(A9;6lUIIIwTmF8B?~v9?x(wuQ_s>%fwX(H<3Hr(O%AW*x_eYvFYzp7+yNVJb0n zDwlsBp^^O8FMd4yF9_>+{dRBv&1?MEJN>VNqt|bLIQlP4Dm1_LU;ps>{aasDUkx)n zL*as&!h%}4`YF#-;v6sl1i}#u_5l#XJh0jYwoWD!b{>Q|qB7yvuXq$(_-vZ7D2Y!X zsv%}P7@e{_z3?cMgANatLS5qw1-i=1rj~U)M2Z;Knf)O^NsDwxQAE~H`DmVI;TiXh zm*T{_nEQZ5VQN<#>mirF-bqA=s51gdL+ zi3fJcG0)FAj}=?n%`C*>wQN1yb~Co#sWpthZNNUo z?W;lDu1wvj({+|tblPb-t6i#9=`0H?EGy=`Hddc@Ow)Kkw>q8Q24DCqDGQtJLGd^o zAq3v}DJQfi!tk3U(HIPU*=aJ5#u$8p@LblVob*NlB5Y)Z#uT;i^#4H)*L4=e(;i>Wyk+Uh}WA_o5JbLuV zeGDdJ828&`>_FUZ5}g{iuo7$0!aoW#A@JPt5H!Z2BySS>n+ zIDI7Sr%#){CsaEKE6Q@Q*2XrWfSHO;L!hqF(|MqLDUype!1xZPq97h|{30X=#VqA# zp-HImri(glLZM>0-lkL0pCXj}#*C-aFv|?UO%Nqn9*(|Tu;Vb#HbtzI9UvvYSFure z_pk_|ehO)SLa&7lYD%o~CS`C0$UD>Yi?CJ@!DqTEo~AGOn&d1{16Oj3@U;ng!s0}3}Xr`TW4JX=&BRUvJs6lU#PiKQ*5X@!~ zhp3Q~ARR|MLrbcpH@<`;7q44al)Ka^fRY+*^_-^E&aSvxzuJMiy!IswpSjlJ@Jf@! z+^`&k0J5PNoyd=pjnbN%OYXokU6}HMRD&+$84TdTN36`S%kb8qD1DGiojt1PP4{kUjfUQI<5s$JeP zdFYnceuKRBY`4Ty4h@EN)M8jSO@@`V8KyKECleQN%5T~BcgMCZG?{MVufbmKGB>&m z-?)IahQwM6qEceel@&@bL01BdbfP1JH^%&4`K7+WACK*KERwjAo4pxSUyw%?(H*z9 zof~!A=~(#lCf&~KZ$P&^ce8n}+ArCB7PXT)y7(cX0FH^ROgmwvI5%-LB4>jry=@UMA3=$XXQQ-<&ul4imz z=kX}yS)T>K=Rmfc=m{<-A>n&N1jT%zqm59axW-yFdS!@ihC{^Sqy*&t|WJJox!dG76%f zkN9->kRe{;>g1C zpP13b$O^&nXt;Avn|<-i=T&rpsY!V)U|dby5%3XP4W)sOpu0;PNT@033NNc-mu*N} zB5VWmeOFun|Bt`W8eIPImyFLY{Ts3tgT)tvXls4fip;LMpAWp@c0-Jrq@=z;pd^v% z+1h{zNy%NpCt}$kn$^SQ^+F;{TdlC-)^JlH3Ochv;Wl@NP?hc!9+$6-a{RmMlS(7~ zVhpt~l;tf$T`NPaMXoFZZTfBS!;;irm(X^3aZ$}{8(!Xl^w&uKo4F+o#$Yv(^fpVZ z8shYJ4X^;(st2UBM!fNS_dRb={Y*G>e2(+aGxu90rE22Z+x zCS9T=WK0SAc`)<6FycoSGr>i207f8<=2kZ0B_zT^S~7w=cVpCq@GA#($~sv zsQ`86AX}`8D`z<_<v+P`cJRp-kydddT*$3O}kg3eW9mtB!YUSVJkNK7LxX;5Th~ zS!waQgC%b2A+k<}cH1|vgNNlvmSjoV3b!nIvsrTE04HH9KJM_Xwew*y=IgqJsT#t! z%EU{u%+}rNh>BQ6Wze~q7YEB?l zpJF4$VEg)Dw_JObTVQyLRX0oDFfOgQ!uav`Fd4|hN zNkh~A=DBpmD&ty(U`qwE#9=NavNJ!qrIl0>s~wasi@Rn1zO`|$%Eqm5^}Zdew%An* znX{WfkckVH%b@$M8MUp%JSoqciiF*;TmH2x7As`9--69~Q(KR3IqBLssU*6-SzEDF zMj1NiH^yYwVU+BMHE>Oa$xUryEN2HtNyamsx-{n5C=F+Ml6D9GmTh*e=x1W8j$k~p z21R^P92DE|Cu4t;O87y-&pd^RMS$oE9HTX@G?|~AViPoSf0FqIzU4HyU=gq_D0`A} zs_I0Ou1uqB4}5{|w*$Udpb`v?W-^wL@fs!USx1;KY^kM5S<(Q|1n{$<#6gbx;AAXe zqTTN`-sbc)TSAoAad?XoDJAAKi=^B#XuCUtCY-f=&Auf?Eiz|OK(1b$Zr-1aQUVf+BzK2Jla1*|&|7vgCUhqHME zUw((d#3B@UbUIDO&OqQcadzX)au6KgCm5lU8~&f!_iUHlVFUIv`;|Rocl}LK<0IoK zROtprO?B;`Oc9zZNP^=F_VHbSby(q$%ldd=3S@V?W}U-W}~7_RWRBa-8BStX3po zqa=bLZL81>u#S{&BDFWmQyxtFI7Qt1$FMms*hh@eetY=p9RuE5d=`j2y+z$*rF8K< zv9U6C9As2c0pt^IiA|sJuczU0m{Yj8s-zTT?3_o@F1(4%1zl}yLOmWR0L6o`dcgBh z?Kvc+`Nv5VoMcaXY3~#6Pd}T_aOWozi(Edw=a=9#Kf*40x}7|H`0!J$0Ku6xDq7gf zE<2d?wmy zjMZfAYXKGZQ@>D9Mc__J#hcc%DQ(Iq_o3>jStwqmyTDcFQ32On)@!y7A-BwF=0yK$ zM|>iB`6_=J#3#IjLIQ=)vOJj1luJmM-mv62k4L1rQ27#<`sfGHgh-c|ihnBwa*{+* zat`fgoTYOJXezXEm;GlD&3PsjSWcjCG>gpU2(0SJX9<+x69wBut+qb%Uj;e$GxGSr z=R6HZauY@27tZ|NaOd9r2M-@Te&TKGtPXORz|7BJAUF=#M8~KAp7AuNjD?oXadN3_M zShS=)_SZg{oY)IltISjQ*ybq2gc5Sf%#plW*^A^uK8}JcXTfL$b!gyWSqhsS$>kg+ zJRK2#5O+8Qyxqw(86z^_s=Dbc#G81grRk)FdE|=ZGx4fRLbuyhPHEeMN=|ieIYDb} z3;13(YZ|5w^}T-asZWGNF)f2@lO~fZ6(=jOH2$sxL>CrVpjLGmKzbtCwpAg=*1TM> zAuhg$-}8UWIe^)Loi>OfatBEqJiJ5{ExS-{Et+SiI=wN=lQcLnHt<!?zPq?Rd4NkK+T{_WffK<)wfa+i77c-trnCz1M>(i&KM7EVTq$>gh|<(G*!3{cG&Ya3V8UgDrt)MUD)BtZ z!y#e0oD|QPa+DYIci+edcPtq?`_|-HBgH*(OUA=lM8WQl&M-;Ba_}3g~CT!5pA)1GN`p=M`f3F=0hBl#|(GYi; zXv_%R!EwqDY8^&2+g7j2X|{T~n~_~?d95%NrnVS{qu^ENfz|nz)Z%}t^=8K$msp9xdg zbEC|Ob?;El1F7m9Eqd3exMWmsT<6`PFf0|Vj&bi_XH*D7%tij#g2(E4huSNn5qDB9 zYO-wBCJeHCNyz$J#_Y(L*UMwK>{7)pD_@tZA$7^RN};N4JwGcw$J?$6Telv^uJmGY zgQbnZ*{srj-CcdE+6qjmQO_KD6jN&MGxw)N--;jQ%$^x?t}<)iPU10bTz15cJ!my% zBWtHMr1(lD+d@03LBid1HeEzxYsKH~__j)nx8pr#=x@&|(xg|)sV0)P$*3h?(-j4U zAg8sB+FQSslKs0VBIy$Ql3$xoemkeI?$+p*nZ^5kH3Jo7U!|GS{YG^l;^7*ER9`q5 zs$5eA`u+}-`c>aHoB6KkHc-t;?Zi}pqr@n|--q}nKS=sN)!iJ2Ct;jh?}INhoq$>j zAHl3-qHU#u`tO3~Y}+Z~%lpWYYg^T%aJV9;lEUlkqr4Y8^Z_JvwrZ@5MM0u^xs%Ik zLZa#+DA`tfQ@>ZQL{W9C!M70+3v$P`^Ojo<*f3MRS6=kL_ALi2^ryYAPM4{6)4~2# z5nZDsRym)2=~UZFCR_6Dlm{aSsgT}2*=SLsVN!jVv48S3xgkDVph}~|w$@oFu2@IL zZR=EcO!Ze_8uo^T;*W;im-j!<5CgMgD;#i zg36#-6lm-j;sIn52JfB2p4MU#VhQ5XmkOauZ6nJTL9_FMC`v{f!-w}C-`~`rRz^IM zWf##e$dDtKeM9TpkZGaJ93aP%2`&g5KJp%_(m*C7TkYYVDvF@tjyHVdZTH#mo;Mse z)E8PEA1lC*s)O_U>)}DyjO%BzveCKe*ctJ-Mu+QWxLEigsyd9sKZWEMZ3a0zKMhBi z+LGm9YJ~O*wuH{7lKW(8e=EVCXWqK&w!Z~Uf95V& z!0vYyWa}cOu3@t75a)$@cay1wAQtvy!JJm6S(Sc9&`qgg>8u@jJy$6LG$u?!&6;)UQm#t_*mhn{Xc=&OY#90z?FG@}}@MHDcrT(Yy`-M>yO$4%p znF}WeoAvuL92@?`3zcz?F9Pto=tgX$EO$2hf9}2+E!Yql3e~jLnAc6%3Px6y}iLZRkJ}`}ZJbdnxBH4qx@LUZlukx8%AS zeJ@jdA=@prxZ3p?463JBUb8=|k$zvh{{{ni@DWqqciHRx!&m$7cUc%k{3M7B^fCxP zH`fkTN28NZ<(+8^ToQKKanh~i&+x+ctwaGO8K?v|NJu{hy2IHJpCqtXQ;|o708Mz8 zeh#l3h9_|l`IO74$4&17C&Np8Y^53?=8FMYsTw0hffa91kd8TWVVXn{Pr;1N&lz_3 zQa#D<#rW`@jV762lppHwC7Ej-g=EP)O4u}v!zrW#PWcpSijI;j z&y=YHZMuqmX6W7$SYf~|XJJ4%f|y5w=QRGdQ8qE-vIq_y0i z6j~ir`T7Sb{PIeB152hBOYi@cZBzq1qmRYq{4oCmAeLuFq1!6JUG^thso*%`MeyBq z)M5isCVgm&MZaO+IlKok$Qm8f6{BAeL?dA|1 zw~kZ5!I~XwWp>#J>nL}rnrP#TE&5p8;I&uijDz`uD9&!Qp?t2dR(^Rqxz(rbM-;i2$JJ``Ul;V zt*`#cUD~kljST~IcR}j{$Mr;Cnf_jDfPsHTNW4mvu zmpVOCWU8o$Ay7PKQ7{tuj;}CEYCa{j8rU}jl~k&3Ziq6R?elR z2ZGkBRmzc37f)d@lByG3unh_?#;_#?i@2$axWx%f`j|uM2moo%44-vX9YNc9?^3D> z25}4o(xF*Zv&UAbvYTiDORoi!2~@(SQSx(DKV~dMuYt^tMMIja$2oOiRe-Bf0oLz| zpkM1nQCr*{uqX1Syu+@O?j3D zC)~@w<~_1h_eJ#Gf8z8o=uFm}S8kAOCBwWvJeIW8Iq9q>)Gkx^@eHtA#j~ zQ7SEAPSr>W?et1uPQ`^2>K7)3IFg^Y?3sww!}2R}2pQlqml2MB*`SO*(UbPE1s|u8 zsqhu*QK$Whph+3XnXpht@WQl3y8(2Y@fgC4&p;a+qe_;AP%x0^I$x_~m2 zG9mbG0nX<7g;VDUG#x``MWGemTBFP>2C+Hf*YGF}TmgSuO(B0e;?E%hWz$Byn~|;~ z`Y;I5J_7Dq1I!FL&@IA@@|PAgf#_vc>KopW8npR>L%lKSL8jFd^=FrhxKPAk5nMB= zIR-Ahu|{G1P2Dt+2uC{O+rZcYQJJ5jDr}Z87ji2}4RKK(85InJO{>eVNTs6%rbhSZ zfsV}9g_GQ{ZJlBWR>E>?XFGO-{Z`k=sMa{zm}Y2kEyIj7yMU5m*NTu|_jQ>|QdL}D zG~@Or3^f}62K_Q3a|&D!q(S40^Nf#6P0B_iWbV zBJ3zom}T&QbaGf zx)kDBQg7}OfECxqYVKPV&ApX|bgpZcQDW=A$4Vor({vE~+|k zlCySO8>iPp?~&`$xai?!P;r?nlGci^;SRp&c}9nrOBJ}ig0JifZf?_Rji`p77OggE z2+FoM>s2t)+L?*nUaW5~);IWK9jxMF-RAPt@)%;Py-Xk8UZqO6fL1Z21qIIjy6JMT zx!S8!mCiO8u)hZJI3fYeEq~DUU$$D2xf@-jmVA5F(pN3$PF%O>pB+~q0`R|a1N%?L z?5XO_aal4MzObZqx1A+6#-(R=yNo@hzr%oM8K#OlP~> z2V4PQb;9t)ND*I7()VoCD?bXeoW}tCDq)F)mm0vT6(5CDZX7Ea3q~WJW#vE++_p+A zsXDY`3nxO9eF?+fpy`3T+8($;#VQ5q&VTG4p3&q=o6^KFI;_Uyp*EYv`p@ zu9UM`n!qGv=g?{x&oP1{oyQ<$q6EC;8O}PxQuoIk7VI2ItS4VRQlZdc$Ok&a&ma^; zAZK65;X#v7#yOefHZXV|q$k{@&Mb+@hRvp76onZdCGog)a^i6Gx}I=2mMu&(6U7sX z*~>9YaOqjf&%$J`$Y#9LGN1}5)GnY(zG=uKjsj@|M%c%(6fG&{Y3!SmnIfl#*)IFz zFYwI62bX@;QSO_w6fKSi*<|h0x z4!^S3vt)F-sg_KNL8;;X3PrdnYYi5ZmB6w94W!qh-7D|87(9Mr6^m$G~hGj@vV2NolU zi!%AH#iU~%@f^19B#ENroCpaKYgwM8-2F|;=|~j^LaZN1N};I4abuKa#*!4oSP^v7WsVe=6e_JjFp3GFY#1;=2samu03(XG_ZouSq#=)=EuJGg?lI-exeRD)5VC z;~1LQ+Oeor%+o-{!#tT$!_sG4K}~SJXd2oe{^$*}a@m434@Yyzo>eCpih^l!hH&x{ z+NIAv2T}A{y+z80cuxslj*hnQjMBZ5*-VLYQSHYVXhD9xG%|OMg9GF}o#A>#NzKoM zbHh9>LIa&9PPUR6sWU-Ldc&#?ONr}W9;fW%p7FXDt+J9X75m(@O~fDQbTo=srv*)g^62*(HaGP!Qr8o!h!A< zFh3KC-KuU-pOR)}1kNZ)Q=ZKd3N|RDI+NaoPHfW{AuGZZX5l!K9(cp;iZiKMZCZgs zT&E0cC?+Y(8&qQXT3I80wp$RbR(-n7U8ab%E(v8L!pTDPpsl#p=PLE$u5pJrA|)Qh zMv{bX6_lt067@0M7xn>h*viqELCDL8CQ>t|8M?6{wDdWfQDbe<3f^N&&8%u`N$!@L zsfaaH!p^MR76NMac3a$Ti*J8hly-&C;@WNl4JdoNAL>`7;R5KCF}2h@0*kwJ1}3S} zxlY0}xMRaC2@wEPwb3abeL>TLG}+_i30TB*0>-Ed(k!J`Xm~;KbFn1A-x$aT9NNyO zCI-~xP@~t%1uN@(Xq-J`y-?(8WIeVE%`^JAbz0@!yGMxDn+8*!gH>oE@tc%}40a+Q zHDVZ{C?KLx)`P&kxofm2zs$V5ciB5gh>jwG{)*uwb|($|FBVy_Ytc_#sz zOPY-5;QI_%3bq%xB8MWY9WM!j=H!g$8F~20=T-K;fRhY{o}Y8!)`1%yRwE*( zRrcIF|5}sJ%39{MGFM(J{D-uCd+{pB14nwQGfbQQYf9;D8k>6Mvec>hr=0=YQgjN2 zS%6vEFiE!+QWS6{JbSpWo<4obdaqyqw10Ti+brb{cjYODW>8Q@>{Mb0Pt>Ic>nA0? zspgpqere{FPI=HRxd5Tu7nK@TCVWR_p`+9&vQxUw{SHL=X12RSI=Z)meS-8B=aw~z zj4H`dx74i#2L|x86&y8`Vrv&1mCSd8>1Sj*3#v6DhY4F1@t}i>)NyqWgBrCm#*gGCtyk?IS)4V=717$T#JZFunc{i}m_Z~m*@=I_uqlC!b% z5AWB~IZm9|qju&W-Y?y?;L0jw7)zWuNAdFg>*q&H4g<6k_z^v0mYhSj6^fqdOBHj< zxXzz)7`&XLT}bHFjys%)dWmDG;DzyH0n2$h#nAjQKMO~OBU9Y(rFh3Lvs3V4p_fKn z?1EgkfVCP%i3q%wc>dUcd_~^W#A#)Awjq^dk$P8J*wX-f(6P#SaEgP2&+iUi9vv;q z=z?5oy~Ox#akMCZtV1|f=BBSR`+#d=w7@HAz&VfAt;fL4nUaepx;uwfsn@QIA zL|!m&ijD!j+JFE0<P*+EIjqBa?B@WVZy^%D>S_f zW9~in0*r1!_JvHOc>?JWX)rRl7-RFncJCPf;phFmw=D^|z~J_b{*A`$qq$;O?_dAr z>c>@gaKWIkqVrV`YIGXFit=`hxKywZUsqc7ZbSA!89)=EAsuDU|WM@G&WJjgOUZE1+a zV0#j~wx|w*!qvx<8dWd22#|pe|AeTq^B4lXTr+(C;in&0Nb@CT&@|8=4_CS27Z|7_ zaQ#3(T>C&Dq_d zPWr;_#ARM1{$1r+ysY@G8|lH(UvCZr*NybUwU4y@`u|ilR@1~{+%?&hPm}aQ;MfO* zSs>gt7|cMU)%G%Fo-rFNT53Lo@i;lps%$lo$4Wuar57wqZEl)^L?Q7yL(h-@`FZc~ z^TB8EoV1YI%o!R7=Tld(TXtGHYgh5ubUaskfbDn?!P3ggB?ZG_Ux$UMMs@0pFkl1x7rfzHFoBfAL9#)Fs8Q5d2zh70 z=nKHg{XI)!UxntNnSUZ|SV~F@1AgGZrK$j+7lwWvUC|UrLYou!(o@zm2UmJ^Fc53+ za8rmBbqRb|N>vvl+aT|S&HL`)L<<-1kH5f&m+X(f@HB<&ph6TTqzH*fZZ|w$?Hmk} zH;woGg5y=$Dbx)P*ywh_Q5Tt`YSbT=8@234j#~Y_9IcV*+fLy9Apycjf4FR&8@k>EC;8EBp3`qXl zXfH0l?Yxz430Vt^pqf;yn=gTG)1_9H7E`9GG~sgER45|2_`ke)sDJ!6i&ljndcHkKUeaRgmln%2WjBw z0}MX^#r5?rB2pSF{ru${$ptB0C13z4Cm=)2Y|*h#N_9r~H%V-00^pa^aFi=?gCW+S z(<9Mj9GWmlh=`LgcO;z+hu-jkdQ3@JAHnSNv}E-9Bwnj16h;Io=958FuKE*gi_ccq zCeB;h94#{=46le#v-X^`ZWLRzC@-;Z+k(8yQtxUhNWHBqYmc~8l}TBsTxnZ+x-HGEY&H`>LumyAJH(>!+Cve#ie*G5k);4Lw;;g~`)8srh0kKUP4wamfF}+O67W0+N zERCb?iX&=mwze!6i^!@*HhLBoRD+GLvYaerr)m3An{t{34Kio=_h5Hq# z`T7zx?j}rX0M2doVwMMK-q0)Qg3opdTlSDNLqd#ne{dR}oPL0cDsO}IOJnIPy+(V7 z`=FTWY-znra4mbb%QigE3(}Kp7dHRLPk7%5;tSpNNKCr+#bUoNF=^>N55~kLrEy4z z@tOg`zFMeTEV{aQzqplK5C-2n>q;3-lOo!B<$i+A)JV`e?&0yc1J4-bTVRNF#IGCU zB${WZ&3NyIs-mI3K?;ZQD4LHs^Kt))f&n}p`|{j_8fIYb0DlBH8IlP*zQ}ooCy04k ziO_Y0HAh)Nd6>!whZjkH>gY#g??-b)4K+@Ce3OlmIVA-IIos|-(Ite~6QiS#O)cl= zkK29r(SL`l=DmIX)91tId#^w5zdL&Um)Gz8PaCIsKFf9ogE2qj5yVM&)8wCF6a`+A zo(y=r_2c1SoQ$%;2Yx*GkKimg#9GFK_k6-rK=l~>B}$Hi=<@+pSQ=1QgJM^kKYt>U z5n}sfY?sX-3J7Y1>fjcI?a*DM&w8O66_^<=oUk^KG5C);(3)Tf;b=D~A|1Q9K(i!6 zcaqR4H6W`<7)Mnm7HH~VrXtV<5tl)Sj!Ok9&9BdVJyN0ZP^by%_EhOyX|w3TgLmdO zKDegW#4c1VB4(yMhy@HpoG`x!;#onY3pGo&$7Rt#9IV!GWv0bw zi50DMFjoU@W^P_OelXi!KW4@q5ojU3xiBqi3g zZFwZQGrexF36ez#F$k~$&@$uJ3+x;0$Njo*GW%5fJD0kmK!6nGxO?IciA_|Ux}Q3A zF8?#?rsFP^?*I#kO5h19e(o|HSrlcq(vc)X{t9yr#N%r;HxDD666mGfH5`T3U_uhP zIDp7s$*Bz1qdcKdpNW?NGOxsL`O+R!6f{kuDX0i_bgIQ(o&~l5q|KUa)2IyFk`@! zZZpqT`Y2|cn;irUZ((m`iWZTKT7CccWxh2WzG4!yB8BMXq3^zsIw(nDR{mnlelglH6FPBjqHUZgcyIvP4K}7ZLHpya;x-S=`me4$3MM<*-%w zBgAhvgWg`6)0LT2j$Q2)nA-L;iOGAxx7!^!?0dnt-!3*q(8o2KwmXVC=oRpyiq zgk&H6>_7T$u(y`qD5*mKs=xL(NIfspOw7Z>=niSb#vJ}tc`X=Be!1JBd@ZPfu6{eX z*Mh|$-P_?`O@?2$2#&C1OQaw;Pa^%4;f=Z#8u5n zq=g|&qF=cm?f!d3K;Z?-4GPJ}1~JTS&4WS>p95tISoge;M~??cqvA1gdQQ(XLuVY< zIaG|Ng4${8esnB;ZNMdisuM#MfnEb3Ng>EnaaJ(6SUQP@?A=EP ze>!*e2v9?>2M+j1hmc2&#XT>$s}ukY6e}gR&=ahq`sc!nQZ{gxZiULAd040vA=TLQ zaIJBcghmB-y4c-C(j~7K2)ju$$^p*rM33W&1!3!Yu(;5r{Y`fcTn8D8Tz?N=TRwDK ziM7U?l{cim6mVbGHX^%K-Hrz{R%>Q`(6JIPc1hS=C2TfA&#fO4fy6c%n60&`#Kf%~ zn0Hqn500A2ZwHDa_sogKFg&A2;AQW2LklOq7|9>zoaNp+YMrVjf_ZYg?i{Zr`sF|8 zo(}u`p&s?__uO>Kc{U8#pdiyE;#oCr04@o=DRFr-3%7kroZ94dwfzoMy1TkI8*qXe zT<(5fZZnrQVYI_TJPRqXVITfRs>{Db;;Qcee_J?5pxdQApe+KWlOqk0eQEbe$78T< zNk2coU6QkSqqzk19A)J&9}UvG1K?&l)<(~NgK$wAd#lgs&`tbzuB>lp3qwYE89HM* z=M*%^2PG-iUtDHFXwAnSWm@h8eYCLuOwCCn%K)c0@AsU~FhiH=RWJb)BAMo|U=}17 zz$w$U%X;vF^z;~a0rrPk5yd?vgMqz<1C=rsYC`E&Pd1b!=#veWY&~xGtjvKV0Cg|P@d%o~QI&W9oi zvnWM85Si|)q^>Vz{yJg&_>NliFeV>wa2x{T=2e<~pb$?Fo_UmTDgiui7Ub6lktIS} zU})#7?P(cd!uTqj=S(NpdsSb6z6=E}YunlFeOuyfZ)J;5THr#|S{xa|%cJFZt>ad| z@#^oPp9wmvfT;POXFZ2+ynUzZ3i3P`*mokU&{@t1K2oC3|seqRFY@%I(S} zr_wdsCzNDrx!gOcS|E{liQo=gRLCdte3){IlGB=qE7a>cSw)|zyS<&ez3mR3uAPTB zyhCZ9{kB)=DTdJ9%Kdpu!&}q!x&DFM5quR_r`hbf?oFKNe~N3dvj}dr+*6k|51S z#K~kx4DSmV456Fh&Xq?+iHQb?&hzL3wj&#GVhmeJ85zu^Y5EgGgv=$?V}SZu4xrKA z>AAb>of_)*S@dfiNJQ1NqffV&bSA)d7kxC)A{tpPInS&yIcGuyZ_(3u6lLwZ4gJvW zZgGv?UGhS64>1KDqFE30afcDS11KN}Fvh|tA*a0YEJI!)cYdzY-^$fg5;=tO!a(7} zZ0anshcO%R66|!X;-uskbqle}^3^4x4e9)>lAhk37)&)Aa3HxG+UI*m@9ZiLP<_}( zQRW3ou}`}`w3~auVN`zEI-Ym_h*9cUUIF3oN{Vb=-<*NelTPPM4;H0b#yJE?NeT{x zjDGOEv+`#*xQs`dgnJ!(8pL3u{uunyDRhS-w{*H|!|rR=lUX##bI^%)Yus0?bdnqa zu?C$zVb1{0fq^`+j8gdi-12{>s*YuzW)%dkGiqw}S(|)X_Ea#Oadzd8nho0bob!j)7!YCxPHK_Oh6MyN8;n4CtEz}=3jW7l9 zid^X#&lJoCMaAnD(Nso}IO@kva1o~iiuN}=FJo9)YbVnwnE8yexc>gvd13#)_rH?8Prib_9kpO5;SPGX=dyXV101pbC#~#U z%=Hi0iVZ$h2wdW*0s{MLmk9a8t5JK?%fyFQqZ-Uvrw4p-Fc=kV1ZlHpV-HL(M4blx z!wCA?&-JB}N}S_nvXR;pySqK5PH+YQ#sUyG&*xK-*MZE|-=PqBPO`cB^^S|pseC*fV8q^ zXMUTZnkVY^MqBRBmmlrzucfyu4aK?JIH}TzQZZeddR?mL9ckRgq1x2*_9a>`@AEG> z{L+YxnvcJ^{$?bGG04S}bTo@GI}{r8H~425z9m)g7@j@yl0|4{T5ov2H z_!%MPDC-R5pP5VxMD&cKL2r~!f;J%3MT6dz7{D_~WSis}i&EDJGwm`?ZZwRv+nauR zV1M49f-N&If+qp{7t?-6q%JAseGbxOB64t%Kp8!_4xR;{uY)~y;AwAAD_tOwZ*2CM z=wsCeV)BV~H$qfpD?g^$1QO+~w-rfMw(?wrBd`XnwGk#N+jvQJj}Q@Utqqx!AKN?N zIEhwj3>kXeP5|QWZn&)mHFeqI&tgEBZ|j{*MOLj0w~YHH0)Z&OkqV#6|SkEG#G44`RMW z>9(d}l$G>#Z(kn13KaZn9fGXFj@^HKyv3d0ibZl!Ty9#Tr}C+#j|(DA00n`3S)87B zGy*utL7w!IYv?<8#AJ5Y@u&6znOse>j0B-h`{2>YGxmd+<7I-$SERm6esPkc-oh9! zL~&e*i9JgGvHd~J4cm&6VWF!F$8H8&C&guHjELZQfnH1uI|gYw|2~7$lz#Co`a#U? z;eQbGc9e|7C&Qt;Zt%2I3k)bVJM3LcW3GS1_kNyMWf*L z#=%4*Fe=EHFc?dbQn3y>Mw0;`5m)Xs!0rHOSR6aUr9gei91@}FqU?^AL6U(m*!Ztm zT7>Wf7b7vk9C#an>D_H0+VMey4p8GmP%bk_axQM;q~*SomX}XjhkE3l{kKNBcYBn_ z>iV%ICz}K2i^Q6P)h0R$N7GE z^78Eb^!U|JMwwlw%=6=;)BV$f=YM^Fdh}m!j?T`h*j=aC&!;D^etLg+a`5Km(JL-< zuhgBt?7uiZe1GtK|8)Q0{OFX5-FJ$;I(dJ%f4={I|HX@wpN|fy(1UWJmnVnEKOP_K zpC6yRvI{>f6+VCe{P~gR^Vyr%uTM_TC53NGU4L_S^nU;R{Pg&TH|KIXw<`vC zcD}F5xO0B?*H`EJ|IHuW$(97Hp;1wH!e8ybJUV;5e<0hbn(Y09gQK%EF62%%7BO3K zr}_M^uaDlpJU)B5e}3?s%eb?9c69LO^!WU*{JAu{N9RAEoc@`=x)Zzq!^tUcmtA){ z-<-a1+TL|%^S|DlobLnJ%+b-IT)SO&R?m-L9-X|At+*2@C+gM7;n8~>FO_pA6!#?I zCQ*U=pm3{Zkp~bi14eemA2ItdaOSXWmto)WUyp5rQ9b0P0CMO!6E;?0g;H&aDxN( zK`BY178cY@2Y)Mb8Yy{jX0u*i02Tp9-a|^1APkByyAVZ?V${Cn$PrG#G3X5HoM+)s zw5ce?_wR8HM*X5@Pp052EuA22-;}`PG%cfDtyByYi%h`b*xv#gH+{`b8s9^_vXrDg zKI%cfH58q&ZWrrz!)f%#;VcKx$6ur5qHBCJ=~}M4)6g6{+TPIyh*RC6uHh#gPY&>$ zXHg+^>RHDSujuRAFQQ3Q*ix!8)pwWsL-TScSnf}Ct)E_;{ILIG*;@5&Ejg_2oh_P> zk733KWv~3Od92H@kCIxJ*YxklssJPIfio5UrR+U*pd5MhL24`Oo&GIA3!E6vI4FDr zyiPYBTi?fV_%Y4kV*h%~%`ejeE8$P{ zw+Yjb_;C1Odwclku6Q`OyR-A{-SENgy>IXD-u*V*9*cVq z9}Nc&9&W|aV9PRYq51WXFCN^z%gGKw5ro6bf$70T5k~{{YTd^`!z_(sP}0#YK@rE4 z@e#sPz^4;5)0F9labOQmUSb*@kr(K_he$!-6*>|*rRU+v)8`Jeupj8=D!mp>4Wya6 zo%>f-!2&)UezSe()IZc6P8s2?gz%N#e#d~FLp~T9QwIYiRJ;x~+R9COt(;~HR9+D2 zf}xPqe{_zW2k8I3A>Cgcq@q;Ob79|60V;(;)=C6e>|2ja(eCc+$96x>SwBN6P& zZd5PxFr7?h38n&-s0zk9>+HfISyMI%P7n76WXl?>#7e=(D1_iFcgcB`D)t61v(h?& zG3T5FnEJf}u9gwohVA8WI{^?3G!=9(Z~zo|Mt*)?x6`fiZsLXUgx{zlv@m;iN_%DL z;XLi_HuT!sm6X`6*rQ2M0*9u-F@gKkg|=_efo(Zs_gt-&I>X21%25L8Th39Nc&@tQ zUNXiD*r8zG0q_{!Tu|ovu``Y{KD|qiK~`L?|1O_!`|kVhJ(iWF3r-X~iQ+iQ#V}1q zxnZ)XZY7zwX(!ve2R*#JwXPql%Syjm)P3b%WUTRaZ&jS~pT$6a2T&m6EOY+o9P=>d zoYQ<7W<@jvks=tSlQ4o5gt?&1tl*%L4#QZcPD0>v;!GWUG;q3A!fp#kWU=j7z%gi+ z8VOD}l#Y>>7%`SjAttwAez7&vW^^x2i` zyk@&y>0st|)QzHglu*)ahV{~hOOlaQ98FjIKzN2`uZzNt!X{}rQ;~reR|Y2({w~D{ z6c^FGi>DYwQSnKE5Mv5u5|uifjWfRtGnA3CG$(fgAWYJyltxP-Lc6=Ydk(k+oD#F& z##UW5DHv_SK~MS8s-*} z=Dw32OEg380VFgWfzQ%8S9lTSXhMD(Tr02P^YY`;QZY7}3qYO=2MOriVon~~20wU= zztfiVO?GOM`A}feGJ;=B$LKgurha}10URh^@ARwII>Mp75(D5UYrJvIQCD5NUemR0 zGyhyx5iHz4z_)*XzJLDnPcFRNFb?yaaih#HtB(pL9UoedJ}zeY<-}mSX4NIXz`Er- zlD4)xSV60~PNgO*G$D8S>5uydM`w*{HEe5nr6yF1V~|QEHo6<74$(1rO6WuAnjbQR1~&bRCW?GI4Iv$@@7}Y zi*Y34k%AS~B&k*MsgfGIUJ#tf$2fsSOO4Chw+Ck zdd}qUNFKjT<56B3o@dJIhVc?_%QXyw@&pHOrHV^q#)o+z)zXk1gG;`vonQ_%wfeQh zMwDAWjuPeNxxU`Lh!R1lnC(piHFCLAIZWf(Bw2sw4v_B3-P=cLD#(H7vo1Ch2q%;j zGUg8+C)7uDjTRpvOA4fnLcz_Y=pUL)Z8c*V4O<1}!N)MJ9pll*Fh0ou-)z+la-7Q` zpdy{dAPgZKy;RrWIg7ymJC}!2A_OQM^|OV&jPi3P+%^GY>iTt<3ho(A2t+GQW4MW< z1icE?o*2xXS*z<0OxjX?IW~I|B>{j#d=$Z79$`o7ntO$%S86b{u4HJwt}#OvT&l%L zwwMsUIE}R(^+b;lhC9;Q*9+sgy@`rE^-D5uZ*JCg4bgzs(5WJ|yHeLK7v7JTTlCB@ zZ=rX(aZzEe1wpz6IwEkA$0;a7jiFLT!#D+&=V#L;s;a#2&MB3C z%^2}*7aLywDbh3Sm~R}{x~S#dW5%2Ne6Hmm0Yz(2lmkqmJX!<sGw$poDVFa>mOGH~2qJ*PGA0A@*k8I6nf@N$-XFmZ~aqa70GtH& z0R#aKlX<_x0J3CkiDK}DQKl&!J=R6b(J^;Na)O@O-1*7j$zE`r1PL^Q4r#&n_{`q| z#0s7GieYj`cK0xorksakEd$;$@1i5Yt-WMrCq>GF!Jy} zPur5pqU9r5@GDzH&C7qQm9%e@hRbPHT6RqvUTlk3*H~kd0ce;4Wd$*Rlx$8Z3&!Bg z)i$POIxB2|!r&i4`KYLb+;XXPzJaYiCxOVmK*55_q7r<)B!5xK!A6dZ~(2n!cQjl}x( za|u&f8A9(HhEQ#LG;7~%oA8$H9Nw z-QL;R{T=`9rhnFh|K<&aT;Lvoco$%pACdRexsk3@3*h=U$Z8ZkaesLlJh6mtQ&nM+ zeCjK95Qh_Q2YjV>9yBX=celRWaicySH*55`S(`sZ7tp;2_Zk&FZdUTgI1L-Mjs?9G zAKP2P$=bTMeNnO1+m?9KWq5^?)}}}2lq?(pLe%^=l?hU z(}e${Bzh+}Pr)4eYz9Ld?dTBO4?W=Ge{@S~tqyhRquSd19b zGmXa(sZyZU2!p^N7|@7d=>#!ErD4M8JQ@HP5!gz)sKy3JQ5IhF9u7fE_7Qex7-nKT zLvwQ?V1fqBz9@Z%imF7l96h-6PLQXRYVi*F(!=eFqJA1s23~aPmNSR5#=QtG`2`yy zadtFe_Xg<)9mEk|+Ivg_^ACfA)1BaRuz_w{Nzo;szm2_MV`um7M&}#!r&M2oMZ-7n z@YaUKQ-{nnTlbN%_gvIc!7BvhSO;*^Hg_C zHL03%j<@(IvN`mpi{2?1&NLEX%s7#}UYB7qBA@DHB-aWEO~VWwc0f&!RpAHpVV4UU zB}J-N6|z#NqdDg4jS2-cC`r+I42K1P^2tgv>v%ev%Q>M8ZPY@K%k@!<%kIb!rgWKJ z1)~|wg1xbDGAEKoH`!$a zO>5~m=)Xl2KE|W_Am+RLkKInt>-FCCd!Q})1~cXv5oA*T?3@sJ6eiKdWkKvAw7U~W zxjHF=y)wX@Y#tf-%iExJkS6DFBwpZwX?23u&hFiN_aC%)Pq*Zmd2#gWr}O7rp!5|^ z6nxVsN)JG%z%TjcH}K|nkD`5d&+*JiO< z7Q1C$r0Iv*RHojrN{^Drm(dIaMbApPQ5%Z=x$5b1E&IJe+Nfdbj%f>7sb@oU9v?1ErBK6dMh(4 z^4A&%59Y$%I7}{P;f2^}Sbhq*44M|sz;MK}LAtZi*p zT&7v{t8|uGNOKqtFNGXd9c3;3)RJY!KZ^1xyPDNbv8*HAC>mF2e3TvWuW@nq_HA4N zkALIRC~nryeEK1(+eD+Vs4F6h@S?8BCy*TL3q_g8Yf6pN>?+JgqAuAQTqiX}K(4Nv z&}iJ9G~&`wkY(vEs`{JM02tur^k>PEEg(9PtW#H7?#P;A#E)wVO|$S~64rHZnx&uS zU0^M6H-X$-J0e|0aijV=vq2mUyC1~7JB^ZBwu}d@t_((MW_2xRqR8gma9oJ2wwJjW zVl+8QMqPf^EmsMJ8*uihzk2M7AH;mg8d71fWHok1X;7=^5_{4`F+q^GaFIpBqKnbR zAdhx)NdFuawPPwi)D_6WD6U^-8Q0wSmYGd2var?}Z=AcrKi8{uP^&FhLpb?5Oa z%o6f6T-d9ttE8!X&O(CAql}K>UgSLDH!@FphCLcvc0236z7|&Uo6D1cp z1v#V6`-I7A5kGjMUBF9%{bT2aP_FKOA(YE4ej?OtSQhAqm!N~N*S1+r?>=i*)hpLD ztNQx`yj$pf|SeRmsg)uq~O_-rMk{wi@tn5C!bKxo=w}uVbVW%#kFV>&AQ+~)Wwa!O=rHkD~LTV-RxU^tb}G zE5Cksoa9BA3?wwLPw6oFqbUJPid&Pb`MEu>h3t_K$;Tm;YW6Brsvw zv6tk)CVOf7ZEDmz@_Fr9tP8xWsGB`5f6lEb^v@`v97$1{^t^2EE;WI1&2kq+H+ z=EiQV<_No)FbX`DIpbghd?TX1eIzf-bR0}(aS=^p?GlJ^Y6|EXydL|VpbvLXA;J-Y zUq|^c%+yjVufp6vXw1w|G3K3n6@zZVOg!T~xAGQSs}J#IiAvES;i-c}h!O5-0JI{| zrICVnSH4}~q1!PV!Z#^6Z9+;4$UB~2LQ<0~(l~HoUMMf%PB0K-*dihGYz4{)ATL=u zx08feyAAvU_rX1I`Tcf(`Q7HWw%mSGClOgZK;QX~B4jMN6vGdECTX*QKdjt^@+3zI zEy6Swg>ZqweW%MiD6Kiq51`p7fjAiK;Bw=WnbG38%8f=~=6zb$e%=cD5(w#ebaDAJ z6xbNa1jnZWnB40oRo<5PP)CSVX@N z1^;e!t-aavZJ^!l-cH2^vO2un?7qnnw^WL`82vL9Gt(sE=VBji`X~y97}B zK4g=zhx;a%M^X`Hn)xMUoW?{w@P2X5Ah=a`^<7*fN0F^?uu9A+`nz9PWTU<5%#Q6iaTFBiq1<#p43OTB#ewu7J~Q5fU+-);7n z6)UReR9$W>&uSQu74@T(GjM`)eeGe-A)QS)mv=tNURhpX`!xU4EFB<7V@|Tgzhi=v+nzmXu1gGfa7&-M^~60|e%cR*S4)b7B_mA)~g zPw?--=b*Z7aIKVkG-n>r5s(CS9)4r43%wJmum5awsr;*CV2JU|H-LBBnZ0H7LtAYk ziM6Eq`_xDRXOdF-Sz8-YuHOl6*lM$PGe`%-hB#r2m;lsz81!3Qu+`^uBqoeH!L0M7 z$t1*(qf?4se7%Hx?k{G5O+r}%WDiVgl+MIF^<|!t5gYOJEanN3cbn5MuzCcM)t+QL zoMA;_o&n`i7pBKMfT|AuFqf+9j@bbjV9)!aWCP^4-uA^o( z)mC1ffsSk;r?}mLiu5x{icj#yj*58hmGifI-}ZKPtuK&@bP~LsGJc zAT2%8^$i0ROweH;U{L%`D>9$Agbp3qLFsXRW?DgWI{f+4nM>qL#!-vIPig9 zbz?|gHV~KL#|SfY_+AT@%=}#64w6)yUPMC@kc(h81&Y=(rvw-oah6|`8ut}}wOEY; z&ljT~l6%VMEg_}P1Mw-!iv@kI=8JlPc>rY?avxiw2yc~E5b9E#GwB&{qERtfr1G7` zJDxRSpgl0DGE-Z8YpO|R@4AjL8N9PcD&jpXW_fUL`w{-zxuV%OOJ49&6~MDA|EaEG zkR|Zq#iN@$XScG?g}T7hBP>ai?yn+Cd9B-`chL)WcDDmQ51UYo?f*e|5rX#Gq&ZCs za`z4nMG}Q^HywB7VGj$y+ebwPU=o;f18-O{jX_;2ry~eWx*6QyIX>?`&4I!=OG}0X zW)eG~@aO~|cebn5;JlpY4foV~)!&xrVQIo|tp4`NU0M?^x2f8Zxbf)}V**6uVXbu< z7H8uPPTk7@*+bq!0HRUw{=C4fw#K}0JyLjeApIh$;Q8nNs{GMVyewjsCdn!eUfP`!qMI+>ljHgf@#O<+jgNNG}_wBIr z=H`&vBe+gmr2Doin%xQ<7$SU9k7G?I#w zwjfYjQW$pB#@-9sy@-S#G91e@$Z3OUqf_GC5CZZ&S;2;)t{(p0Xi4P?$oi>9{DfpTFxdYeO7 zjJ-QHY}ZSp@kM%JZ)Z9vbINQU9^cMJlQGKDDK}(K#?t*+ZYO1)HgCAT-g#$N@85LZ zK`ZNWEr(Tk9A?Z~%$@3snLNm0Jau&?uQ3=*T@}q!DvSCLgUv>)G7HwjDYv?<#9FIm z`)zTjud(ZXK3C7&8g8zQ&Z2=fIx}@G*-UA9PPEjbDo*q@uccyRw=wr=vIdz-6Io7_ zGV9$?f-*?0C^#7umX?>yfvi(Za_O#7ITZER9wA_8vYXUjnUki#2SO5 zKKWl}=7wS|%s`V_mK~TiZ_E%3Vk@%*gT@L>!5q$d*@8=Xt&G81zuRC9L-F-Kl&s-@ z84hAJxHcYAHN{`Un`oMesYuqT)TyAj9Q&yxazjp3MR!G}R7GxS{!}^Mb+W33jjWMt zRqufHGcdQUua=iJ>Zrxz*4Eh@@PTzP!A7J1iumD4G8F6Qi9V_;@kKwO_3%b7?VIsO zFUeJTq<`$Uz$dF4T0gI>*crFRFRk{zcAi<^+25RRde?8gyt955erx_&O4W#gdF0!U zmQ9%(1H84s-;h3~Cn}1_Q(~5j1Dnhba}@zurYDloA>yCZg&Kc9 zf`mK}o;lsH?#EGx+pVA4Tc*b`u@$|r!~LxJJX85>cXoT*9rUMo z*xL!ZG}BCX@f54UXhA{>4RwCDr-*q5U0`n)h#bn|IUGlh&kEk;=!M+DoKCrRPreEh z@?$~lQj;pWM9BEvN>4I$tOGZ94102CR3xMJX1`<8QXX_Ls7fF8s_05JPqtuHnjqmQu!eaV6;z7As(L{Z@e zQyI)4qY6|=txm8`U>CAs@NZJFDl$MNI148N`Z0(Y|AID6UwRGFjppB_Zg9l1u@OG+ zvoHYHe+B74epEd>3NHv_Sa|l4%Vi3uBJB=D*Y%fYb^tz<(lbvkNhYRoIAkagE5j3` zVIwfMfIL|YG~pqvcSa6V34lly3wY1r8MJ;-fwOYs-#taB*Uya!sag&y(*`>Fk%TpT z&_Me1aG+tM6>>l~Bpe60JVg@<$Wfl$YLcX*97V{Z&=aI%lXhRFyGpa5|1zBRIhd&7 znp+EP60TVD3LeJEwDb?iI@CCxp!+6wwf#95r|DkM8iZLZxHcFIc!Rn3iCmq$&BW~T zmAt=Ur|q|ITjMl^v|G^Ackgbirx->fo7agBb0NW47BodSgHRWONp~W$ z3&}gdH&!+Q0ea-J*H^xFAjx1zEmBm6)2?D&ZB?~{i|C_BK;|C;z`7k5yl@@1wt`bp z%rbH;R7ismzNr$bmDi0u4xgYmbdR9yNZ4+}a{*&vk(qur>jpJD6jH)r58#o}+T)yV zkY>HKWzlqByZls2Pt@-Ab|#c(Hswh9ZSMiaB0TEt-2YNM zR!z=cpkeo3hSTpP*KNRV%kN89I-SC6(|;$*o7zeuSmR#pja`p&_(lAE7JUq3K?0zZ z;qWUV)p_qgkP_;nTv5tTQk?+NxH9w*>iSa6Jn+8bdv3Eb&fyTB?m#IuX9Hz_idybj z@%VibnY8b^@*Agao3y2~FbtFq?udtj+zb|RHkEf4uh>AKNDhS6m5TFeGkm@J7+{4A zjpuJ6%7E!;%&|HT;30Cm=Oe@&yGRUKUHbS*MklC+Qz?IWN)@*!&W*AdZNpG9NZ4PP zrqo|GV~SpLe*<Rcgk~m5( zMHU(OfBzYN49|vHG%bSu2{zvEk@{~U!i1ntEFMmzRAD*cK|X`Xhdk(~gI{_@dWL%s zr7Ha8GR#k|lGpr>hud)4euJzjBM=zM_H}R7BXy1j$gh@qz1j&9IT+O zG1Zbr2b`H&7@f918s*CD0ht5xK)y2&NFppa+;Suj7^@>U<#Rx$Qm?v^Bw1v@ckX}y zb_akr(6<`X!dY~2uaX5Kz~lrR;hdy}#qLoTW6_4F$S9_R!l0|wS{EELh}RJHN%tf7 zRDo=eGBf8#fk6BLZqVupDG3zv7uP2ESYk2&%PDn%od6;eDv-8!T8?b(WBi*gZuY~A{^g) z`0(Dt!M(vSeDL65Wz(p~Z}>>xFA6c47OYtYh8dQZ1RhlUrUkCR*NR5Ugk*l~dh|$1=0oK5z3eVmQxJiP>VT`OUGDPN1gDKc5OpP3fg9wZeB^W}@uif(l z3mXKgiE8~uL9Y@5*BOZ%U=xBi+$AAhJLd*qXZySy9MZqnR)es2JNnZPQO%EC+uI+!a9yopS}uNSZzvf*EnWL+$qv?$zN+q9Hj zsl`f^mTg&T49TYu@@`<#uka370E&-_ZPK&2HVyz0E3}fzuSwQOWt+~mX_`VgqYTd= z0UW@UOKefys(b|+iYeH`?rki)2Y67pGnTM?IwWF(DL{uLwGD9+g6zp~qDNs|7Lm?bcrM*L5vFslrId8jCT40UF9J zX4KSvG72+Gv!Yyi_%5)PgZqYg6;|A2`rNi&rGVx$OGd4)V86+6H{NnPJH1B>_8gB> zz6dI}T^S5nUh+8Ggg}3FDL}`fkm*pqdx7xQ4mzDwegTHId^-%%(Y&KDuRHkq7Jr|G zu{E-nQH}{6FKx|93foPbI54rpAq>ud;xxpY<04CsWo3p)S-lE z2wFMKM4X1BEwBoc>knfw;uAR&c{dnQeAZtGTZ+Vc1i+*@kI0`p#Bim>BfcPJK-{bxAn0q1cFXnIa`3W8dwL zqKl{~0fia`!J+?y2>SQ7@AZiaf;Vb}?mo|Ozhhba%xnM_vo1up;NAD>2NM>`;J?hoJDZ6Bppq{(X`b z?+txu0l@@d7vFS>3)n3g^U(t_oqlUW+nXiL@)Bz3>rJOupz}kj4c}bn zmTOSX=`%E&O3}p=^s<)6G+`#1gme`~M%C|VR}Zzi40Wo@CN+;}vh~tY~CH3=I8LV9wN%o60$$qUal2Y@) z8%ArEG2xeYtazQF&JiYtirdn9A;D@hF$6Oc_KX@y&dLg^FY3faf|e1n8gI)Kh4q$NOp@kcG4;A zD^L&{?*SVtTR_=~)Qre`F|ZQ2VHiV-&{FFJBg$eK^4*(8Et4 zfhIm!RSq<%3DU{Wq^7B~g>9u%se|%(cxaRM>@v)4&X0znFv;2WtQ1hdyOXpU(*Fxu z760~@wN`(7_qVryd)LIWxYN74K=Xl{N`Lk$qdT7OIx8*<=~kJ#jNs*8-@aQAORIb8 z>D)?<)yJ05L&4DK>;|v16e7{gP}23OxV$gA?MgIloD$t3pM_25hCbH06^~F|ruo<+ z(?gAl7?|Z>2m*cK$Cu$RX;!9gmWUE>32E<^wll9^n3l<1AFCA%jleXNb0j)3a-1Inr~SQ5^)nM>2pKtq?1ub}@HrxhYRBNbfYUE!y_rh> z)UR+g?*x6@c^7{wdH-zogZTPd}&e#W2{Q1j?o-_&Jm%uWRL!@CN-o)F>(1 zm&ZWMCX$hwD<$MZ&JOSx&(jXMj2M%qD3K(`wU}%$5tB5VO9e$jgvqBRhVtMaBZ;-9 zbQJ{{%{%70tpMR++${udL!i2YqzIUQCoG~t1nE10)tI=i^E6Yx;3IvPP9O2Lw5V?4&W^@THoq z)*$^b4<=#u!Ae-8v^P<~=Skw7kjkYKT#mz@^|IszT4ZWa+fw|p#Bnf67iN2 z%CDM;w>ICd-y3a~#YQOgo6{G;KWrgwKfA~~!Eo>lvE~eo&Py3EBn|kD1PSY9WKT8- zjo&`>4+(26C$WUZ<&wU;0mte?ybUTxrxndfwY_q zyemR!t!HswrH3L8=PNFbH9Scwq5nTq4EM`yGlj9ZjkXnYL+ z4xXqcE<|xE4Hg_4?hnZ4icg*dZ)L}gKD}!qciivoFxJXF7i+}|RChbnAXeSD4gB2Q zlTi*i{wm20bqmYE5Yt^)5;ok#YwO9=H}qjlFPXhD(snwV41CxtnemoQ=tuM6=E$g+ zrR9jzjIJ-QCSN>j+bstbII1g zncQTQUz9ghrKVbnO|2_W*sVPu7G%6zioaFSSsSaX&J?yLu2U4NCjf0PJCGZP}?`1D-=-w&Oy= z4$LS}SdM{`fR&;)C`3ucfOQmpV=0az8e=p*Lz9E|j7omSj@K$sBgkh1m4UEtswyY!2UBH5sseX;>@%NtLfiTrLW ze0oC%@MFE=?6aK7RHG_`#Yc+EqYyAg*(8_c9@NKw5)G5GN=zaHyGrz=qk!~^=wiSu zbi!JS*I7CU0o0UZbNa2F-cE}!6k0pI?N%lF2E@7OMR0=5XxsT9JrrB7PtML;E-X}) z8!z~b%cwC=;6FOgYN<*kx4_~K-2e-`sD3Bc1Z z$_x}ZBTtb;%_{lrVRn=*hyqJNw7kv`kSnA)qhAKS?&|W0ZAY?;S$j^5y^mbOK6EHj}&^TeAV9X-Nl<~l4jOEF;s{>dvo-4W+wuHjbYa*XWyQ=dtkaS++IHFsfbMwLb~;& z^(ATbEO#=Uajw83y`b~CYFv^Q485T`pQmZmhmbQWeH>m@-^mDoi5~6%I+HVyoJFd=UuyU=+u7+o@SeD87^k42ysI*PNr0de zm~DnGgxk6({%|{Ggf}_^t>^>8rRSR-UOwyi^W#?aY)3m)N0?ubKoku+!>0 zWYIo8SG%NkBOf5}ucKlxLlGyr80I?eZnH|JSr8#+k-A|h-<>-+WyIpfX=cD{6^L4F zfu>2ZwGx8A9Mnr{K$^E6rZhvQ*$WuWKi>=bt)Gt0TOi-H4v$_OogY=?-l*2fQd7?i zQ(Jxh;x&(4qSrvMv>YvJI}|b`-W9MNp@>XS$$)e6wkP~H>k^f@3kk z^mMTXemXi2w#d--3@+y<+1$u=VJXd6dh=tgES*|VUfuo7C=fBG!vYL>;<{iaWQgqP_XRq++oZeh2Z3vX{0>Rl_{LO0$vY6Dxu$TZP}4YIV<0U+-zPxa6ul3vP*AgxT>La{v%E+rK_6scsd{Lptk*ZgEQ@b^Ehx}I&%I##Q7pa~&3qG@ ztdVV^7aa9|>T$M-Gk0MCfN1)l$G>utHi!LyOIV%+T22>e92&=vq91^-& z@FWBXn6{KT;Vnw%zWQ2KQRRPXAn+GXuaXC;j zo_-Kh!0H9x9i#U<+uPgacU~r9@i9ygwN8z~z^w$=0KZjIm3|3NiRC!QOU5eVD)3t6 z5foDEJ_Q{wKoY7U0EdCcVzAxY*@iCO??~u5>)S4TJ5IoPu$cQr{_qp+rL}b%`^?GW zK}QWer=64*VcZLj!r`UHIRiU4sDnZj)%dK=6r`&}aw06&A?C;AN!U{Zt3+x#hZfg7 zJU~PhfQ6h+MMCFjoC#vgqPN6OGWO%{{Rfp}_%Rb=r6DkCn8d(|l3-#0@9?V%=RarU zX;~CaMJDew0bBeX<*G~e5Y}^sh)#I{PJb5&qX+m~bAs@hM#B#hStSvl3Z7~O*EGwW z^vm)P^y6rp_Pt%rRjbd?uXdbn1pf#&V*ZQMZLiblJ{im+<#!o@FCUtk!X&(a9vdDX zQ*cy*TV$wFun|rj_B~WWe#f#KyLv|a*bNB^9X8<91|w7{o$;J;iWd|?(FqbA6rc&h z736f?Jab0ppf(&VNlhO;Y8da+DIgGs60;lD+SwiKkEWdaB(*dPrnvVIyA$sl%9Ryi zHRR651r%O@i-e&>a3Q-4V&`KUeF!dU@T@u8( zgh?RAX*w9mv_m1LU`8M;C}L_rV5acgIx)sV)0ASxnQxX7I zVX|qH{U~4Pb}p3HRu3C)Z}vA!@c1~mi!>btQvk@0hTsRAS}%jpV6D=32|GhGlPG_1 z$h`n39t1|wQ6?p4VkBPs$yq7mtHwT8VzG17;3;q+({`KOP9VZ0F+9c2A^$F{u+F=i z(c=VZoFZYRIHw%~vc5v0!!plsvSsC%vq(vp2 zCwst;(nMPMH0-(7A>Pp-zQir_vd`rmg}a*m=kz6B<*yy$-1-R*ta3a8N)xH4jx z0uf;vOux(jlzM|r@)LqR$$q2d1PtdXEbKVC0A(L29muO{($UI0)*In2y4KtgQ#t}j zB1O-XHifzF4KSUhE4LDm_Ll~Bz9V;aPl7_*#2#DQP@WydSJFgg0aYn}%WG13f~eP*$xa`9XoV%U2q_%E;5|0=25-K4l1xEd6zGC!4g;&%=DadY+LW zZ^#oLi*cdelgOeoVHq;$aapOhtHAZO9*?yl66Fc#%LjHJ9;=+LB1d)11h(lgO(e9X z9+n3M9-KTb)sq>t8D#wE1t<7_8A+nhF3Inf-7^z(ss;$gcBPf~ZiUfVYd5}@;rD_! z3FSi8ed~9WX&{_HLkvNk2jMVF^PF7$aH?{@yFrs25sp5jc0zPoY!=t00oL%VkdhWn z1GpAkg%RcjfJ<*+s+{!PkVs`7BzQs6S?V!#KV`z4S2-`8*|KkctoJ#kywPCZ5)vPM z&GqXrw6j0E&nyOa1@BZ14qSZz?|Ek&Lf6n*JvNUaJ9&T!ACyJt>_HzFIeV6BUjUrfC(Nb=CkIwwNY$tl2QD{6y3+WheaO zbZi#ZfX&Fxbc$*`Q@vju-g!v76-5H;-oX6G{#E9stvEOI3Y+DWtqLY35%Bg4Gt|6| z2&~yoImRlaq_lq)UWn?|Hb7AC6jJG8l4jU3m$M=mrB}%U_8^~p@~uai5_-W2yt}TV zTy#83%}HqT0*dU>8R{%1&b|8M34?RwMq zqL#mK#4+axdSv7X^1i6PuDLIbW@{^;E$HUS#GT}f8MG8~ui^8PBftN}*V6WgxNAM7 z)PXgp`8&m7+%$6#7L|@mzz0t%K6DI1?AqW^q6X#H?~a)X!32NDjX!;=>D$GL{L{9> zi=OSte#>7ZsgCN$)6G35=K1#cUuSAmEByGDqh_(hGkD#xRi>3{*H7-&RuIOZ+`PDy zRHY*X$UPcfrIbkr4!WHKaTH~si=kOjk7kgxhk zd=xQwWD)nPq$L-v+|SP?tD>czDr=`2D3PQ#U)v6I5aGhuGGf8wTXS0+r>Se!T79$* zt9_2f9#Yn!`8rJUX(+|dJfDdY0W~mm0_89d>A;NY@u2_a^hI9=b2WRom>b`OQqk>U%gbP?Vs+9di7} zI(@``;e=O&I8tJ>hLISJKOE}@l`Kl&DH&ZP-~o<}B_qj=<&e6P4hF@U3B;3>#!oJk zFjUVg3TDJ}9fGckl8>TN7ZWaG`0HqvNlz|GqCF7O4pLkOhp)&^AJ5QFL|t$PuY(vQ zE+U(wb3MiPkmy1YGW2nCu}iR|nI^WqL5D1nEV9qW9-LI0T8=s~%o)j!!Af(1E(9{k zI?XyxguH+$L%HVyXGe=L7=sHWhzwz@A{5CnMP(aLQjhF+M`fxFkv%Gi91UI9qHZK< z0b4=}i%8sY!O<70R*)GTklt(~!&MAj^Q2+Ds#7MPEyXfhF_h#&;fS=a)-;{Xdu?hUCzJEU}!iLsgP9ykhjC3tPCL$aPu zD@g8FawABR(q!LnshV;p>RE)0Z3?tv_rcBs1zPc_w_Ad(@Ih8MQ?YLXfLQYZPD@!d z60FF@t^r&~pTz;S+9|?7%?be-gCWS)f+TYH9LF6>^)QRtVXo!agfMX*b!KixNzPp^5hv?Ka&Jy+{Kg?ECsJK9kIlE9|fDr1)}dtR*7_0(*%;=1kTOTD0* zhKPt_s^Rt-Ntst;QkE0RcKodLhKt>H`@$V5t;B7dm5y`(Hi(gN%IeCL2gYSQ?G0cfBO(FU zTT+7uA9mhSjQ~<5#=H~s+du$(MGj^ojBin1kbZm6YhYBQisAE5hM2zkArsgze8r@Boas$ zZC+%~M1Ro{CsrB4o4>dc7)1tQmkj5np==erZNv)Ms4yZ3sCbcLKL^@LogyC*T*FZN zTXt>gjhsia7ZhOfA0h^2YK#K|<;X69@WsSeV$X<>;nHzQXLdg*k3~Iqx6hq`?tVC=U7F7adLWsz%R<#ij%)Hv- z7hDHVU>YC0g&05@tejLr+W6kKOl;}aJ6Fva1Th320)H`xZf#*S=noDRVl<-a|70tGg010ZoqQs*K=Y`3H@ z&W`~8H|qT@X$AjbRw@7KpV4^8ef3YDtE{QlfrvrofjkXc|EFO!{u`Q&w|Wq`)i$Pm zv%a^-3{z^ZNTWWJ$pEA>$9j#?#0uf&PoItcIK#2$T2QhuuYHxQo%mmA*fc3o=pCPG zwf54ci5LpAX)qC!G@F~XJQ*|O2e6cR`l^4aw@kw(&cZA9ZD_Tc8Ld^7|9C=Hp~p+w zq>F5B{~*sJIS`qy7Whk>8?{SYRH*MDt>t2ftOrtcjaeCDyX910nr*J={Bpvj@-KnobX+|h(Gjt_#F+yB! z6PO=HBbpEIs<%%R$KoQ4IeZaJq0|sQD}b-Y1px;2VS^JE8#`H$Z-CmE(FhE$m|bNs zhqM835w?y_Pv0NE`pf={2mlCA-3*VE8+lXNtT879MatK>BhAcI|NB4x&;R`2zZH|$^J^WY zbxf%~$dPjT;`e3n)|%2A@O!*X3})|qre)>t_>U$mpBBsH`OJFju7EQJD=b56Ag-Er z2{pX@jI<1oR9c2d<%?|+etH7fpzr)6$VKro{B%5u1+?;-8fj0$PckUCs?R^g=^%_P zJ(dCllF_g;BWbh=(!wkBXh=34@3J1rB+i0D%nT7c0m(9CcCaq%s*YXtgwE$TgOb zqIvWyPM($XIf6kI8rnyQ(u(Zv0vw2^=c=tezUA7$jiX_NYOZ`^v!_aw##2lD0IXR@l&Zag zx-POjd43o!Zon+`_?zo*Mq(IauocM-8|vELV5ToV;bqS_dmH!(D*oa3KkNDfbB_CV zw>Rn)`K`3Ey}kY5-o4-t+uJ)2@9)6>w|5>q!2fUGeQ^Ko!+XIWcJ4jA_h9?({hj*{ z{;<7s|L()x;1Aok(i`W`EHA?B58K;-uPCzB>1^YlK>hzK_+!qg`FHaV9&(wESDwG! zzC4r4vId5p5_<$T{T5TI>}vj4q-mV@B2kQyM*=(C%ErTo_wQ|Qs&pB>Z|HR*Lr>8b z0#OUV{`bBKuv0AfTQPmRu86-2GCqq-no&LK-2*-aKL`=LC45QU$BU@AoDINjo!L45 zZ)*^zgDrxRi=zP_i(kM=`p#B~Tj5v9sknz0nAsB)1ENf{iL;S!#|F!}TmzBq$1EOD zxpBTxE|Q4CER%@BQ;0$^&2sdMr)UvdZ5FYw(ODLog=Sf77t#6b}FkT36C*Nl|0OzWlu&_q;A;( z-R{RUlZotBTD7n!cYtz(mLd5l`?URggOUCi#iDw&TU&w1<0vV*9C_D;_`Pl%B_jA9 zCFx-nO^YrS+Dg(c=kDyn;}&IYYXcpC&%iVE4aoO`ao&S5<{cgF?PIi9^F$$!=zs7V zI{1g2+LdNsPio!n#u>iZ#_~)z1n;7%NHN*w>ysu}^BL%V6x!TTmL=)YCom#LY2rZ_ zEA`M|hN=^cpa5B{#iwd4)H4Ra1jSTeMuPPXf+j$>_HYZrK>|^V=z8=s1ymLmP8&Jh zX~#*!?GD}h5YCUi@4U!sEOn_59-uy^zE|EqrTm$cOo&wvmw<4B(X2|Nq||FBs3L(k z5LU=Q$nfZ%J%1qUilRqv=^j-%L)`-CbVi~GqqqXgbEmgUI;!p7&V#zaYRa{Ep35xi zWth`iP-K#~qu3$fhOr0a=2CZl4@hsF&w=*e1CR+dbIztAB^Mh z0*?zA^P|LdzO_B?h$uru1Y-bmF+95g&m8~fDF!XRViWmk4{WNr}v8-ki4pm%q zI3jEnh!9SFGcTQD7i@(c1VpTvOOcHB!C_rxGp;|Mcosz#4duH-S*gg691gI5oAlIr zD0Z$ErA+IRk|dN7MOWQ7(P+s`I7=P?Km4hc%)D~uRz1v|f2Q$Cz#*KTovZy%+1JoZ z5#WLd#!BZ`aE5CEY8z)AV;(r)4DD>`c5b#s2S%a!s_aFygbq3xo;_v{MlM+$OKq^Tvb->1KpVj7GN7(hdZ)8ufGOal{v7k>Dm;Fx z;}u)weqASlb&o(+h~(F89k8PGnEaM!^M|>zGyiHa|N;DXV_-8FCwZrH)(;9fj1hAvg*Qx^Mo|5 zXi5qp&DyJ2t_Mc~=2z%1{ppGLvQ(80?`uMNAr>1G#4o_Fo+wy}&pR zXIpuy5jqWZK;hGT4qB*CZD9r-?RgxyXB*tIVd7&;a%HTp7QT5Pnbt>GJK~1QP;Zif z2q7ad@cuS9T+>#8PqeA*;ceP;U}wv2u=YlC6Ud5s!`*s@`iqdRL6q0{ZDg~K3VuOv zeNs-FRPj=wIi=6D z6g^T}Ve?zQASuDkkGBuVWWN)L zVz^nQcG#}uKE~`VQbd>dPB6S=tG%YAh*#uDQO>UM;k%C-J`Q=SIgWT+>+#~!QoImv)R?5e* zTuakv>THHQ8}7+-d&)|=>OC>puO`}k}*yj;|3fO$L zE}N|T2K`nR?0h~Mq_IV)*XxBD^e;^2Z{Jmu#VnaFXWI0r<*b6le`<>{m#JVawY8C( z)D{DtQD2D9p}`L7sxSwrFK3?fMu)qOBA-0(ajUDV&h1LIo%1S?m-6>ijA>gG1;-TcBfi7j(a8}*jBp3PdT-O2`qH@#>LQcK>iX3bl?R*hy>xlMKTbzGupG8C)x2BYqh+`*{14*p=0 zTaH5*HJ9QMX1!Ipgh69jK4Dh9B~D>9ar5JC5L*YgFv#7UUl_!e<``z(Tjd!>L#uHO zO<)~-W16Ag;!QOKRb-apCRIdk&R8lbFT-Q1h%CWwDoL!yd8)`Q$Al`W+zLOcYVD@H zq>Ap%xl|S9n=-5_x=Zq|N;0>|#;V#}g`-u_S|f8iNrqxg49-hx6(;8;v^GZPr@jKS z^AcK~;rYqji0OGruEhBKlx~yxd0Si)oAT0L8x!h#;ayLlR6ZYj^EYkW^V)Xe^SLjKBMPs(L{;76PCsM^5CE6G>$6 zU0qdOUG*zTFl0k3P-rG+Bv57Fi<*pg_X|zpZf59eN8WQE{7F|WtM_xj^A_PDo$Grv zPFAIu3H=IaMzyis7uDn~#KWSSFJqpnMnuV09y&ec+DPt)v`Q_{L!z=j$z-q=(P=Gx zC4`rKKfPDtD_*7tNPu7Pdd8eT%U{oup@-ngX-{R0)D6JogAZ$+OijR?_rL-B#ttaJ z7jqc1Y$wGMF&4a+AudQ!bX^8&+T2_$SVRGO?+%U8sMC8lyfAvLw_W4n?0k5_qfccD zXh3RETV?*~wLs*@n1GM6Y>7MiDiLp5pdxDyJ+0L?O%8btCxKf|f;t)F0*>PqY>4bO zEFFgg$VMpHYw9mku?Px?wiaKs?)t+3TMS~ZOmrhUqPuFqtsaV2$uqs$kmEl2Ij!c~ znwUz*wL=?YKumR$5@|z{sXAD~=bOA3ALe{*$*2~kVT6B;Q4U$0g3S2A5_`L3%#m{S z!c*IaZ0Ee}*Y8RW5g-iAr`Ci#8o5r~uzqZjQ&A&zv;fyhTtr@ivt7%1T8V9jKMa=G zSIHuATNQ??RYR}yz?-wJhs^Jg)S;5kI@ZppR@!4-&6mZXV|cDvg%~+(vA~wJMHI4j zcpC`!tZ_9mW-X3+U?RkAs}aH?=xH1umoWqRk-->&7VaH-9C(wH)DFhtUz)CUV_V^j zT$+yQPFPMZmPlygxpBxJ^3}Wp(awr)R!9m`gu$tRp(0i_-!pxU7Sv}^D%wK07K@)@ z#3a&WRf^4%Or|Y<5ov#T9F51KMRhhJV`ps6z^v?8Ic1)j4zv=OMk}d?D#ed2fGc1D*eFVek$=r6?#svHwcfUygq>!o z20)Rj;dyKEgHo3pwpO!M;1qRLK;$FkRk=sVY-2YwPvjiKq_n0L!?9f1*AVw^I{7G@#WV)w+1QQL72V1DRT zfv;~vtT4s-o>`ZieUX5VN>D)1n~FViBa#F6Ap%uP4KghqJt zwL=Zq5X&c!jLu_;f>zVSfMZjE!_ZykkrUbrM~qQt>TEWA*#y#sxm2=Qp`diUAZU;Q z-Ql7x*{gPp@RnezcX#G?ND;JA_O(*tJ@}iAE|1)>ao3woC~r1u(|?sq&IR0ZE=pf> zG~W3zZaj}l&EHC?`HC)>_pf~wnsuiZf&p@9*%hio>b}ZXUb9P1Ed@(;8Z;KZH@5>C zG-5%l8!}hldGidUtMR$ZTP_7sl~1oC$Mo6s`74&5(r^rqIb&w=;hC=z^%9H^lsBFR zTEos(#F&=_rphjc5A9C*)hq6{Ok10pTb>yr%k~f(9L&&MVQNU)7qkPq8B>G2h;R)0 zvGxos!LLwXv18)niBd^lyy@3fEm)MwMB-FC=jl0#rd7fj$y?rZ8cnP#<2oLlw6(hxGf;7YKuz%Qnk@Y9k^AD;Au8z;j4_B{VIv!noB9EWBb*dzq=hf{i-WbX#Eb%bp1NN6f z(M3jr4uHbZCJD|ivJGESNGr^8$smdwc=Kg$Sr;2!kx`m+&_zyeny5hQa!J&S@_ zQC2-B3d*OLoSV1Dz%9xZZOi8>wroLh6}AZwS5kVOZRU!9##05ak;ajQ|MNW=Ffo3I zypn%H-qDK56d^Z;2`kkCAebTkRUug-u2V8sDV-6ADN-qEz02t z{~*UD+ltsATm=rXmH$ujv?vSN# z#4KPb)so-wpgktSxXK(iqqI;9Alnfco6f=&TxTo;xYo_crnXj)Mme$8S#ex((w9`a zrbIf(x)S~-EE;Q0p=^f8iUS6{H^kf?Y&SrjOVUcDz<@vu9+SpzLU?6Ba}BR99$QS; z+6A8q9#j!K<1}PJVK1+mupnL$IpU44N>1ubRMuV1_maDt$a`(M{oZUsO~wykI)$u& zr|9CRJ(VFbq2{yWSg`+gG+b1pAZV@Ojb$9&}rf z@NkS753yo^R-~JmJ(*>VfLX7SH&@%jq+(_i&LF_Y1oddORVh74m>iQU*QV{@)BO#5 z8fMRN0i8rXC8O?8GAYkpmpEnrQgD^bl-OaZZz(*eQanOA+a$f-K+}a8z_OZ?kFIy) zQ0of9NQpPq&M`C06ox%B^HEv~a5mHsR2^G^8kt;ML_))wfvqI7_dv;v9glwfbcQ^Q ztDyhZ;zCS)o#@!L4>_n2&fZ7XzwM$9C($z`PRd9*(V%AsQ97?-h-LHaRzti;Tcb|DH*T<0=-RCSx?*b)ux#ja(7BWl`rL`dDdjXb z=hy>*`EaZhJ{nm&4wu4sfiWlS{w~_|y$HCxW&3mje1w~0nWSDjpC;CBl9)=!e~CsR zxfFQkbfP6!#Vt7A?DeaRpkE`;sA4I|U5HVN;{s=j{bcB;h$#}Wa-PWgIW&gDPQQ0C zGzRaDL8<$Meyv2y9zQlkowU0hqc@VOVQ!;5N939d7%CvExhwb1Hz#x&IpXFOWC+hX z3yEhwMoU6(?Eu9m_ZKIjc2k&m;IacGhIe7x$BQnk%fiP?6I9KIi{S3Fmo)JZ!cim| zq>q>q{MxB+dYp>;Vh#qc3xyGg6qyo_Oxpb<$^cl-DojEFg2gCTJeE4n8)6z?oS zub$Nzo>(g0Uz4i?%g&O1jS2)5rvX)bZxt|riRt?`KP>`%MJJ)m9li3*8*`aVfvrwh`8Xc+n6ryi1?9o=_s@KbHvcOvyy8UwZGE3aW#&h$wAJ;vDlHg42 zPVK9RIX3ZUP&P4fuEhxKfb8$BV7rNUNA8X>mPw3FGG_Y+cNm2f>j_#^Nbn`OT!O^& zrkn)f)+XeI;>DowZnoH_t9iDweNoFTkis>)!m3@64%MRb1h|$@sf4*g=sSMU#b@!z z6SOo2n3haZi6(HyncAoBF*qKMExuu6*@I>rht7NouRKg!h>2%zJC4nBjT7pa3*aJ* zg~??Rlq$3eO&!xsF;En6=j>}CE8<;NHxk-@xdWRi=E%vTv{Q)CA7O-BtcM0@p<9q% z*`m{{S#4WDYl+pVi(az49Kcuk|71J(3SV8vyV@F`>6F4ir~c;;(Z^?PNylloLaj0I z9*~Yowg34;tU~As=kU+9R2!OuVR^`zY2qA8S`-1Jx^66vyBM83W;y{pKis(l&Cj0G zAT;L-vgO!e=umhzw@r7O%uWBJ62st!LUi$s7Ymo8IepuBnjy!;p!y>61PL{Rh7=qr zSWa}ZuJN6p*Upw%*}zSA9h&BcQe+bZ#I67=NK^FT z$~3%4WuO+Is^>dPd{$HL6P4}9)2(8G&3P4jP@t~0@N5LPyunv@0#S%*6rvmXB#-JT zG!S~B>8Q1MFi{<-UT2f&I~khy;F*>*^;dCHW98}X0+p25>43Z@2jrV?$iZHoPaD^4 z(5a2>W{UIatYvo>7M`zpV#zM4=uWSr7|atcAY17%uj2={|E%$}u~#S8`-hGFm$|v( zQ@zKuQ1*^+E?qlAaOW37UMhbHTsz@b=~Euy55~u92v^g6!m}>u`1&xO2XqpQHIc!T zEf$=nD4@1Rcu5O|z}uDaZ#AAnW~GrL-yjtmX}55QG22#_Dg zI1sCTfLXt*6i`?SxpvYG_>xY*8&mpLk;n~g=0mQmo368I{4CbqqzP$U(;i)=nZ^!; zg{DC|_~*h40vp~wxM4wUSprt1U&eSyrLIUy-w(bQ_XJ3(>{(1eo=<#48-**XjF*c` znhw}&mvN13g+o3dYGOV}Jyuo1Z_KEk(hb%CYUFxA(}h)R={^OWCTTCQqztkhhal9e{T94#xIeo1Opy4@H(t4YTyQM6KVb2P0qTA8Z9 zP|~nXB%|L@s`dw{KbIQfpRGgZZOeuZRepB*^5-kBjZGc3`^_7F?@81)l`MUO>BArH zVJsfz138eHTeR6jnUgiW^1;k(XTyi{o^zRhfgIq8kVoyq+>l2=0pd1i)>hv884JwF zGB|Sx5rlHacc1{xufFhB&vSL;I3Q*^qlOMF$A>2{iBcwW{$!M6Z$@|ulZ?|Vg>P&u zsTcS4tSjEt808X&a3!9!xakz^t7GOgo3|vf-PVeH_LK}yd-j|m)T!-q^er*b7_@Fm zeRwR1?cscgJgWivgOD9n%oEu~Bdgc`+9E$n#r0?D2 zy2>Lm4RNA+efo*K*5@N>^bhh&YCOO4 z^ltiGeEJC=W(7zQyv(jh_NMxZ2w=gCnf;pd5E0#AN|HL+LQEXi0X*?G8X5UaL>&O| zkU$_grAs@V+!roT{P^@Bk{NOKluT!&HY;FCAK`#1!U5^4!4NFOBJh}Ah`)>hEu{B5 zgzCe`{5dNjfP4-jgHKpkz3sW74;d7EMdsA`1Fj-a(A8aaTo-=p>R7l(cgin2MQTk( zPaNi~$yz6r!rar&a&Oqv^J!l)lV;`69(54T?sWEsZ`c^By0S4 zz;omk+19c;V{Pf3@u=W9O!f{hj$C}^Uw^np(9Fm_2>HuCPs7BGK|+UG=KOl9nB zJymqwoY$#_v>e#_*K59QZv2H#Qf?J;EqW!A6e`J53E|`PS=5H4LULDf%j>B;U6rJr zjnGXF&D`&U+r9BGrH?zZE%kX&lEytSrL2zswjAgl-^T8d8tG z`DI?X?u}6MI=myzmU?n}2;^I8pnnHS{*zvf?whbPJKYR%7eC=VAObHQ?B9sUzu?PD z%L%FPBFYuSz1S0)2458=AoDaGydr&jnGt&7^whW){bGw3k@c|pUHfFY3wGIP`p?IW`RO?ROpidIN8$->Jj+{`^1=#?XE57 zhqOhP41WM@gx%5beOnk^w@jIr38J%q863CCi7mZbSICoGNC z-m1+GUO#ER+}qoG0!b9JTUeRCJ#Q){aO2YxG2?U;tXg95!m7Sv4!n$Qt@$=HWRW!) zo6LEVQSv1AG)r6eDL+9IY;fkww!$8UG) zdApaejv{cEtvj1rW|i8w0Z=Le(N4st!<#xhkMo?gF^RFJG!|yMEN(7d13qz>*OZvB z$F`)jxVTt=oPBAL@%f-D0DbB#?c-A5`^c9f)@&SHSSLCSnL%;`>wq@EU_~b;Pm`-5 zSEt$(3!@GXTtyfu7u4lv3eh^)hfFHlrepuEXNzRJ#agI@h+{e-Y01>0h&nRWIE#8p zba)b7Y>tK49A^O`=?h5=MjULj`T61LJH^{E-}Eh>v$KzzH_qR^ZNg8Tfa$RS{ngeCIC(N$7L9qUPpGz)4K^OXv2ihxaYq!>UZF^n|K=;?g~9rYX44;Z z-gSDbG@F-CpFS_tY@krSW}|iv0kzgO^+P)lL7ibf5HD9(@O^iIjx?Tts!8w$4Te{y zmCB9Ey}PrFNNx3+T+xu}qI~^_-ki?7n@n7Q9Q`ZSWVd*`8_ax@NWvDJV)mGP)p?4FU*$Y!mawc`AuS|$) zr&`;;uS}L|WnyM6ok}^&lTKA?l00JfoXb|EE7bj^nyktZ zWtKh8`d^b@s&I>6{|f9i4@70Jv44=Me~HEFyTEuDkTV=!hCrqAzJNlFP=Pkf) z)=VsohS-%RK^&y-w66(TVUoN>e!+E=jBox(eMS_sA#3nes?2BYlh_!v5{h6wJ9gSO zEDYNj*2%SvPHA&+v5EX{4lipN%7tBAojS9Nue5{Lb>sG*?VD495Wc`>SJ~)7uO6|1 zWJ5c3FJ3W^2XS4WmoInz?!hzVaog8-DEX2bf4^=Yk5sS`zl<+O5MS7P;*mZ!=GO4V zY2^N#58?#8FcthLFTrWr31M#D9<7y;b8g=9Mo;P7^Osff;GUVbUm|gC62ZI7h+K$vIdo>K<`gc_{4+w5Lt)2#0gdD$#V~$s4Uu{Q0=*@?5CDwMy3}izd zN&}`U9-|EAAPo;2-Z(Yek+22?GcR&1gn49k71JfZjBAk#7=|*NXKnoJFTd(IiPNM_ zFp=yqk=PMm1WbmmtXi+p48@BPI|1$~Vtw}a;9uqiJuy%Y^;x(*4y0RVl< zNGy^>D<5v_$!yBxVHU?v_=v1Jl>>?kVhvazdnqbo7M!-seFs2`Tf)}AYzk9@2t{fp z27pY4+hdNRg+p(*a}GhA)Ab41j+#%%f7x#V{#rKaGG-swhVbaa^pJd*a_JLSC9&9V zn);q)QVy2TJB{n{3FcPR*N4|TDD3Ybv%iD<{&MLRETbzAbk>)3)Oq4VDOYo4H;;$o z;UA8S9a>*~W}2}R6q5&Z`$!Rgd5TcjEtAQh5rl6eKPc2@;^G4{T&2jDU_p?L0!&*PJK(8y^{G}IcryBPg^meYoKOw4{u zj4*Y8xaDQRQmIdNIcHV%7=JvY59o}d*^8%PT}AT6&#*H(`3L|Wwj0rWixx+r0JBxz z1nSb&E4viu1RHrS<-_@E#>8ia7nvvRo*yNOy#w?URUsX~7xpW-XB_;mM+D^!_JK*BTz`fK zD{vIJle@{8ugR6;0YLYEO-C^W_;K85l%{&xr_;f$MKvWp{13UGP zFA$F}5CzR_l36^ya;)CN$5)QWSB|W;`HQ`B+y_s&M|c4dQh}(2=?4S>Vu-k-EK@QB zcmMIfj_rQrd-fU7*W@ShJIrUql8jNjh%&`Ozfw62~B)ytQI0NnI<+QTv+7!H9rV-KuHcoQRfFnevpQvLeQYk}+TK1|}t? zRvK24j6*+y9L`fM>F7*Hutbai-bNQTIIx(YwifrQ;AQgzp+7vKRZYW?z$4%KVPaNw7;keGyd^1o@I}l)@3^x+ivLP}e z*W&uMUvc#oKE=Ggqz@h3*dPP!u%H#_wf5^cb4gd_H5DrwLkJ{M2b0hfR3Qe&$;$N# z*bWPyPLO>J`DQ^1ht4kYR&VW^HENI}eKW2fEy0bh-f07Jz`|C&M-8Jo5mLlp`nF z7d|D9cSHRh0HDnU!c76G?(UK^-*&@*1Rh|pf&_EykF=>5N>urS)S`g;JLVO2!&;Nn zCXw&#zGxgAH1=xsL}5ZOA3Le-AG`nxYwTm?~o0^KN`HhynT#$=McK#|c zznq!lQQ`bVOD?KlkhnYIzyc5tvLx1@l~1NsWWy@8B$pv|Tn0<+O$F?aFK#dr6#Sa{m^%r` zmFEu-xqqNO{>j?V4knh6H@uAYIEb}`-QPipjgZDQ9Y@?OsE0!SSJt>Xp84#o>Y4ETmX%!(bCJYZjM6dhYAY%E4zOM*<59%3 zo~>x%@H|SQ$ej9D_pSl_qGrp8~)=#`U;=)ft9!*WRQkDmu59^4$ZgnnqRGO z)J{MH&-lDh1*x^#ZR2c|_02am@@tV&5?}91L8+HGVd{lZ+!L#xv(Ptfhx)0Ll6B;C zS;BC?a-Xe04ba~3IagDl`v=OX7#St4{={X96!(>M1H0us2@{5V&1FWRl4j32| z0Tr756%7Hde%)!XE(&>}5PBvVpZVVHQW|s+pU<2CtH5vL`_vdS2aUBm)p(m+Mmnb8 zV&MP^;S~)-G`j@imsl+g$R+R&;tAE3INp^#$z>Mu-UQOZ=Z1|jYjJ!7DQ)0yabbhr zh1%)U(6_0)AWIVv;Ykfb7(;w_U7f5=i~~ji9y<8b#X)&4%iuPKr@^tDrWgj`n6UYl z?kfgG5zQ61Ci3g$x4HoCCsvXD45GQVmUPTI!t5yk1SyiLgflYnEK0^PvP!RiG3>X0 zFh&=rtzPHsyxSUe`n_?3-*XguHnz`bCKv;5iaIPz(O|n%&!1x+tb7&BAs(7o(9PSN zFw`u$*gDKmHApEO9a&PC$lE0g#936e%^?Vzz7fN(AkCPpI}08Z9eZMj&a$HHNXw*dJlQAbTN^$1@o_GIFC0liD` z3Ow%W^(V8){g|3>wN|NX-DObX)^e9N=-tDaHXVSICW|6kD2ke3+h16WZ*tDg7S)E$ zED@^1x2(9i%26xp1$ErdAygW!boP{bcRzAUV--%CQmg6#Q#)KcEMn6>{`a-PO4Aj$ zSgE;*O;(z#w9QJr>Km(&pT1@5|v6jaq56-i&sOrVVPhuPI?nkDsz`f z$T;;Wvad~t`v$|Emzl5aKs=7jBPX;M4#it|?rS#d$*1g9-}T^NUE5wHkl$sBdN%H& z0dVi;fQHO^{5kjKA`Iz#!QKIxuc)a%6oN?#Yz%zyz<4a}%Hr`_I%4rB4|uzA(6X%A zHhzJ)2IMEdZi%emVAT8#@`zvUTHYks1*3Wp?pz-nG;Vjzg}uw%m>RQi?)+aoOgjMO zLK#=Oq-?c)? zx|fu=>wCK0zq)jRH9+}sLYZ30f zpth(((8eXs0KM=xm?j-9)^_fPiqGvD=kj@k`l`ffWKNyN2dX3 z)30Lp3EQVZa)R1na^;w-`r-uCwV>5v@rr95!F>o0FTV9jEno{4NZcG^ei`eHr~-)x z!tJ`g;^<1k1Croo;Cl|gP2)2;@|UMb|BL^}!jzbONa{Fp18zVbD3IiF+5{8Q|2H zp0!k)otf8^1^)o?zhaH(8NWe_+ZJ|U$D}JRa)~^6l#j8Vy1LcL>G^P^YlPIC%nEnC zGbLlN0b?jkz*Cr8BDgi%=#pTaTTs7Fs5|k%w6F~-9YpG~6Q_?YC1Yi4PL zn4kciW#lIQabU*{5GN~|&6 z7Pt#_L*Nyt;&M8=iVaD;1e(ffcT_;*W>pi;c6mpBZZj23QRthIYk!I;kKYktaFOqG zafqx+>SxIt&MX=HBLjcdP!ZyFJN7)ZqnUnU)v^i?X}HrCwzpquQ_p)16l^x2tbxC7X3zNuO2nPS_L5+RfCOaXEtZ8F z%k5x#tpt~fSU49F5x0hOsEv6P;&lKn-gsgy%ZB@|>EPK%VRdc#U`N;F4|cxeQ|7`A zcTxz|jT|9Jf<_!TCj}eK4TO;&_NK_!EHEM+~XJ*hxOd8awQIf-oqGcnsG{Am& zl3y%!fzl8@z482y7hfMs$Yuw*tbnnBKgiVcnrx^#Gic_F<&M6?>cBG9%R*+M16OeB zw=IZK0nG;WBsdJH@NgairUoi5@M@!J-ZF|CMbSGq!wCj(-dzUI%%GhuhG%AQA7VIe zHX(+KZvF#|uMaY`8C8qHgwet<0A_{6rLNq$VX^#T`h08`@JC}3^H9(2#1OXuWQ;|;>jyZu>D0t(MdJ(`5 z;4~64%BSqY=_+r?F?t2Z!N34+Sc^L`Ik8hf%fKNp{05#}U*XL)pyBH%obJ3_xr5qS z^zSm91RI6p^V+rD-%J>rW4c$7c|~9UW?q{CilPKpU1isKV3+xniB4>=dPNS|c8@cb zY8%m;Xbc6!qTBUxg)?xoiNREu&kKZWWZL@bF?H!xGy`2;ZE|H_Qy1*46KcV0-a7B{ zD&vIYEt%0^n|*s<^9ZEc`DrItW5{@puS3+2)^(G2jnhr`oqUwP`}_UM$c|M{_sr&~ z#%QGQ+DftI$GD=(aYf`$4=f^IL1a-9zs{`0~XLOI-jO&tYBAdXhzz(sa>99gP`t( z21Dh?1@2^kQwcXxj8_%CVB>l8&QFkh^d0m2b3HvkSZZ%>hoM5Kx&j~~iit^1jMh;c zb3C-?wqyFvk~KR%*gND-1W(~N`D#Wkkm~RP%kjL3DUHUfCNjo_m0`I883<_KB$sGT zY%tR+D`&^(LG|>3O?ZzA3vEDV-VH1{S}G}WCI}HW$>lN>mRap|yj{Y579J$o#D$3y z2QaQh;q+x~+)xd|+4f(cau~R#noSX96wSY@U)4t3#W3WsDfsk)TMB!?566t_QkKWm zhM9deqyCOVuc^bRZU@Lpqe^H(Oo^Ke6ztSh_6-JNg8yI`>s(#@%Vb4MH{~%FOJ|q;+Dt01%eBygPZ_E`xA%I4&>xXwBR#PTh5tl-aces-r>#;LJ8+#O4<_aWg0oLx5-E9 zyHvv(5Jye6%{=m;aeQ3zkvECa$xis?)ppUho6PCl^Oucr&GJp#t;MH;CioBU56^&4 zDKW21yXqqw+f^PFQ24r$?Mt7!yB9ZF?zN+2cPWL8NgMu9J>K8jBLbX#oP6}w5QO-P ztKj9y2S5I($KU>$>l0JKGyr%-5!0}pInz%i&a8^dhN~+&+bUL1ldJKR7$A+v3E+W^ zlP(N+&mvv$yXH>Xx}_k!Tu8JC5rzV2;Zw&mtzEb~F$Z`o1)kj0g7b{tM?vaYX*^@& zVGiot1e|zn;bv$r_WcY!>5BnFR~w}`OKeq0(L84G%{Lr4Pg}bZ1~lvg7ZO+OHK~2K z8-zhF?!tLJLOF_${*%GjC|Me%;^_1S{4c@5Z?Qvaz3sdYv2uk`VaXPCVcGPTU|< zUf#)1gRQnrR2;aYkIw7_#wk!xKJXan*D(GvR$BuNT0L1@8zmv@dPPMsR4b88MI@ z7&e(jbJN`s-oa$7IpK`C2Bux8vx1|0icT1gq;Vqss=ppV+!Yf_t0$MN9Z$gx&28^wT= zIB3F})1~fJII9Uc-2h#meYORCZ6{elc`H!)L#utG4-CZxv(?!yUPRbkH#TnKK^Uh; zzda_cvraPGfdyBdx$QDC;MO5;%3Dr`0bP6X(hYhh#TiaU+m$tsulN5lG~ zVf{-P*41ww+GA7M8xpQz+P_%lH+qxjORD?Tt!^vf0xWdHYF#AM#5S-5L?1lhMzuv0 z%$U_2PLMo)>?o-Tc*u=!E|P{3RxA-Y0jurO8;DZo0qB`(oKTy@tz1{Ego)6eDh84U z<5Zbhjesu$wgG$H$a?}2)<4FXcvO-Si`418Z*@CI7sJuOXq}dgTEyW>merD1OpC(( zA-IYw;#W9fFoG~y?^yakcDr1z8>|xa#l=AXC6B?i?b-03Hs5KGRd?C8HYkopd^-B zvjK4cHRRaMEHHxXY-IYC?0z88z)-h&=rM0C@UbV1=c)ZA%EF`JhF1YD^U6Y(iR~*a$Cop64U6i^%~+@Q-N4n>#z3ob#tPBLN*pbvjcO-K zsd!hC*V3nNuCa{+s@(zgtlG8~VvUvBSf!P!TdP#P`+jKovp3n?eS)ZM2Hvd7wpW7> zD?tHy4OSzDyjJeIk@;DZ@2Tbc22R@?oY@*wQvoKdJmq9Ix)$|hwzQ#r&dHN|kF9S8 zERBPXVf@I#oKR-UG2tCAfeuD`@7R@aXbgv)e(z#v4Bi`qbS!ap>2|kc^hSlH@tS!t z9JNNqMdzq%RI1QFGkTRO3=Eva(M7l4ZgtnIIxtTAqiW+kX?2e;+TH$et)A7|Yjn

    FO0#UU%0(zgZ`-B?sv6%6l>zthrPfFM6^g5$Xt9$XG(>v;asMgnCNq^Qu9qk|jI6 z3T;*xx!4dfgAYdM-AOUWsk|epnk9B5RR`wQ?)Tc~gMrZ-acVCl-*q-Lv+DqFK#;%U z#m}t9*QnbWj#gHNlhf(FgK4!!#=DPRfk{GdfpjGO0 zTfKMZt#{?-!0QZJy>~{rm1i|d7ab0zM$+n{eljqQj2@hh^8KY6k>X_C1{nR^p@IIO z^RCldr@ryiS$}BUWeT7P7{k#fny7M)%90eUPnDDTAB5{GRioW%pBQ2i&-m%AGbqVUj|ctJQUy=?!*acMjxSDIqjovcfWrNw z&T$9sU7cRL+@f`kQDdmqPkF-V9ABLG))-c|1ssjnD_5h_`=MOHDn|!3xc=ZnYfw_c zoDGa)und(d+W+ZiI~rqIEnf*|xB< zl`1-_!c&H$L8m>s7!6vz;aPt$Qm*hNYGbuy;0{$pM9J+vKYKT59hEFQWWu~xj-9-3 z4a!aMeWz8b+=mYzs?)E2*(p`!2g5kKXmva9tDKOs>H^c7E?VsZErgeQ+Zr0(POqfu zA}V!y1ze05Y@ZnIABvPwwJcit$`od+QL^k=0iE!IM@H8u+I3#^UD0icmxC=VRj}K7 zYm{63V#y#1_S@wOo*IK9Rw_#V&}xr5?+ZDLEZ%N)jowkKfa}G@OA_Ge4+G<zME8FY$qby5DI=$om;FRmfWf~B-*fOQz33ODY!dYv8 zX5zslTS*j=w=d5d7v`_k-woz(GAQX-+&Wyon zt7r5^-P~6jwbF6_yjN;OL&Lb}k52L*;`RMiFOY8K-CcL2Ceu&klYm znh@(!sn*-pk+AudnnzDu70b>0to8FL8`A1GN`1!$Z#zdv`5p+#jVQgvoIOGvG)9(X z1|!Zq;JK(Ir_=A^z>KRbfw00ByuK$G_;I&WZqwhbc-2wMF;iltk)I8WcE5Lo2GWb; zR;OEV|)MwBF%pS*9Zc#>6AOfIN6IM~_UYozt_f0j#{-B7sKse)G1fyBHi^Fr{TL6lU|yErmNc*e^ueedW)=V)|t(e0deMi<6UZNpgM50l(!dHL z5!~y`iMs5hvdrmHKrLXTX28G(SV|X;7i1eWU@GSS>{AUg|XqkN={8d;Liqy5g22TfexX#01el4^{ixL zVxte~gz8XpzQnZvEGm(fmlp*bAD_b!G9X44nka@Ac(P~^qm}aj_Q0G{X9&^TbX=K1D$N5x?gz7~!x7@!Zv=3#f0Kj{Q4=^6-RG3_Xma4Pe}; zXp|F;Tw_y7-68OUe_@5|XFfxnX|*~n_@~ThEec8uTWn-Z zN81A9V--PhG7xo$fW}W9Nrk%NbLo3?(PkXKEQ!<%l+%q zID8AmFfw_Px>D!vLhtV~nl=^mvXW;HGu(0DFM0l0bUen%vg8VL(?w*B9A*_H37RFE zU`du)(g1Sldp7}a;E%3%uZOz=(1sZyHoSi?*9cK zj~)DGho^np;VsynyImKEU%(`IdS-#C5F?s>#_U`a0>Vvyseq8cL72}Ymt%;D5AkgC zX>cI2)Wq*_l6QAWn*~^#E=ey4$B1Ys#jCBdQZe1Swqj!)g(6k`XA#mM*ulb>O@2m|@Bwv=xO(NhLASDGpL z&j(I5Lg-mYWv`1C1fmkC(Vj5X@njs_%mgs^aG5g6+;;7`>0mY&+al+Ku3{#FDK~d_ z8LFe0{}`gzr}k}~z#?FXIRj4XoDp2+Ex>9guIKIuv!Z&#<7phXG53`Zi2Gy<;jcSK z*a`q4-gv&XT_+1OoYeu^-Cqh+ILx5on^y=9YthiOoj^>Ajh%rs+E=dUOYBOydNLWy z2bqcM3O@2hY8cO@J7}wnbHp%99>1v9_{!EkGl25dmJmTZ@?gr{Q{wz1-)Wo=y7B2% zQ3V*8H%XfG>pam)lc1FZe<%MXpty~?L-u$2q^8@+5g}`hob$Ceq95J`=WOJ^oZn@A znV$ZeFFAjO;ly?h{aEp_F#Z9UdXNJSt-#nP&52YZeEg901og8FdsS=%5Rf|>b|J}L(fN;wc@&9!AlK3QjM zqiVypXiq&GcM;>C|7p>Q1C~FYQ1?kJa-Z<)2&d0)*qM65zJsd&c>MPdST3|L2Mwzc z2KUm(-rnBx!$b0qy}kVx&-UTx-v0CF_;YXX`QE|73-XWs!xx9o_nto6fA;(zd;8B0 zpYM@>?A^;~691wgH2r_!QXnZKTto^x{Q2>mq8S4ou5jEnTr<)WzdX=Iv3b=ZbPAp{eMhRa)S5+r6I8flDQ|YXSiJaOVPk< zIXm8z{=M>T-k_8s3XnLM;{fcRjjV$yp~K~yrkFppmQeuIQGQ>z6xIqo!oNpc{|mDUnd4B-OwM%9Y728O*398qGxPJ>L9EpVG5Jl6YDfaq#L z{vWZNf--O^)ot9K#mQq^x8i$Q%n#wwH%phP(k+B9z@G?J| zgr2mHzG-S}sGze;gNypTx&rYoBn@U?@A21`k54OoqRAgA8bGtCQfpjxGoLmNGdA4p$D}}k$D>OE?t?Wez!ZHG z$(jQ3yT~w$c}x{Y0iAyKUp5YMvJs%MtmQZ{+Y1V_wpAPwxtZCM8Fy7c-#SQ0gUOm0 zxq3diF>So@qjy}K2WXwibS#IioJ}rN_gdJZS#aVX>C*A8bQnv=cByb;LP;~^x6y37 z%F2E;>Jy#1^oEP2CpvkitzI1~9tr>G$PCT+!%T>KX2ceS;*n+o+gBWXzdbzT=Ocgg z+UJD7CNeL*cxh9G>>!AsdfxYiaQ^8j>y2z=0U*)HoUXHhIeV3{uWN6a7-S%HOMbX? z3cnjoi#|dpV5USP69!k#Z!^8!IlICnXEB7WiCxGxk#J$HbPKEr+r7He9MuG(T0>=J zZ|Po)+XbC4Pv86Ns0?|nvwxWfn-fU>k@o4Q#G_#RYN(Hb`5mm_My00j3pTsq<;|RZ zw7Bw3i~c#YPv?awlMX`5MWIOYQsO(Wy=oFW&E>Pc)SUon-Y@9$>0fed1Iy+;-%6|0g`tn#f< zoyf*7i^;|}eMi)GZ-ZCE^zQ0y-uddYs>e;<^3+6cQt;jLM3U*k?w$tjex%`qevR@l zZ`6N%iI_L@2PhL2+TFZVR2siexww%ujCYrfg_#+v z1n<43$GxjKu9h)(?R>eFg>>$GH!iPN_OxlyolgrJl;Wirz@PdQnzsy_6#u1G;ZJ=M zEliKQ@%+m7s5EH(eXWW^@g)8x%0ux&JX8fDlkV?HiOB5h-W7@a&78g=g`z?-^*g0f zUstinp8I_%7x}&2lY)^$Bb!$;iW$X2P&6`^;~tca;??-m6pmE*g9aV3yGtgK?~t93 zBnK&jd!|3 z7?TK2$_*j?%dS~$Wv?Elb;l5`;#F6q+^P8yqN8MZQ|QG|bvN`ff#@n~jSxJ@al9K0 zjF@Ut654r#W4XyF=S~u8= zfKt+%nt1Lt^?CT5iKzCr3mCicsQ6HmGiI`glN->4AEVMsh)IsN#G+5xZIRRRm_?H| zkOaqxuVj6k3J5R26BiIFFip>;#HAFDy(fkgEga9Zh)Jfl!_m=A0@?G#p+Mka7u%y! z79_gPnQe95qJ-)IN+-}JuqdLd9&aF^I@E%)Ew*MD1C zs8y<}af^x_i2~rVf)uhCYjYLdJp@X6fVUN~A`L7{USrw{M$`xokPEiD<{{YKg?OF} zQb=!n%LzfMKu!;5S%-lVFTxZdvGs{8JkJ5TxLjhSG9waG;x?>gMUNz*w}RjCoD&=8 zeib%eKk-5uo67yC(n%LGUV>Jdmy_o0^7sFxtRLLaKY_l*G#9pui7r6@k6!@D)ON3^ zzkswIsQiGuT|}3TJpqy-TQLC1cwxIc!OT2(_I$j(a%s5ml_)|rfg+T;)R(;b9_I}Bou-`q7Ia_7ZQjLJxlh#hwc?)>o6RS5#<56as;#TAIVWd7oROGx#W_gN zVG&(^q)RCBn$#BE{eOMB{PtvYI{44O=TUq2^6l<_I^SAP_YU6v?E9bW_t9Ya;a^AZ z{PWkf)TB7|G4_YeZj=A>`gPnzYRYT~^WX|PZ!4Q}O?{beh@g_wBsKCcy*44^k$!Hy zDXIO>A2@&@V(N0c_qj&K>8drzoq}R*ZibT?@gg4=36ej>%t4=|+#}$6Xsq9w2Upuw zwu|1HkQ6JPYMuBd?{2I(2 zzD3eG_I;v71g>&vSO@$XMY3i$2xbd=f-ulBd0e7F>R#Kv=gzf+IPlN%vS>$M)P`)c zNt?~92Lh+Y7_CAG+pktML5NC#!;=;eud>3jJ)OQYE`#uIW(G6zdX<1(J(jb0^%k~! z#aT9tA%mmljKML3P#(kAS%XiGf%>5+$aY^@5}nBThUcDmweO7Kea=^RtKN?`VjXBX z4(b2U;1*2A5vZl|1Y8@>SID}SYc?orYtYU)N@vX1800jYZH@S)#)bs@$JNsl44PzdVO~Fz>zR&4X6+;Cb`e)8^i@=C}LJ z{in@?m(6Eyo2}#K%e`i6uX%LXY#GhNgXTfI`SK7}@!R9(i5ySvN& zth2lP*UT%qJSXe$&`%K09n4?loV&Y(9P4Y<&ysv~R$A?7eNao;O=>n@2BT{hk}m zqo>Wc`_28A&GvEes(kS54})c=|GsB_YtPKL6MHahzxe6oH^=^Y`0e|f^LPDDWF4Np z-G3=pWgT88>MEQKa_xwZ1!n^E&mHrMzTSJKTr^%ksWQwbdetiX{zS4CwS|ud*Uz85 zxP2S+-_!lG9|t%6;3T+tdKtVM9lZa&^Xd0zKm6<2w?Xg6n;_Zw4=-PMAKrdA{r3Dn z)1_ryA5Fd6?!R6-i{8>Ze|xY9--Yhp^!oX`gCCPsJ3qd4dv6W)v0uidlvXM=BVe;>Wv z`}pIn^&k50fBkMn?YB>(-}aK7cdrNbJL9*(r|IvJPk%Q*M8CcKVAF%E<;ki4;n|OS z&%43m)b(y(w4kc(PMpZ1!|3wJo13;9q&c+qY%aN3&a*k_p~)vXE|bS~_S6x0b4n~5 zTx2L_-?d$t2bc*#!T1xe+(Nehlj|(;OJ@QS_`fkIu9hZ3_&Kt)G(j`-;WnMSA^j%w zs$gJ|?=*A9kTd3c8>I5`+O0vtm#{qnQ zFQZBPd(8jwPt+DB6uj0zKUnzQm2b{t5zCXXM)-&APCS3%Ve)sVX?c?f%y{g^X?`>t zWc=^pkvHKAVL_gc(5G~FZbEjnUCW#Nli+aL-eT$7SF=zi8-a|WzI_>mo*y*uYJ=Yg zAmQMCV_}MsGwRQ6mO#r62xJAnT#_r_gxn-`GW981jv>Y96|FOcVF~%F0uQvE(6n9l zFgo!TOK1-bngHJIO~V`XE^{HrN#IRvn15pO;NTOGEf6|ShP=iT$i(j9LQ&HZN#w-0 zD5c=--KW6JkxE!a#-YHDEaIK! zUj;LhXXRtJ9E;d4v}P(Z^I;g^#1-16gD;XO$`dngh;f`4WY|9*eP|5~(ixJoLH~W{ z$T%WTT0_zqKBe%j);T@v zc8sGs>Gay&^P^7h9eH~`BE9~IbUUY=k#R&uee9FB)-i_A-l;KYpR{_T*4s|EGy1s> zZ5?+;J!tv3KOik~)*6gD?elJHK+etwXZ@i;TD>FE>-Rdn<3XqQ&NwxCqXy~pNUu+f z_eO67R*r5LdV}U#=cAMU00v6h{j;A3op&cAa?S|_l&{bMNA=|R<=!5V^<*Egs?z`xIjhHR4@8Le)o_il*m-_y!B zFq6^U_n58;Ho>E`1T?s&l)fO)xZV@l;3Vq{j?#? zqf*YXFN5YkcXxNmcfKs>*q5)L(BNS2VDAap{T`c9>VSH7WBOLGGtu$}E5l1Q32*7I zpJ?S3!7h6_QfIiJ6EJ(hp-jvyr+KF61r6{}woKnQmvQTv6)rJ4ron&Yjs)b6SZAg# z1}qV{%#@%E6`1xl_3`j~Q)T1@gI+ySGYH^~qfDV)#;gm=F5St+%=11Lb)8(D?46z2 zj&&h!YXxPU2qbDzDSk;SE(IL3uut{`wz`l7nnh6=+q`nUAhajJ#bjo>E_I4(xJ84r z++cU%dviOWn=Fb}wBkZL7|v1DTB$6rI<_@7KwF8%3M$)w2O*dzbq@P0U>6nf{EyVX2xo8-iYETMV=J`qr(N8? z;6HBvQQ7mx`&ecFdA_&*{OQxA{pb19NBhs+|CO@;>}K42(9)s3vRpw(AeuZbmv~ne zAM8llApz>(4OHztRNAR!hwQqJu}_xm(@6+EaFDW+QeGq2O*ghXFj_~aMq_T_)j;v1 z13$HycY~G>^jv06Xd+v!G7apeJu}@a8VIukH$~fFK%FTGW?tl2sX$yl9B>V%^MwO_ zY^@loetH_B&Nf^QzmW!wFegh5nx0zM02yM;?J%U^1I;hJTkOS*2^jF1VpU|y%Z_NR=Y`Ve^SjaaYEDt^ z`px960`CA1K|zy@1eOB+0B`ePf!Q=CGdeewh7w8ojwstceqq!JhUxH1@i>QGJb3nA zp2!%h^}>5%c z*^WhCrxqx?ah{*HRO16W_d?po8fCgT^TDobUsL7^!IMKyOc$8vB_;nJ_Io?54d~ih z(e=3-P~SEk`*(;*eUHr*_J3+4h83TpP=+vM#<#C*@LB%1d2MpDkoJsD@=l7n2F0Yr z%fS>@6AzRqeO`F0L3D|0Gqc^WL59qNM43eS4pjN?*_6K9#Xs0WGN%;PS374!y!Gs) z%q2(2QrB)NNm#cT@7VZgv8P^c66vDxvRxIF!l>1D$;1rsMP;EAGFsY!c*UPvHu`nk zn1Ohqr`C1>AA_225N@w$y8g0w~yAkF&@( z%_PsPGORP7Ufc8r-v-6g-Q^{Gh?=U{Gd`qEoGJ3Z^majg8{hn#l~Y`>!M$nnvn~c( zWrF2*HXVf<}Ncu^(LM>wXgcsXfb!$1WV5*MnBC!8|yB*PEe0BHfMx?KHnVq zASS0%<^>zyJb*3n_h<@k4e_J9)VnyLShj^?YHAmZ)w`zt)bVa|PSgr5ULVuyUgC01 za>m&!r$bepFVQ2PcQ(n)&4r*BcywhS22>J}AiC0Y#Cv8cp#sYL;)1$FXJ;D_=?{o)ZiLL$^Hhe$SwYSO0C6KR`MJ5+almzb;yDh7A`!e| z<(xm#<()PrF|?$F&gc<~B)TlGCrFAHQpU@%ETmb=k*raXtDpnaa(;<+QYqUu$ZJMo zU4u;IlC0r3FXehSG7P!hQo5Idp!F@(xfxVI9x6+7P zv6nZyx}r;C0DkQzTtdOlIu%GIeB2m}!B~atNN@`_d347kt|wa9lI*1sSUZb@EOfG;7M8o<;I?7lA}c(3iOITvWr&%3PtXBoZyK%XYD|-R4gZ|p1kc^)*d>KfUF);QKSF^FW zs&^C|A1q($1Qm%yhB5(;xf!yN0c$A3c5C1j?9cIi^4bn;z+$vr)nbhfHw8kq!#iC^ zxV9no%;o4Fi+j@FzpPBn-J^lHMh6P2F8EfP{uTPbH;7>)n2m1guq{oY?O4*n8ruxB z?60~lHECf6@!(R{pEqT8NI9ErSed!{8LgPgaM z6`OP~7Vkg9aIHTY%uLsE3Jyj^yKpYCb}WR+aS6SplZeqO1I=CWgl34c9A6h-@Z4yA zN&Q!O9VK3t0c1At9Ckzjw7iJml6|V}71AF!%iESTs-$L1I-v;YjRNN3zzzch@^Gq2 z)e;Y?vA|T$68J@W{=A5yY^#~EpoJu3q{hN5Vg+P_WlD3@lW1;29JguVF~yq^lQfs0 zD_q&vG>cv`I&2kVQE_F+JGdD z6NwME=p0gmusz$`0j$QNr&RF&?O|J`7pLtx(cInG2qxHE#W8Rtu5*;%e}QVseLdbZ zW4Dh=&z^&Be%E!L!U4$y=>P-M*_h$*fFSlMbC4;JzP_`b9aB+tgV3COBjby62x0KGZzc$7VQR2Nv$_oqO2kh z?#Yuhw;jh0D1nUE)>K=RQ=(+5-{4N`3Aj znboDP4j=pGyo67fLW=TwP<#;*MSE4`s7m$1^Q#;qi21-8od^RexV{%1=R3^BQ8@qo z@%MDU6OH3Zt2G@$htm`Py_n)S*Q^ltTPg z>eIk;uGz8iDYx>OfDOQW_I+q^;(I}`BdY`Xg69AgmLu*c+=$mX?LHu8+E|#NvWWs{ zI7%^^N>8BL?&>_q&TwWYc<#jtqM0SJ69p8aT&dUvot}YzJPoN|&VSpu1yde|Plukk z-@E)2`ofNnks0`sbddXt&AR zx?;Q$G4$d#f~Ue_Av$;(luJD6UsK=5fE4L=a|UJlu2l4;8%|hAHf*SCPE~jY1gmUS z444G$8tQfcvqJN@I2riPfgvkaV(TQXoV08Slon}%;yBqXfCW5D&8s2_yT;uiXB9qh z;#A(Z>;TTA$W6dh6Lh!cH!wV9iuoI;<#JiZr-8wqzg-Fw@H*Qj2Fx96l!3%iWa1T! zP3R6%Rx}y==GX0@s6b#$Yb`u`eia>0-K4KXsge)97Rog!VSng3gG$B@j%1zVysQ&5{2(t#AHC6 zAt0%hd)}0tylHChta)CzdHeDA(SO!pJjq9lua5IPivGWb=+Bu;tkS17c}BYotV_}} z*UiOUF_+_Ja9K~`!<9Mion8U*CV$rpF{YS}@4d_cGK{B$TP^2o2X(EqSWDZTQQwx% zg=Khm`O9`rl=+!-4!pC@7mHs`)QaQbRCA)voyZzWAlxVY2r_o@e8NhvOkT1~gU(XO zP3ll|BVrL1b=;}YgFhMg09xT#s;1RLzH#H#Ti0li9DOpf1E#TsZ`{mTc$azAZsUwz zr9AVXcq~<+Noo=1j&%oyE(R4(x9>X3FD8mo2B-UzMOmk0z)n36C)ngE!FKO@E((W? z+@a#QB}e4LjTvKUepC+VVn{<4s>&loMS!W{f=$m_HEha?WH=;eUUbkqhT~D*$u7(M zZ0^A6$m#Y=D=kR4J)H>NCn4G zi+OyPbOz=A;kYUZm+`e;nX0S{uOb$Oe6TTl1VXwHpZ>5}te_>QM-J)eMA2 zEaCUA8L|V>}m3zbiV-$f94X&n`D*c8AN|k`J<{; zRTiWLDOFgoQH3j8khd}w6s6ozy39|QT?f;ktz>09W1GF8A!0Cuua#T{NCpqNJ^B0F zswmEkMd5|gT9p!AS#26ekeKn+flXnP&%$97J1E_V@0gbHkYK|o02`%A=Qwbm};jOaz7VKXo zcwiYFs334m%n3!Do=Krgku*G3i){K zZ+&WhTzIxy5-&Y2Unc$}jv6c1x{Pcp(|A`zG;_m0d*mvGAS0_5TbGhR^-0Db!|=#( zl|Vet#6c@%Us+^WOxf2KHR{~f0-C>6r1@ICs!@nC7Lug9cE*tvEQsIF*d!o*TNo5w zRQ&KBS)w)`>RPKuLtU%%Sn>}GHT}tq%*}8z6A#Qdpu$6g6;H8Vi9}DDJ}CNNSC=9N zv4$>){h{%bO{{c3ZC0?HFCgAJ{(ttqwkvKUX>>p5SMLh6;=wLXBu-#}LvpnVww+i-R!4 z;HJJI3`Ka=Ww0Q@S#^qux(pWG!OThf{qmt`=kJul75lw;*K z6ZgvHx=!U(zJ*S+;1M;i`A?^>R0pt>o$bPvu@fU$#MbX{8T|)N=RPFr%!3i{?Ju^k|h zU&(Gea$#9v_X{@J_CS|dVcl)(jqMw72eLVO#h@fUod6VV7d*91Q@z`&^<1FH-{(+7 z{whF-P5BmrbAxEQ#fPPkkT(EnA6unT`(V(~Fh<)``Y*U-i)ShFSJhe|feL*ifiDva zbP8>R;A<_sfz4$T+$<4wXUr`Fo+5I#hG?WoFiy{79T2usoq!m0=}ex-8r>W4k}*#v z()eavgtFX?HBqf_AvsPRE0e)Qy-Oh2e1`(#sram^G)IaP6)!GS1Lf^&&8ES6Wp*(u zOBu0#+wu;ia&a7`@s02cl*+ItH?lu36s6)_aLG&yX{^^4Ep^#GPhBF)KRAED4@Q^Vkn2OKm=Gcd+=$@-$oNX+4$r4B!ja zbIYBsJiB&at18#-maAix>piHjEo{VWo?I^;L9VN zbVb?jXLjr2cJ<`y?7OiVe~?$xQy3H)VpRsP8K^v*Vn|ko4bY;)je*!0hq1~Mxq+8y zV+^jm4gLV!I8-_Y872r&Z;;6B10U;CG54Zikx?h5xfh|Z)FDQrr$<1Oszb>U?JVyV z$V0vuUZcZJi{$ms)KylC9CoF=4iU{d#ETwgyz;X+^p%0)HpH|u$w@z}oH!s6N1d#Z zKs8_*#T~Wi=W>zGdV>4fdmGHNx$xmzZ26TNU{GPl!sKbnS}Z*jyZTu`Rf0H1a3#Z~ z@B@WsLw7rlrqv0>CcmjI;=tT{ix_na{0D=5=#4Kg;|JNLbg9+#rqLvJ&6m?sUBgEA*dwI9NR#jVp3OosUrtDR#i!>}Kg`dtRYT z%5?&qI59>exnf15RkA8>URmPi7xl~vG45TJpsW|LdbYsXZq1R0@s~-ViC$r0u}Qb6 zMbGV%^@A~{F~tEEmjq87$G(`jb}NDcV8yQT+IQqlRSR5{W)MWOZy5E8@O6NO7U&*- z?WJGi4P4|T(T!-xu-+7y970-b43wXZhwA-`{($xH`@-B?SeOq ze^2ek%NQTDwjZwn;~ZlhbTp)H*s3hEKZakj6GNX0h^q&&TR=jR({|qDX${n?;7T6( z!K&UC4jkuOIQJINu{0i2KM1^(I`^Ry1EYCfdyAh=U#;f2a}pKQ6H}YH^&p+;kt@=q zZeNeio`4dPwV9d&^%_U5y1cb&h#aLwrN%L<1#nv#su1f-avxdPK9y?lpl zrwutddOpKe<)y6b{JS+z%>k7saQHV?Pq(Peo#;!E!`v|LDksAh`|d%CJx!Gq!AUg& z*IGxA&0k!T8W4=y- zbBP9888&d;Ob><7o8FYNChli-1ADn7o-SWlTMlpi3fHv z)c4DTFjLDb=oZ*=ze0H>yK7QiBk?*2?c^dW$#-rfum;E9dh&DsLF|3S*&i z8yDU%4by64ZxOX{pA(s1ou1;)`AiFyfFsp( zgShi}kp}bNzYtG-ZdY~VtTbPm0bn(od&wmk-u*b*$iHq86JZi6pS>EtJb-))ju~ZM zq=O%GIU2t5MGPSE4bI4w7s4BqUeh!5hc`yKnV~6TPS+Dp zgD=C>qfTF;hn1u_u}YsEL;n^TDVWRWFjqS=_4VY8P1Cb;KNtxwO_Sgv}96wv-3tiXwQ3EsetjBMLpnwm?>8%H;XF&*d|4b zl?N`KWc6AT#mNg~IAk{Zpv#Q=z%3U55lz^Xu+7jj0Bjh1ob3l+fADmHK*q`v`Y zVS`$C&@bARN3Eo-;;7Of;w9%SSA8Vf^qv$0BvwktP2)wchG=peCq6ZTowRm;=Rrn2 zXolt7yOgDE?$xo;!9k_TLkLtHwx;r#bdCb&>X6m)y;SMZWD+OoM+G?>ns|54s0vq; z*$ZqheR~8z#xFO&;q$QBCL0_7n=#9GE|jO0;WS7?=&i1}nw=M!UQJwjtq(*v+X_|H ziUfWUM1h*U4+Wj+UHoJw0$$_`L&>Q5VgS1c*$RO=)4Xd z*-LBBRuw~fF6%P1ac#5>s+MEl&yyscLJ6P^3b#?F3_$K@qJ&Aq0U);*&DW`SDWkjr zUCLlm-O3JWl?03iU=`|sU{pZngCWapWByVyXZ?PeAB$tZi2yN=*?02icFVwWei4Vk zxKK|ERJ5@d*<~ZRCYG2(`7F>IdbGpsQW4A9G~V~QwVw2Ia`Ze6HSe4*$uu5Ioff_n zbLmBByZ-yzO69EE>NY-!Lva!Z3LC}-icG@XEC~;)elU$Afb9FaQzf-w2$cBp(brF&@{G-o zXvuc4f{VT8PWMrmj&38DvcoZ4tzyN@b>qfyl1R0H66#cm2OTRUD<=q_QwDWlH*;LB zRjwSo!TOZ0WD+n&Aw;;JfxscHv?mYiD@Eh`!Hfl+xUe`ut-V_Gyp6R1{G$g z2#ES{$^LX~3Pw2|#?d60cCnmAX%dG@%;IY!ol9|%O(syYFO3tax;Sr;g}sjb6??%Q zQ;|?#jJ;G&<76o&L72*<)eKIb9nx2U>|R3*P2w#|8B=lJCTS~E&0*=oPY+C7iOLpS zsWjzH9-A54Yz6?KKwiInsQ`D?I7*vt?-iBg!-8=C`19RAyPVNq;^eYmFG8CS{r32I zyPd~b-}N*PALP+{5zJJT7Ba4wn?gCVPiEnL$d{Cxv_iD}mMl|+-9`%g|E znA_hJ`5ef29uojf=hnnPcCD9RP4BGGQ#d#mlN9VEnz}7TL9obOPwCyN&>G2W-U(&Z zmgRO4AeV;Bcrjhhhw`_+5+g0LCRubm`NhLJPcPy`n`}qr6;1GIj78tmnVdIM;@S&R zYr;3t8Fi-V)M5>af{Yt0RQ4zI0bdb)T2{~Z^^^*xkrg4sHMzA44 zK+lQf>-r2O@;@1L<#q0Nbp;&U#hdZd`5{W(SaO+M{{xat!TONIbMbE|j+`vT-azbq z^Yw1SvJgpl7DQutw1~$u@m)oRFRlGLj^Z?qf-yF#2qH*x#;WxtfP{ic$^CQ@qzR^; zarZW@cGm>6AY5i0jHzq|>xc966GQKk?CG@VGr3Dwp*G57F4I|D<0S;szf2UW|L~6v zZU+VzOcAOQdr|{05AFyss0o=P;xPZ)d2JTW3J7U(?&MhUEN}rYqCK48MnFJZVpcciMDSMU|^1`nK-p7q?YzI(47V`svN&og$A>32%=I zW?j8-!PYhZwHJmIrd{MKZLby`8U1>FhOGr*=GfmDNSe;kfSk9hAb+N3Qi?IPz$Jb4C0nnowT0y^HX8I z)^lEX0QXTDa!wNV2N6#!Ize@MFJ#@8D|ucNJ?L^`;_+svsRNho6f{Y+avf-n_DB@@zKfy zR@%L+>6&Y;`GP>hVyc04_#m1pO)?m`x%KU5wKO0ol%+^H*V%4bi164KS8?F4eQuMpPh7+B)*k4Pziw2EBQeW-Y>-V(dr^ zSqxxg&XPiX{+g&X->|QC8lS`}wbcBEgCs_pxFbVc;wKo(A|rcRFIN#T&5dNf!W`%@ zF;ZVG0>Lw#{;{oEj01gn zmBP5;G)QOJ#W09>^slz{nmbodced(w4qo!%AIiQpjuVrN!&Tw=~J3ZJd%~%-q}n&vntXF))1c**>1ueHKCg5>Xb018PYNab={w0e&=PdB%8~I}l>yY&?^5Z#b3dbNXnbBb<;5fSywMCk+H=iZy>E?Ok< zJWz!ynEF>Oq3Ld%Jn%W3&!K0d^n*NtTG=o}2+BA*<3tj>diT!U9hS)QRZz9*89u`L2Y*&kOt-h}n zsBayP8g87|o+G!?U2Wr3!a-$FT)X(v9&ocwEKIff9+pAAZ73=`h>_Q-6eeli(tfP5 z(B0Uz1E=?r~?fd|$jaaUuOa?b!*GNS1e+WS_y5O5$X)4p)nn2BRuqH0+@7M}Du*@t#O$mXP z@-5`Sf!DkYXfL4@S6&+>pHt7&?xgGkD>r0aC$M8LfviKT;)v->j_HM5*A7f>n3~uV zT$rBoV2`3S>F{QB2EL}iW-C-mriYnI<2f;h7no(4%7pHK@8Vr&&7a&RBWs6tJ=8pm z=ZhdL=z6^bQu>@S(4F$AJ>Z7os6EvUq|p+{w+%)4WzHgHw?HuB3k0U>2?3vaE?=8bnqcwpD8A`B~fxC&G z2lUA4_U(#PBDN1<%ln3tTX0lX^$eWkm3#{kUS}{B)Ob=GgTiN3g~|O{aSsbq^i^Qo z3pmJXR_Ur))nR;lAa)fCjqs{dMA#?=p#b7A4A5B2fz9BQ^OVYT>TKTGTX(6&lDJyn z%cGxJ#WvNibk3>moaw*^O+kxpf?ZBN^I^HAd4JijKrf3{eZXJ0tamU@gDbS=?g(Fc z<|nw-cBTASheh^;SJ~aY6|Pn=HkyHFj)Au!LA61)98^hifb z3i4NCGbiyNm$3)n4Y2&(G97RACHmQAus8@qZ0Vrt2woU;+r%zIv>rmAftqL)ZnGMD zK*eypWOWLF`hL+ILvB82f2UIv?jxPZ!%E69deP*6@7dwwT%&wbIpU;dPY?F;~ittMhMOxR!2 zYDVJyK-BBRd!;kK`cAcP(mMBNU0ZY0U0F#Gp2t_RW>0$2Kf#$=w&1ih=vMi*1EO_V zpxNgVb7_&hz7t4C76DB~Pvmh}8yq+(gfLO5U8^#bNuuK{{{D)F!5lmq44Wk;)F~R~ zvzN}#ZmwvwEN}xwqZQ-Z1F_xu6s19wq4`N$N=Y*?AyejUM|}Vj*?L{MF)wi*>q>Xd zOLtfqcB|LU3Dw=$M-5CUvQn2LY)j;%(@AO2ty0MW(VB$HR4$Z&f|wD>-hK|vn zBl$Kh)R|uCXyL(MpXZXADZwJZMSZzQC~GcHYf%PhFxv z6ymS#V~o@&_jyZkH1?&#dV1#193qb&;q*f*jt*;-QAIv`8YMhz_!utpi3Y5NDGtRA zCL)Sy{55pv$ydZU-57N+{Y!m4sFxnNb1A}lxE3DkTxE?i7ueqlf@6Rlkq zw7dCPz7JAnmDTQ!)!6mWd@9qtm7bF&zO+Z&Q0XbmbpxfR4E3$UQPD!ZWIW^gtF%vC zBnPB)?lDbmo_ngGFz<21Euw3b(88D-tD%M2Zls8oVSf*>lx_2VP&5yi9xzwE4YxD{ z^~I<)AzEW@ZV#|$yO~9x1p9k{rOIqUSH-5JX)uQF9MoZenm?N;!3#MJBIt?RmjlD> zSUkDLN{|n@;l9{Y-C$EnAm26=b#Dw^2ko(PdD?qz#I(aTdAZhW@^Wq0qze0cfTipl z!*Xhh1UeB%cBBys$3t;QX^_xk33Au4S7OA5cs+I?vS{pO(^+ay5GNqn<-Zt;<0wc2 zFRWhB*dxEKKR+~|eD=PIHPfVl+#TWrlv{4-M&Yfp4azhC(A)jWR zyM(!n(6ajiYG0?QI?kcQPZ%!yUY(yAl%D~%x@%JyblX>^4AGhb>v#`H71dRjsS_*{ z|De>GJk^6y^LBPHyn*H^S=wwQyfx&u$zFtJz46RctbqP)HJ3*fQ<-Z1eUI)zp<(-T zxkzVqbaV{8ZF;()TbBaA2tjFIB=RbVGw4d^jV~|aw_<@&sgWWHi)&fO5w@3&ld)8~ zf&o75m%&1Sk!cY`(;axC3;HBak|km85x0_5^-@Fe^K0^4r^yng4JEqd86@Mc2j~An zCeTg=X4-&-MG$RJ_joU)x*Y>3XN>kE@Z(eDb{g~OI7>Ice3V6OfSP3C+OFgG4Dbo# zRqKx}jl1=rnJQfCjG58r!5juvYK{kG?(@B*9*f02w>BITkn;$QTiSBdC023yXKw7L z43pNKzseVLCg$D}PGS&2)=ntFT6AQ6L98sv(7uXwdFH`?v4^TJIUG}Anqje@cCko*hx6)a zM(aMXZCz_`Yufk5#Y7gBNctK+)-rJ!VwM8iot=xFwXP9F> z^^yy$qed%ql&=hWQ&+>@70A@m__yl~w)>N=S$-%?ePbD-VQy8^IMQZ~g%3J)ntacY z-o|3izLpJCY43yie&JmIT4|}9Wi2rp+g`pW$kx9I^Q@P|!fv=k&h_lL=E8bYce}m1 z;O4@&UD|K16ye-ul^cXPcO$?p1KZamflWmx(%2iY$#F3){3`IE73Zds&{~}Gm0oc_ zPJCGBAV>Q$^@32rNF5oeI^~oV5cQnRMr$u?hu);OahqzPT>nzjVlT*AN;I`DUHQ!Q zJ!`%2xOg6Vc%-L4DNY=gUL=c?zT)KPQwqfy(Mvom*m37S*K zW^%O*&FVD>=;gibx?^TfQPUo;M|3zOG*Qee+bjBMFg7sScx0}M{l{v5z%`v;7X<4I zov)=0O)6N`dtchk zZ#^P!!98JW9qaPfn5~i*>+TuPmUlNCs%m$>@{!_^ZGHUKc)l88TMu22xmdm`l@T|U z*|?G$o;YsXHx$s)M|h#K2U&gn>;*iWc}X^$etTjp0IqFtv>{wS<=5?iqNa1~PQogL zMarVFEDzE^+Oi|oZkwoS3PDLdY-1K;Yj;8Ec6uhlmteK;q-i?W7gn6R<`_5{FRuR> z7zozvhm5#uo{qh-JdyfOnmOnGN969keUIFrZ|xheb+;-iB@C!VLwt?BJtPF?C#(2S zH6Clene4m)SnLKg3_FF(!oxVS{yMyNG@u!EJ>0ija?ycBPq=R9pdf|UPsFIPDNvbp z=&yRT5?Uiq=?rtv70r^K@4vzh1Txvgt;7Z-|Xq22u%Gp zVs9aza}J|rA+{su{y#qz$3~WDEn4M(c*BSyKUxcH6i_fdN{?M*|3RgF|JfO}W2_59 zn89mXsZ)x9OH|3VJ09kqyGz3M!pKzDch6Pm7PcDRPMm$I(j;E41MBB{sr6iqKhQHRx-IU9n>MsStP@XTV^^$pW#tN}kR zRG$ZR<^{wzv7+@`u$n>afTGS+Q0pt6=wX{%rbbz)ZT>)_8qba_qlwo>Pfjgveuem{bZY<_XnEDzyek{^~$(XN7eHfA-)O9g^6yCxm6A= zu!`@26({0i5IT|^uT5i}v_?8q%j>O1hVLu$+?)!q!R0dmR>%c4M6-y5Oh&&USny&g zxa0*`U&qkYBnfI7fH%?yb1YY+3Fax@5*?^|h2K{Dq7gTqV+}$J$k(MHYh+~*HQpUC z9ms6QocE%U!LPQ*W- z(IUObV5T~BP1ThkJ%H5xjn@ICvsZFYFw35FJND&pmPMDn04;|DRAyTns2EqtKdG+Q zvcs(4Yb*pDCGixpn^z~pY3-b=%99f@linh4;KPQ;ysEaoZYe&HoM4s6DHNrE%1G!@ z@=W+8C8L4_6?!TaO6G!U;B)_vgu0~Sg*FYYhX4zjyir-?d;(72LKvyxE>25Q8-j#c zd>p9)!_HDKRX;6!FO^P@9tVee$Y5ZyGbtk-cF^RaYu)hjWUFuUtI|yGcXJ_37Q6gr zL`B$4o63{Ko6c)(p{-;pZPMyg`k^?{ibOip>2^>lA{$>y)RA&=-*zE)KNz+Lx8Nu4 zg|0ozb9^+8*E7Xj!$4tOGsOKOn@qr8rn^p0!c5Jmnl*-1 z!-XyQ#f@JA;>%oK^3~{Aa;L9Bej?W(OZe<->jxXVw)8}nW4Yfh^E?NodDdVh@N0aE zE8(dpdy&NRn_>FAGSiB<(gNV;y?_#qo)#R75f0jNo>PJSsPwgr8 zt1aC)i}88dFzfa?f%XI3ln8mh%uXbb^B^tyk;Pv^E$0_;I1nW-^1ir;<4}5$`}10- zZbwgU+w|?e*0nlVR|Us*g09)~xhhD;AK7DuvWsvne!pJ^rdT0P5U7Yw-E>T)OOyS)U80GaycP$l81$oxw0(ha0&XIxnXk0j*!uSm3@3#%M>sv8c_X5vhX-#wRNaC(@KtIZGYYY7Q zA7$ME+4~$^-2wd%Ag0<0<-G}|Zo=*(j-Ym+^$<8+Lzstn>6UnDi)QyVOu8P$Pa-BA+dsKe&MBcG&JR&e?+Q0}XGkgK(v&=K9GVf|>7A zFmv5LKg2LMQRm);E?bB`L@f7@Sgs-8T?Q(bK)P@7$!_!>!jgN0CA&%ZDMTaNnBTV` zWG8NS7<=r1=Z->-8z6azG`@>S;}QewS%#CPf-`o@0T~VZl@po zsm=7chaOc6)d!#IDn8X30^Y4xwFK1t^Q*cMeDJLH@~pav_-Xi7ZQSplch!mAo%&ZD z5Z#%FwE>m~AM4%tSWB$v6Z5jRW8c%yx=18QJ|9_2pc<$@O7CkOF8ALN+ZXfu?33+F zix0p(+Ya)*@zi!k^&@uLw&D2TzwJV$2Ul*3E4Pk-_tmT05#LY3!P`oU2VZYHjXrX> zZ!3Ox=>e_-?vrr_*Ad`@^9%O`^e$b*b)bHr-r`Q+uH-oGIP-%K`9ArOJ8k-dJGnEd z?wx134(kUebAKmu7h2w>zqtv%`{sJ?fa`-7x`!9K13fDG2Z{xQ3@o%nn*?(JUKe*!MJ=56>sxX$~#&f94E3AxYRq`0Rp^cH0A-i_V};N7~? zJAwA#PQOEUdM#J`6kY0lh|$BX{_eBS3e@;Q9E{W83S@T!Ggts;u_8k#D3e2R^q(xa z@(Wlz}^wWIg{?$#Iqh=~7&KNfboW-!^Ayx={N&JAmdN zY8WTe9X}qcozP3AO1G~bJsQ5<@fN|(I1GlfbRPaM{&f2yKxui~?8tT+Z+qK|>>>=t z+ra|x*dE98iy%T4v>hlI3lPXH4Ot?m9vRL6z7g!u2+aN7TmtbkU}+i~@h|)X5=flD z|D`dXB{&Rl`18}jLx$+EtX(I$}p z*}jOf`GrgdNTO$Xs0*O+%(Nlj+PBvHwsNbVOHbcx>juQhkO-le5~Q(ti3F7mzmNr@ zyMbj~_L03**FHs>;JQDZzJgZ^{>if&NCsde7-f+!CqV?yRxq&@$Vis2+GsRlo2UNG z-$juTiS30IUNg*+aC2)TrwCtUI&5$;z>5wybnnsE!`6a4`Tg*1mAuc^T2QH*o1s zZ@6?F5xxW0Rfr7v%iZ1GRcTV3W#_BC@#Lw$E4RNKfB9tl@%XE6wx7z0zx~zYulBxq z`sFwBt0&&NXtMg!WtudgZVsMxyxgZ9zth)H{FQ%MJ^6*ZWw^|yd>bf~B65}{eF5)4 zvV}Ydt&T>tOS0&A@=N7;A8B8I`C=RtLSopE$zd_YOI5jqIU^&>>DAt&;n%}mHz9xl zS@4t@z>YYdNd;c1bQXibHvy4x5yNA8vD86y1?FyIJT}d*cdnjpYsb!vwP2c>Cl(4U zQE8S)CHw%)OIiVsmDJ1z1f}60O0O}%=NdVD9)mEGxRQG_zcIm zN1TGcsBsubmr1&bP7oS05G`wK2WQi?JOgD11VqhM&NKiIF_*PKN?msjU;9ID)$M@ryD5_|p_{6@^a z@Po*kOSJ$Fz)HS#@m&h#L?UAXW*bMK=V+^rxDL`83F6z^^6f$<0k}oHa66)j_3ItP z(MU`}Z|c(8?e)Ib04tid*5ozPp0L<@dyINs44sO6FltD$^4qJS0Jm6#IxM zlbzYOM~{Y2^uF<5Y*IM2Ve|M@@Y+P-UhRu!^IYZdez5yiG`y{4+q#(<*R?@K1g!mO zFe!d4+fy0G6Cfvn&un!^HZ40 z))l_k`OKH&5CmzSY@@iy20xG>_a~|Nf<*IN3ETL#8OWVQ63+uA)moqx|56f6b8(i8 zWp0q02I(xj7>?sP>!kRfor^HO*deQ27+maBVH*CSwm!4vkZ(v1aZsiDv8GHgN6O$f zQtDA6zQaQnByy9;NuKVFt#9owa>)a1MFUHEjg`!Q%#twwp`@`{AF*C!e&KX&vweVi-QV~y>pzuvS5m*Fh4eD zi*6bn!E>_@l=e9jj`@BUYB{_R8q-}toC2=;L zi4hMQ@}D-hMmowWoynZ0+H1h{u9)!SM28-^JxQnsBpD3c+~U1F^=9D2hzhtZt#h4vsT>HEjc1U2!!n8RrWh_r+UX>iX5cu?!{uwjlX3@WJB?3b zg{MUmu+wQNkZ&~lqu`s>4~StInl0A6y&K=!U#H2^VkhDYqit&neuun-=ic1@P+gon-={m~*;>1Lj+1~wB4|N9dpjD$w*i;YL(e~U*O;+<=9upofhjFu>l zcqhidX2d2Q!Yvn`@Hv_9XiV{Y`-hz!@g_?bS-LO&WQ5>fU|rl78|2j47*O=r*kR_=g-qF9>)@$xuJ>A)=JEGb=YhAYty_yPdA$r;B zK=R``#$K|>WjoQq%>47yVcWL_nKC!>mLyAiUgT96*E%T#2rxIu*k7#OP-SZg@)Alb zLO)C4dc}IiZJe?($`P&u*{5>1AZZED_Sw9)wGZgRJ^lyqnSa)*ZKv$HWXellQ?|p} z8zc`7r!sv`A8lCc@*iKCKhjbd2UDMh&zDk92kdf;GnuA*y5}Axu{@aOm zhqE%JF({Agg1~|A3(C?>FtLuNqN6hnu4H6>Wn$g?po5H&;d7yMVEw%fEqiPi)DF>^ zo%?}ul;{%DDQEXM{ekyOP*^&d;?3FfHry*26rPzC_PYe*s#yX z-a0+~Za_lw5&c}~oZ18G&}n0e3^P1K1-Lo#{X&K@gw(`lUvVQ>#^WV?-HHs3S`DLf z33oS7D>ph{8pERlszgA6E_SG!iFyJ=F;2M`hHeM;MrWXpP}+u*15Xor&L`E%9bB^n zesi%DbLmBR;r;=^ivO&sM)Hpx{3|E%h+j;|pIK=t(_Gw#KarKNkRTLTdJv}Rd*hif zUj7Q8y`C*xxjU(z2dW>f`T*n8kM7HCDy&HlIdZl(s)j{@kN}>JutJ-G4);7_pJGo)$TH+tw0{4B_j2DA?b5UuXjF> z_JG#+(H`9CJ;)+mu%Y+}U@`>%w8D)^vZx-VQ~k#_bj&~}D(;p4lgVUB8|-{v|BvL~Yx*P+y5P{#ll5Zh&_YA)N5uD;q zal$>cRj_b>)=6pLcfveZI!v1dZU}J|hZu#WbdeRXm3a!%@i~{x1o;-y9rX)f;v}_@ zMoT~pH&i5<@DxHgjW{|81`QvfrWk_h)et=cIp^Qrl}BvPuKD4me1dcp6e|c?23Y*# zVo9;R3H~RMQ~7o%-k@Arx*Gu|5DvKP7>h_)b|$aCgTmF!yOM=dV~Vtp7X>Z@WzLa= zr-4&irenQpITSCl1fiU3rwubfQ10xfMdKrm}rBy3JWzr83pUh zyciiecf5H&o()z92FGH_P9nT?4sG3A_h+39S#gvGQHBzj{X9hRUSsp&?n4sGW z{V^|b9>0oBY0oO^hm~Qgoq)b7O|k0Io9I9-qcNDeoKT*W2Cewgq;jD|d?iUXLu>fF zzJ^8(gGlA#%~c;G0xcUvY+=u{SL%xd)h~S!KWfBJ3x9PvNh{eA}4bm>~l|D>g?H} zeIO8B1(!QRuPzK0DUP0?m6HDrLZUtZ0+3h=ta;%o_hvA2dX)rYPp>?7+E7_nkb&`eudKv#o4e-Qx)p^;wwr zA@#4Vqq|9DUNW9ZWodn!rv%SD zZ3LQB`f^*G_n3^QwE|gTOb3yyFus$1?*~PRlS26f6p87rSK$n2I6wKr4Fo;64T^-Xd*@ zaT)yj%9E{I_p;~Kz3jhr&oSpu5&su)WZSjzu^fs+3SLu^(juTdW~|F?>#+lJOpxmSSW6l?U;V(MD=vIur*ub#D4nagwf0x5_tB`lm?Kw$0Y#ZpMMMubl$> z23&}>7;vB0!jHwoOLROUmoBj5D&W^7aoE+OwPD=OV(7xtbm8cg;~mP#0dqpz{Dh7F zr7GF%2fdJRDT`7bQ>At!`lewm+poQLw+t0ZijXcP}_xfH8!ZVy(6@m|MyH&Hti;tDu%uj5PT+m>w9; z$*|lnHYpi%0o5Tb&R@{|OR|V6$t==f9{gAOGzmHJ6h>EB(McJQzLQ(5Naqs*P-Exb zVaLGLI4X0UIvUfTiLr11VFu|AaBGug8DBo%6c6QvVSH^!QXyMU!o-U*U3vr;;Y*Nj zwmC1zAh~vTpyCh{W16>9oH);qNfJX}?<$u&^)6)tie}t-bzC4@l2ev zZUldEgjW?lIIH-pD0a9$dC^QHN;zNEvu+LlgbN~HLH znUm$%uf^h}dwd--UB2xTOQyv}h>w;NX(VE-C{~PHgc{|4e+xC9CB$Z8#LFw)hijs1 z;6s6H=(hCtx5m4tIz1)=g_;9a^Gm<`;U@ zdYFV+vktK{YfxXTrn!{LzpGv5Wo2lWbN>>a@Z8X-OZ$T#b{a!`b(f=R*Vv!R^w4~4 z18Wa@X%Fh;>B5*5yR$;ir_^4ZBz5bE*ncFcaYc82yr_i{LX5m1qRvIdrUu3A0*{i# zAs`KN^X(N}EfK^d1|gEm>=ip4G>ZChtBzc4BagX^fGXu)n{*gXpTXUvCJ1UMpac~)AIt|qZZr?D7r@4)a!E39 zKXR~a=B5C>Vk;^+)IWg@C71zK#1Mu4+@_5aiyj+g?;Y$ zC?59)2IsD!H!XZ4rBVs5gk*dImN85JN#FF`gr&H=Q9tvQE|%1r!dg74!de26DmBE{ zSjWS(b6FYCzV<;jhUg-ooMfPZBQGlO$x&Nj`BB$na>L9m2betvgc*w?^wNcs?{(@6lkrg_fT}V|6D9?ps6kW+d;hk$Mwg zcho?=3rG)*)9<2jdL6g=q#CC8AVQBu>F_@}57MF^S^Oo`a()qq*t600BAdp{?$2wT zx*a{aZPT~=TG#4eT@@VL3A$#_=c*tXe`Jpt$}YmS_yv0}pS$kXQ0&VV@GA#3x2bOytC9d6`m=)9bE1hjrpW1+vf zS-x%IR_pjWP2wv8W66taHGQ{%)5Y4oW)pWWkcw9AzTY<3u5ZO)-3vU2rFD(w)n1@f zt(ogHVYUI%WMo{EWw8$kW&2#GkLwL+YqOg50K;kDTBA{`2PjSEq4nE@S^;Y?+N{Y^ z(;bA0No75Dl&%1jO($!xm-Jn_^OM)jF4E;#HrfGJox$qnQu#iPK9acW9MF$4+}Z;F z{zqANK=wWdS9d`F1Bj`1LV0gOshhC-h$E;SXgvf@*AV6*Ub-b-+M?Ng4U?`%@so&- zcA@_e6zwF-M;;69Lg_9;pe=YlnaF1g=MOI6xgEBmXbys=0o$hhXOW z6wF+=&kr%oP1Lz}q01Jc4-w1#BbIB(cb9?6C6Ml0e6kz8hp^-xVaaY1ehSgZHs<#& z2-%6-9mXCz;JKra;|53`B8~4N(zwKcKB)lXcHDc$701z7el&j49Mq50Q)(gbDfmh| zpnJc)r5y}`Rb+;Z=3!+cRhiYN{0eVr}p}Si@ss-N%>q)JHaYbKh{d5oB)cfU4t=s7b ze`+&*?x9E3LiNF?x{6P=hJbhLRV@K^|NN?M1Rp%By*#UKB7PdaRU7yF=UsJTcc=bU z2Sj(~VQqlr!N+RWwrw~*_;0&V>A{uT;>xWf;C=P#cEtCSaPYR$;=$M3PNR?9 z?c0jqU3!4)fcs>e!F2@q;QYcp0liBXaUG~1sJFNixGOo1JI?&zL%vTw2Gd=@4mU7JK*}@h3?^n?m*8^!698shWqB5Zb$SE-PCQs z-I2$-D_9TC>$`AXH*v5}%8%WX5UaVg-$Y~iak{l#kblgsZ6`jTjC;Em_Md=@yB9q^ z95;6h*!RuV-3{H3-`(Aa=Yz|;E2SRX-rd~ZP9olO*LN43KPC5fGd&($;N9qSKiuHW zIDP=Ga3_GDnmgP{gb&pv-UrwZz%A|s_rrFLw}X5W_js4tA6(@3&_&+9@egkDUgWy3 zu5u^l5AO1n-Q}(H`~Y0$wJ_dOw|N`B53ck6uJbmUenReZH!1F^3%v!|yLY2E0(iHs z^iH5XxYO^@onFh;K1G*$A7b=ytH1jU|0Camk|_Q(tDey_H88)37t;D^9L7rKKW0go z{{VnkP*@+4RU!X{^Zw+2J{!;E+{=GvO!HqVWbeNH?A>Rd;rW7dCB-O;eYtOrz|JCx=Yf)HB<8W7g;Glas6T+q1`bycr84ox zc-XFkbjCpkFlT<4;HQ6)j(fHD&2V?P`xzV^UyegBk$U=#n)Nq$zj^b&Ai-tBF%U5N z+xz$*K)OR<5B*`PZexwz-Q6dTAB(^3?(Tj4)gJtJckjs){O|7WlP6z4`C9yK@A21< zpX`45)!tW6{&}Vr%`Ig=`;06Ca8|p=9bmYyYT3Dm=#Wma2 ze|cxG((qmB@j5_058?nY3H%OzfOnVZWGNaKON4UxhZ>4QuvbU{E)#f`uVfNTmiENK zM0lFyff92sKtl&j;0fg&X9*(5Dons|yu}St@aPdqx`Lmaz0{9OZRN@NB{q`U;4@ zV5O~neW-a%PM-XHB61#>P4gpKA)sJ63ygwc7+-6T4SfiAJCSLYz~RCu9w|mD_0mj@ z#3YcRukE^Q88(A2mgP16{8t!6mn`OjX(tHfA*j~xU?+me2T4QnM(79%_{mFCIbWdC zNgu;+%d`K=_hC#Ei!sdn+vY4y7ixcJ2M+8XY8WTe9X}qcozR2RyM6WO(eUk#w+Qs> zHcRK>|Du0y^Hke7m96O)58k6k!>9JaEA44{PjbA^kdCFzac+>{+lmYVZN024Abkob z3zdyQF_>gwxE$if`ayz%!_pjkm4el`LPc7pIGwh*n~mlD9+_E-2f;O?`IZjJ&@pDG z@;l-SM?W5X|LW-ZzKF8II=@Yk*IdG;9wW zG;VcsUK||XWKYIk6vb)nj))71+kk&@oo?6MbYq?$pTTh{-JHFV<>`{WFy#qraDDe# z^c~rUMr}RR#KCExR%SQXn{K7o0!|Ge`uJm~k7kYQy@H>`1o^;)&0a_lk*r&=9 z;pV}~);9H_c!Q#uOhFVi@<5=(h@a6WB!_h7M&$>!h%7JlOv^o8(5;@oz`T?t9LY+g zZ+3aEYxIygr$fH$7b#$qpgdJ4iZE*&3ENoJth`mDHqweH! za6*D~L&0gmCnQtF$w0gx{t*Y!W~_$keBlSl=GK7hLq+OrY>gbNtZJS~Wc0?~k z1je3{YJiK`3qWkvd@duObsi9D^s%Z+FPmER5bAf*R z498b8Ndn)8XoOmcs6aS-YC}T~I0MPnOO|yze})oy_0DFCMa*&&YHjrV%X+6Jrtt#%5Xx0&LE< z7b#-E-1|Zr7Xg@P!PNkJO~;r-0I*cDBF2mkw$6))ecLOTm_)a%0bcUJXES<9U4{Eq z$7KuJ$DmQlEK4m#{4Fkx`gzLAWJ2LaP25$UB||q0g}gaP+0;s{-R--b*@`eRJI3iZqUq zfx@#}=E&?18_MWv=wdJw&4wl)`?y&Ao=(_>oOxG43{VxkbC~oolMqJ@0P=aX!Bk~c zO>@8tHqJ4+Iu4-#e&v!_h7_ANh(9_WSe%^7)aKsLgXEplBv-al81tCs>Eg|TxR|+c z%>BDvJbPvnrH2=BCy{9q$l4@KWAt*oMH)CGsch}n3gh(-eTZg4h~KO9;*H1IJcBtn z_C%XdwG{%q*#+-no4~_P+Dle+>4+%dO;SnjTvRIo+aQ`2IbN=##tWI?^98~%8ARcM zi2MP>gUx{};iI=CUJjg*Y{)EO7ww~9AjJ0!HD7)JasNTR6$;F*DLe(r@ic?l4cS4I zRu#o*krtqRNmP*8&&K&51_Q%M^EbKf?C&)z}}PL-q&s05~%OV zHLyuY|LD!7#SAXuIFw$LFPbaur*aBz_JsJF`UeDg{IgwSKc0wXoQZ2M!l#*2kiED1*gTmhbk1vtM@^aS?-TrRrX zF2h_qYy+v z8hBywU-?eV;`p*f`}I=q*}j0&&9{*sXJJIgY3kKtG>VwJM= zjaYA|ybieJw#rbD$^lfd#gI`>f>8$&=oKJv`9E6t-w9~AXm zbh+usCk_@f65UXo$)bFH$dl4zf~&2_kjM5++c?vf`zhMh%lra$#)egX%rkjL}{!U)aKS`z=|oW!~Av>iA=n2z|V?F(X^SO z#gm2(49#CfPhN}6)t>MMe75=7(FDdm$1UV2EOckkVF^k#QmWKwJcv ztf0V3Q_$3CA~8BT;}8usg3~ki(lN=A{F(+7kAV#IFrLrj=-+1}&3uO9xFC)~Yy{eH zJRc?EM9$+Y$)lyu;TD~L5mu5LJUNV6qdLrAdN+>~nm;tXRrt1us@xC+T(@@=3nYS0kT z$aF@(f&2xO0g6-6#tz{MkJF?7WL`+i8sZKZ*8=negH8Y3bw>MRr9|WwPu05ihCSy7 z=&Tbp5ECy{(g8pXo%8#|7pVX!!i6}l01bXO5NVRF1P|PAyv!Xpfk;2drKjSe?}|T; zMg>Em6}+_fs7)2B0lmzua}DSi5A8vkCc#Ap{Ie7g_dFP<|DczltQY}Tf7Yzt<#!MU zGq-yYCvz_q-xVhNOMK2u`SbGc$H;g8P_=*9hRLboLuJe#Dz47RA&Bl@H_dkKsrl#M zx{x}Hvt$fh&yeFFNxbFvm^CN<(&U5;09`<$zXBis(h$$?5Z0|gV{z>*(aM9w#$;R& z0rN9}GE9<1pcIuwJuNQ7jmV?q>9={bV7@x~5%>odF}=k?M#YSQx_NRD6q5j17t_Ce z*JxWttU)g03@FMn#9LpTNd(aqm-!foAR336UovmeV+JxmmAptDni?5r*)BusCFE(? zd%^ZvuW(;aDA;-gON;ASFrJ~C%{X4*0|>1*fka3w2+1tEif~s7#&46RK~*PeQYP^j znr)Il#POvq9vz~wAOIhEAVe3pGjm}djYmu~i%uAIAa8eT+ivUHJkI0^@17LeM85_#}tit16o@icnAR z%`h?D{Dk}^qAU!1nP`C0T0G7lJr3%kf@N4VW@?{<&6xcj-vagJTi`DoSQ$h>34P5W zoU9p<@?m*aJuUq#WkO*(w|1{<&Kcx6TPXyuMcTnQo&nzhzQ(FFJuu~nG|TFTVp}6p zY8EHyVUUco0QQItuD$og#6yDup2o~d>98Z28RD|(vj|L@O@B21gNC!WRE6iESI3{OmhD;a6?!wBQFB!+-sRVH9Zn6!nK zcb2qAR0Icfgp#9CAIETMocer2#HO)yY_PI6+M<$k_Ej9gU1T$$IG)&Zo0-63ln2C= zzJkAIVH(Um(C;ghB59@c1f%CEfU`QHCA7zN6O#}reJ_#3c9AKNPyujTNf3pnSMS^w z-pqU>EpbUNHpoS#5+Yi&DLlQfUBQHW+uF#CwWYM#*=D}_s@Qa`f2yrl72f7%lTpzO z#Fb9>9WQfnU?kt_B4hidB|0o)E%j_)oOlU{7XPTO`Oo5KC|i_YiCoMm{lzv~_508z zszA=}M<%CGMg?9r>qZ;zjE;qJaHkG$<;|bU4_J(HNhfdsYD5zkMLwyQRgrcI`=VJE zgcQMMdT9#;_^FY+SkGtVoLuoLw`a3R|~?k{X6y;$Ky6 z4g*}Qymo5gWa6cDTpYY`lX5O>|GLb(yL?h>@xbWTkydDow+Lg5G%LaI6!?LJLa$U< zj1TzSTi6rlM`I#WDA3~cx9xp7{F?l2kIKOYCQ9R!<7l)ug08`9Z!w}w%Y1#5V&V*9 zWmXBH08!FRUdZa(+85>z?)#VXLNo9%&yi*KP5Z-W{E&M?%FKMUJN&98dktz9zmm~3 zoq@L0SVfj`as)L`!@5R@k-<^3Cg3;;#>E} zxwlw=r^yW*EpQsgX_IQ=paRTUA^}Bnr_z5FMAD6}8FCnh*}R4(aS}{H8mG0~aO*Mk zOX(4HE7fE72EXizjp(Y)+H7h*Xly!nT@P4q24bl@*^88O$Y`F z>wHsD$UI%kY-_Xp78FC6I>EEI9Ynr-E2(_=kGKmOv?8m-P+AqFhK41`Tkknd-Z{sp z2;CUZ$*sX>Pv3MH>*CJpp8_iz9m^5qy!g)&1bJ101@W-`3Rkn;>kYhmtChGfCB|av zSCSX3$z31WuU0id#z9WQ$ZIiahY$@P9#yrECld(Froy1GQ~Ec&)rN7o_ZqLpAP;Jd z@|1GcM6}SB?~ctb%F~&Xg||7F=!YANV+)A9Uz&2JlTwicQS@2}bJojQ?uA5!Jc0gF zF4caA>C8N&c^OPuSn{qJLr;MT1)MWpqH6FpR2g8D3>FCguS{ZdJ83u6K>QxX>F*_` zQnYZb=4BnJ$%TsR9VYKQT{v=JqSI8z7Xs6tx?kGx0a2`z@1 zf1`h)5yBz|%*`*BjFw8h@nt0t)5cLFH9-6FNa+n2f}BS$;AX!5ps@H>+2o*Oqu_%# zbZ_8<6m}3%k2HJjbGLM?KSEG9eSx6;7AQY*k$(g(i_IJx&9DarAoOo-`FBB2_Mh)M zv!DEMjBk92(2_~Yp&qYg z>U9&k^8^7~&ee%0tO%2{o>g}YB-JHgFlE&b68IS6^mG`V9f3LFk~@`bWbwrphu)R+ z()};KARD|kHO7$`p%$oXuvH$6N+xsESD1#>#A0raORCG=b#rbj(jM4LIhgB6(b4{z^Sr>kJ3CqryjUa$|q_h02 zxXUa;f0>^p`bF1nzeOU!Y~z}3G4oV2HhW(UACr0PamhT^gqJ#@HG^pCNXBeI@t2vz zcuh($F5&5ey_cs(t4&~f$mrVF?s{JQ&APUZvb6gnXE9%NG83aU{I?JQI0FB@+3TX{ z$%odpgcTN87F(G_m2BVQaRPHX;a92GNGkx7OJ^o`jO(L#LZ{1^AUZjm4#nxw$tzrt zBcaMQ6Fcq!_|O-L93y`}2_=NvqJ@QtHw3kc)ni?mgWs8vF2dfeG8nzv`f+NFqiES} zw@y{or81Q$pP8Lw7X7QYX-~3GM?G5)Hcf85AH?kMjN_xq7hToTiLt3`K4`{W% zxfbX&srcwvIc3#21+=c4OjNMBI{C}Unk#R5o9EIP%TFgFd^OzbLh!Zw)Hl(0z0`L6P~7)yMR0) z&pcWzFdor0^4Ey8DbM%gs85zMeSlfYTh$N}5Oqx4g?Y&}3RtZuh)e;gmRV*mt=!> z*6?*F!os6(z101m=>7*a(J{8XksPYp#Bz7OD2gxTILI# zXj}q^3|}{7^5sxYnu~-Ucuq1^Yyd>MK1G6BCP(~WkZ1gwGJvkx-RjM+FJHa+{@~UB z`~Ah6SI>`5&w5v^;Myb1>$d^j?Q|x$$-A&Ui9=r|YRk1Y761SH4{u%{?cnbI&Qp#C zI(9E{63Pp&y`|#pJ$Q7Fz|cx`Qj+P2!ZB5@@u-g_a5~~YlX7KLVJxw{e|Ghca2h8; zI-3u~TzZjFUsB!m#egklflNStbw2uFW}39(G= zb-NF}L_E%NN@aqX8@7;4-L(@IjN?m@EjZC@Y-(?5S=lL9TtH5bNBNjDFEZs=@+}*P zKQg6*DT?;kCi{z1EGVe8kjTjuGdbwP6QkE}p8xdf==UGrod5pf%}+l*A8}1%RIiix zx_LwE(^!U7^!X==_XH<+m`KG9S+9luq?Oi`)M9w<3X~rT`E-9+f=O9 zLHTpCGg;S*qTmtCYQaG50s};M$YbS{Z)--Q~h9 z3U7}r;msnzm6wR$f3J1VI?$=aTsC1+vXH^I8_M{6?5Sx>+kCgha*;9CqoM{lB<^bC zF)$TfntDS1gK>KpqE>>F4n9F)Cc&anQn%6DK zYwo3uG)EB7|FhHZJE70oyGjE#tCCZx3mcF4&R7z4r4$ZCHj~fITW6+25^SIeYZt1 zzF`0%)bMF>)FHK^4dUn>c%~3&%D+eVJ{GQ*K1E9H^WV8fo2jH0$wJMwNMgY?uImI` zUP|#RMIq*j`7}sp*##7hXB{2?vvU!~7dxb#hrtEjuRlQVcJx(@WLmn;@D4Mn?8b`p z8!lsHs=pmv#0hTIKw!V)qj`X-1%;lB*u7R2KgCu2NZI53NDtz)NRX6Y=vXQ{IdT@O z)D~9kwzZs3?MG@zGq65m^`-T~5MH!>u_=?pyog6h62(WReF90)12Bw3odqidC!hL& z{`Tu{P^N4igwXheBRh4$99q`=$V4zan`bzVCb6Ypm)5i*J8_lj?}4Vp%$0KI%CmTU z35AyJY!TbIHSrDXZcBj&IS4;^;pELiMr~QeaRf;q&-TTe=u~<>uH_sE!{Ge1O?aII zX_s-7ef?~oPUac@fIg|j&LJa0 zg8bNCQ9#vyE38L)yBJ|&`N*ZRkYPgS@ZMD?CL)RxWg)T!+;v{XkxKIj3wTvlouet?+=RMmmb7tq@D1I(O zZ`pQVFQr@@K-JaG1G!|Gp1ld+`a1EoO=G<*jn8B#$LR}Al18xBu*3niYdH_*GR~Sd zvwQ}R7vsh=SP8s%mp`u655IGt>A#%Id|RFgche*6tdnVnMRWI%%6g-WqYy0#O83`ZOY^Y2)2fjdKDos4{|y4e?E zGXtF#WCvd?f&~=njl?fOFY!W|3!CT?SXr`f=Ri1~xW!Hkxb9zt`*phxUcQt4n zh!MzOL@84auoP&TDNZFr3lACLsEUwo4Ug)!S(GJKYSzV;&AfJY-s7cCQXS}-xIYc9 z51?gKgb>UbUU;d^8oXKwGnR6(GDZ<49Xd#5H1zXj7D9J2m}oUTdPamEYd88%)QWRK zDSOD#q5jumw2@D^F~V|8sgSrUn6_wYK(bsva3OCXNh`!B0}rYJni2&={^QT=%dS&? z@pNi!oDS&ldA11U+nT=QcABq4YO5DNo=cS`@lsh2v(>}}YheaPRv4PxFsQh#W}05t zRzF)!J8M4bJ_gHxA#y&Ket_k?%ALH5pQscfKeQBwdzlLqASNitb3{o(M*ikjonhF} zxWrT$q_a4VTHC9f;YJ`e;>ea^IP46wD)M9s9hT4KmZNd(v;C@UgN1lPJcpdW0oQ|l zwdffB>HNi0GeMn|*c1&Zgy}+bM#AMxVS})#OsOrJz7&@-iDYQcNrKiepPNO!fSSfb z?KLkku^48N|70>FYct-DxtzzzayZ)X6EA@Kr3)D9Q(|I7Xg%bUQw*3%WNlML%zoA# zqDER`w6j^vGFaHuUPqs3ED#qKio9uoIL=b-LY{j|?Y*lxx5ZN;#poA4up_MzkMQBL zqWwU!pU1`CML|Thqw3lQfvNTzSBHjQ_2Kw#BTFYwH-4jTpm`dPMtDRgY~&WZ2}Y+b zqn&@_i)W<%KHI0XWTT+t#T0OAx%ApW$I4xgu1=t4 zrV^xnoz2r+Vjy`ZFkA#od>5gdn|TYhs=lzJV!Z0)1C+})&=+5~pe0cW6ZS#g`=XqY z&!Z)dVVQ@8o=PpIH7ae?2uscAGJS)*#xH1=JqpQaLOU(;*P)Z#Yp1q_Qdu2h^4 z_!DbwJZXuxZ!{0dm!KZf`~>pE)Ha&b?9rlm{h@alWk$fr$*Q_4{{mwl67z6FI==FfT(^A z9)tiT!E`E;wsnKAX;~W=Hr(nrgG+G3t3*!9%p|VFy30_IMCcLS}utRyxbd+@i;x z63>zyVMxiL#t5 z-?M=TTt3xy;ggKXXz;~qaU+gf8Iiq*e*(q?e$EjEFk^N-^)n%Rb5-alRKaEU824s} zBY=fi_D6rRmwoTimye$eOlZu;@yXTW4J&SEWAD+|Lkxf35bx@@sK!}Kvw+xZhw2my zwUzZXRwhPSl*kE+b5U+v!Gn##G=;=Rs1fxxNXw0yz+hA0*JI4q)mzSD4~n6>KuyK> zqMbPe&j_mD5rjE_WTwxbg zwwn2bHkLNQsWfTG{6rI7Q#?pFa&qhMLODsrrk!u6tyo)Cb4?>a13QZ|Y^no{zGfJCB2~bzhvEu(cqZyp% zdQTMAIjZ39*mp4u`rS0akg@hrGH6G1r5?_}My9u69K}8X9 z&X790Bsd&-H%)qmeLUHT!rZ8|?VoG=@aH*cCLvreI*mbMo*mrGvTcq8BmSi}w$+D0 zJT3geieo%uhVmGSFN$r-C((fy)NR96%*e%Xa@?!2jE=0Z{Ae151g~Qa4qpx3*-H8H z@G-b7dah19K-HUFx~*IaSFLwaPgvO>^ztFY3u8~ik-~5afEj7tNU=HGgou=))LUxv zLKdY#XumoaavYahOq;idA2Dqlq3VEaG|-x3)z1hoymrt27#EWu^W^tFh-=dnJ=6~4 zSqTK^E-jk=0oVmezah}@BTWJSyGX`b`16u`-R04{x0czHWxdM3>hc#IM>mHK){m zCBl96Bgys z)&S@CJOx5Cv6Or$iqy?Adpvz;iMBN(i#j4@&m6Zy1gk)@TE!}MRZ*Aj@&4Fn*~i#_ z8~a`xnYa|H3U#BTwkKj7=SJneMuIs?r$w51j?);rIh}tETm#xEu>VYtiQFC zs!pW}!A_=mlz5RQsb?3Ab_Fx-L1{_tSv7S4`*R1h)|vm zTg=Dro4&oBZuni@Ob{dfje`pvlzlofbDRQa|subHC82Rzsi3$GuvnM%%m6RML_(kfPdZUjE z@G;YedG@2K!{kpAK+uRxEKAK%<9Z=~jN(Qz5ERW638y^+=vz;gz+;S6FE=xsFT)eeVfOfSAZ5cYd8vy$wHG z^ZEAqqPEmJ``ua`nY84SHo5LLtdpp-`)c)SY`S`__4Zod`<}O0t$($4R;^ym4He>U zoI;i~-x@>f zV@;i*)vT#CmH~q|;3vFc$f5X1U6M<+-uy2i^L*MV-SGE!T6UpnMY~W^3naSG^u6Uap&A-C4P(h^ z$#h#1Cr=?u>*&1Hx^ewk$+I}Sx7<}&0aCOA9BUfhQ$_-z*R1i8&RO0b!n1T);{jWR z(xIWSAi%_waJek^i;(_OJ=d)YwOmp(12B!g0x1mA44#+mfR{S>-SZ61b8uP!2Qp@- zF{}{z7z5?fZ|~)!Pz$WOlu6AWK!gBH7{_iwR7r*8oCm;FfnlUJ@C4*hU5=;9om)7f zJCTef4-2FC6Zj?)J;Y;oramR0IV*K9_IWwX^|-5u6I`XoJP<9+k16((t{v-jJpn-$ zIt$08fs3^7L@W*_7}uiV62Z43>KCBg^r+h}=}?cy$h0!3a;{Vq1<-Rfk-&2 z3eKN2Tt4n{d)@A?4-Gwt(E%VnDd34E0GCAz5(^tKRMvZEHvdE;7JQ(=jfmZmiZl7m z+{YoNbKtN{GZvljpA$7Vw`ycy6r?Z#Bmeu1MWV5}Gn?N5)ddZ1c+S^_Z?l}Jfg^+` zYLeUCc5aBpT<5a}V)aSjFMAU4BHkrRT-1x4!i$}+%^s-f?>VH6j+uJDa)GK>0y&UF zo(MFQRHhLFesJvemIM&yPI%HVO61uv;|H6unad)^bHLeQq{pRVqnIKw|M8;b7m!WPjAru>=666zUkvAt#dPGxFpr(E+eK z2|0)WFu2fE&?fLB7g@bz~`fDY8sGo5aVv%JX~(4c!8GvBu- z59}wekw)=NSvWypBDJ$a-gEm)7>ZyKw~}Qz+BOSES|oplj7c~TJ_umlgt@PLq5o+-CqA1Dd0g2@-~D_@3&&El3xxW7~5YOd-P2rqt}gM zPEyHxJNcbrQrd z6AoB2%5A+_{v^R*YtQLK;M=37^6wOaRXZMO-BEd>pqodGOd`16>{ykh0$3 zJ#$FG+C!Qja`6BzU7t2SB}Olu2?X~ z=)wsFeEW3eP93P4zH6Nq-{J1&BMN>Vq5;#wi}e#HT>2sV0w=Ev-tb?bKY!KTilT=l z0NZ_JK?sMO*JQ(4-tKRZf8k#aH+b2E^ARKCH?D8pfLORZ-a4ZegkcCb7R{)7)!X}An!qx3+ z;;|^qxIc9c;3Bn&z|}G4X2KClbur(;xMw568FU7Cn?Ma5N1iTN170)@qnQVyU&_nt z?j8`k-3OTf)S#KHfGvXoecgaTYg~G znd>4`Wv)hg^0K@5g2^aQ%7+#%o%BKH?^0uQ=fV6&!Ve!Z8;zM~Cw^OZ0Fb)Chok{s zsK?(wo?mcvP8Z*BjylmBjE0V$V0^V)aY^D!#hO zf`&Ki4lvZ$6BkrnX3Kz0oqGw2DejYxPfsr8mx&Vzyj39C6uCYj6(f2Sa?d51atl&q z;jQo9?pReiOjXJh?(7~JK?ff{QHChkO^;*66gwlV6jlzqgC(3Gp|M4qokcUmm=)x@<~Wcc1Mabi0ivIoxj&KK{9nTl!;E zOxv0>>&DQ9tsn4-?ILizDC`m#q3XnVj~+>7cXzkd0q|P@q2Jxj5KBij=!AE6_*(aT z0cJZDOIA}mn1H2QnVoKTI-O3tFDEZ2_&*IL@U0)#?xP@@mVQOj$rr(OOc2m?I^Mlc zkg=y%KfJ%W_Cw|}DpkHC(#K;B;v{BL{dWNwxgiAdi1#In10_j?v*D z6ya6{u@UOnFeT$eMBiA?U?Kv*)RB$5i-LXU>sdS`G4$(q`Kz5Q6i_c*I3di+gwqo~ zw2Ajl&*q8W<9d>!UY)a%%H|9yRPL9qV>yw?_Y4lX>5LN!dl~gk#O`t0kB%=y-!$N6 zI}wnU`4Xy(6fZc>*oEqxUCFF6X{NMrxVb``w!y30+g6DDkPe%JMazJwtrkawZZOYQ zehXkQeZG8qOgf$2-PmzE@_jdKIV_r@`!+ae?*vl|3T=VIH)mkKwcFZlb@tGAn=CNr zuLnuqsFnviF@KT)mZk|5rJ$c_82XljIhFAE%&0Y&6iqRL(vyq_hBif_1Cb+3d;=lz zV-k3kaUVf-6h>z}oabTUc@>OshDn3LQA*gH;`I{tLMNJIdUfwXCP7w@XD@h*(z_~f zX5hmoE4Ro9NY5NkWsv7-tI)qtMz~6Mq(q+bbb_kHWrSEgiC`V+IuoP=b(-c#9WA^< z1?#9r-h+z=Par5(5G)nm5VPjKTEFN8CWC%bucnfi?{Pn|qt5PrH`S14cD^9a0?WYx z1trvgsJyPnqQ(!}8Yyr0?qM@e+ECcO)LIQt8MgrPx^(K{Jl&x#GHVUGITJR zhn|lC-c~h?d?^bop1Uj*4i6K6mFH=^nd`A=Y?v4m8Y+FjOYvw#@D0bwRM3zw#yJ&| zJl=^G%N>}(E%?RMYCIj2GHE2MnkK-b<%6l@JZp@$CZ9Ci&m!x+D7Y&Tn`e>jE0W|q z+q@}nOY9|^iAW^9Rpi4)V5w~1=GZTBKddjmuL)OVVJ9m8=)_X47YZrED1RuR_!J?R z$#yiOtLHitGeh{Y-@NVEiREir%jSndsv<8GF;3=d?guR(G3&XKS3ZRZkvA;Kq;uVr zoth`YgwRlo>A?|nlQ268)R4#1PDDf0Bc_ionNqOsA5;rXvH4jEV>=mI*Nk_z7z%;M z_Cu9~ZKGwZjPu+n0%$u0ny+{wxhlS`h$zowYOC~=Q=y?rW0QqoM`9L^CJ!7)B`Hh= zhH6_oj|=0@(}~2WnXu7hqC%eEEnF>^uA@L7UXW@rrD^tFynqMn7cU;Q!qUsNyhP35{L+KXvh!iT9`?pa*dgI`sJK%;91snrje&v;O`{#hIEfM1l%$* zPN#?-D_6;Besb=XKBO_UhfZH*#%z+6=gRbo;G7Ak9M|z=w9a^Y+w-@@-TgKXoY+nz z567d|GVpI5TfL^5^I)fENQ{%wOLcQIeV3$3ZYU-991;^o2q(#3E$)&HJ*9A!Y4nUj z4)cYK-0B$>;s=7q&(tLT-BZrn-27G*8$lOK&;DgJ9BH5I9P+}>V&5k@Wj(;@Mj#kqz|)&;uyeW(fypF?Y8*;bcJ>S z?Va8I^3v1!FL(19wZpuk#xwO^-b_NGIEq?klN?QveGbl!|ML#KrnSsx8V6a zi+vcY5buepGIjmCZI@1%O9a3sN6k?I=CBhR-mA^{ff`$`e}`o2Ap;^?*#P2_#!3)b zGx%}Zn{{Wu#0@ersd5nD)Y&<22Igb43HN}X#2EjC7SB&Y;y>jiOgFQg5{i0cPq_ws zOIBoPznZK0lYhMi^h<`Prmd!QvVpIE{Q5_mSuOx@EPNaM_%`HI)rOcb>>l5;UhtQ! z4fyiIAHV+b55MytU~9(@TXri7pR0{_yM4I7PyWzucU~TJ;J@w8;UWIF-QGWFclOC2 zI{Pp858HbOorA+av^)DR_n`c9F{J-l!L{fg+U;QFc`R6;4tAzZ)PKK&Ke|lyzw3W+ z9S9G0oT7d>mUC8IUxXP@knMoE_$QZet;P%kk|R6^RHaF z<(?*Cwxc5j0w9SC#|%1D76B=Fh}$zC;v{+>+vvrWe4|F=FQnz@}zV*IMy?E)9+)Y04^| z4fb5Xw>Ol@G@t_aUfzvXVh8*#N!pi{9$KpCgn83HxalzrVsj!SiT*`O{ zTpq_{>bPpW;PT&7RZI&cHY5oKuGu`_2XZZfEXD7Ij#{7PUr5p&Pgryf(2DNni z1GYK(utl7g*gg5@=&()5f0NzTQTyHdUmH!Gh_L^5U+o?yeoq>J60DWmY`X`$?cH`W z`H7oZ>0i+*+H3Far$2Bzrqh1e-a9xvdYSnQ_DAx^uiC%#zkeSx*=rxZI;GGSNnSfGHD;| zo9D@H6`_35^i5g=0Z(JTM{_LJi^1^pAKP$ol-<#jrNNilRbJwL5byAqkqLMCcILj` z4_nr96>e^|I3E32!s-E%l?+4&&rxaEr1nyH0CrvGI^jaKC$%%WnRz*HAA;Iv_F75pT4Qfh zN708|GcBxxk8sS}x$U&>cNR`)@l-QbE04}rj@Jo)z3$}tpO}WSq9v3$9^l!5#^9-7 zNPix$(DdKa`-w>cTDHSl9*ZDFz|P(d7TZdP>8Q9G^?KF7EC`J_AwrXk8z(flb3Fdz zf?9*2K*Vi`Rd;Rf@VmmwTBZ1 z<+_TND-na|p(R&Sh|tkn8UXlYW{_%G>2Uh2aA>P~R+RMy9#@W%rKXuez+48$c}Vf4 zQf$DSk|36~=a#O9$M0Aq-XQw-pG0sL=u8ZrQnuuCPl~))sw%@H1XS%`>_C$Kc%ZRSPbz{4G+Q|*f+D=H35QdJ&7 zrUMVh7l(Fj7FvM=SI-*fB@CyI9q|SzI*>=F&Ur+$Yh1spA5Tcy<}o2%r)?j33)t8_ zz=+#cJ6$A&pPl@OmxYaXyPN#Kbg}sQ5MKLJANd8M=0I`O$TOY_x(JR1xt+sU@ACgC z>iXfDU00Wb8AGvxOuF69PG>hIkN6*7v|22hw<}MFSG%pw;Zdv8>a>rFr-c0fwWdX< z+urTA_quJ`ZBM#wD}P#`Q%BCc(3u72nl&cJlpVFZUD|GUcVEI-vwhY*Jft;eOn066 zQ6>X5KRW9OC$D2Whx@scM*da(W^|%C%(L;l)NL?Y+ULH_{x)o#I9Bu*({=IZFMln* z59H4W;BPPOaOrysC$~n3H`>H@0)~+?c}4(cg;<3maq9Tb?*||HW5T>!C-6N?{{W^8 z>SSk1#A|`(*reHrippmW(hRPuSEnbX+j7W)Yqc{4f9lK1*U*vc(-QzxB9L5~td=sp zYo!hpqZpIFN_f09?8>f~uhw*(5-|AC@AZ5K)dGs!((X0<-V@z{bl(ZZc%d48ALe zF;Paw^5JIOB;%E1!+&P{Klmmy7Door>#^a`4z+k8s7R&`b8UXsA8&VLeNGI$rZAs? z$>LCM-Kw?3nF)^eEAjXw3{x3fQ1Uh*GR)WxB#jqO>)Z|t;eZS+`e92A>{$AE|FU9% z6U)mqDMJ-+m7Ml6U&2%vZU!Z~@J{k@YcLR|~sE6nw@f+r6Fwq@P?g6}L z_$Bom%Krnx377C5YAISNCpdET@%rlIB2E>UefEs0NIa0=zNUzX58X89CL$~dJU``a z!Kw6j-<-ZPKlqCRz2oElu(*WG09RV-d@$;L?46z!7kqm@7+zgKs6$gNr}PvdGF2Oa#TiXaDIN-e|t5o zRBqTWmh(x!cXIakk|M(qjPGUte~QZuJ`{idpQ}MJGyQ*@4vR~??OmOflqj3>kRR~s z{IcIWeqUJb^yIR*Kc{EI5{aCiUtA8}UG|5?OYHP~WY7|c0v~(D%j$Gc{CNnop`^&k zX)zaPgTX~%fe&EC6_+?WJujYYABOLSr~g|*aXnpWqfLOLJ3xq4eXW6lRBy-}~MNdIF=iT-&>mj?ZR^p8u5oE;aB z==q>@(9Z`S`o(MQd{CyQ&j%NmgVA7cQP!p5MOlxA#p~dFFf3WG=Y!!t%LZ^%x+2d9 zqp~G=J{a{sT#SnMr}M#RI4B*Y(eSEdK@CP_4gI4;4Gk`MJH-tRKK3u)o((<~7P{z{ zXy=R5i{fR5)1|ybHFE`vj{aHFS$;uy=_G@@qqJf5^UWo=8oqi}Ua5A_m zmdWTJqc@tT*el&cp-h=M2xUqwVklH-pjbs45qn&|!$Yx3D~fYiMe!?=mDV$qhHj54m#(DRkcnys zARM9^MXQ|BWWg#2HI!_*X(WnOFnmPGQacLDRXhsGqLpZtTUEGzN)2VPD5?}2zQ3v@ zz|mmvp?Chz%YHe3RTOV5meNBa6fHCBvBTAjX($TEt16wYcnlNbF12#R`aV88Ei?LiUVA>lR}}({)fS+tkm$I!}GzYibnp}zZ9CL%KA7Tj84x_N2k5B(+X4J z1gC%baC{hCmUf%pij-W7sBQA}1O{)^ds8mYxctY{lYZ%*FU!5{ou2hiKp5piaojsQ zgYs9U-5mBWKb{`$iie^RnK;hE}=oH59$BAnfb@b!BnqYK8a;GQL{0UCbtK zx?8*)ot<2t_5QbTzG9*CVpAT=ygM7bDK?gPdxPT&rB3?&i#Mkx@tXR$3>-gzpa)Yg zFD_39m#3qDUYDFlRJk|(v%#n9^T7aIK%>9qhhj!mg&IYBZw4Rxbt=3+eOIVl69xOG zt2Zt%{=dAA&2Gc7gaJHUj7P#xuz?wS|vj77RA9naV5R`{Uf!5CcVKV9|j0H2BNmKL4vj_jdW;T;KO*^5=!K4CB8sm;ZgawA5c@$-oJ%TltT0 z?^Qeg+kGQOMC9&%_fXLE;+6`bA?%lxb4y*3x%RUJXa=#=cx{r^@VQC+14v|@F?A@_ zvF_+wOU$*bl*X}ZMV|P2v*N(rLVzz6MgIJAc99xq0 z)RXZk%3bd}@YCz;wK^T{Z@b&-yv!TzTPcI}2Rt))@)bQ^$dZ zIo3Z59C${jZnXgR_x;|<&YP>#vy;>Fcddo}C&97!&-R3d%-*)ytz)rpo6WYTPQa%A z{k9+0QaVyvnkUeO_^EI+Sx{>Z8yP+^Yc9TV1lX7c3m9SC1Mn}P;P_ub*USI%Ur^Dj zzqsg}0jgd8_a6S@>>VBAe-HV8?~e|z5BDdyvtyf&T9cF=Y)U*=9 zUejm15vov**u4b3P8gs?fc65PA0AvO3Fd|)ziPcQGZ`(G)!dqLH87-4pq__*z*B`3 zU^Js7O_TOb&0n*MebaA@k@UowiH3#FJd0{Q*vwk+` zWy15%nlpQa%SIg}q;HVW#u`u~_%kgXd)(q_LBMe;4q=8+CFR=WBZTBw;zlakDK|FR zgcApvWM?bn2+LsCe_lHF>-HDv^o>+bPhb}bSQI$yHn(p%7|JsiU5HYfOT;tahl%|7 z8G#AOGkLP;spMHANY&MRQLe)5ghZGa$lry+uw|7-zW7+J`z|ZCH@rB^%Gr zv(1FAGn<2}q?AUaM=L=B3wo=WAC~V;S3G?Z%p$GRaaR*-DDGKy(^UId$f77Q3&Flh zADF>a@t2hou#hm9-Ev@{kOkV1+&V6sC9ohxlBXypE%&(4ak-CZ!0eU9$12&T0hhJr z>V}3(7IvJ~QhXcbEKCTD#F!Ax?bgx)OS0&&v4#+T(X>R20c)-iBZxFfZuK1Wu^8qk z1wQ77-voQ?KYzacA3SJ4;xak|DKR5VI+J?BFfUl5Kbhp)(UwC*OdM3ly(ZiAr@dqBO;Bcf>FkEzc z;8DG#Gi=Uq06yVWnfn0r?99KTfU%tg4I>upWSMmxi+Lf^{%|^yze0#(;7nGLAA}n! zz$y+l5`UBwJ~&q3hyFAoai0V&RhF}SC7i_*wbDgbft%CWxJrE4+$`g+=T2A<`DAF# z9l)L}=j`VjfAQe?)%lVYYH@Yzgyj8*jHov&XNf}b>J0JXb=dLjfZdS~^o9ohZ8<-| zp7%hj^TUhR;O7nVex?h@BO`ysD#&LNnabreB+A#|=y>kT{9m2GS&-vaIYZ%sT1T&{ zGbGB_VCaP2IyU*+%A2vEoS(>FO{Wjl`4Q#o@WY&2$EG29LvN@@GqW|zldO?bA)mQ) z#Ts1pS2N}@^3N9epB5R;nODvxd-$aWZ&r86g-uhb4-z={*P=A!xB#8qlA^nnJ>D*Tmva&96&uzr2GDd%l* zms>cWJH1jJ{``5!JktBsSvVCq!_u7^T!{)bI68N3oQRTl)V--P#b?HH`5cMzH5dYD zo5jQl$k6d-^Ky=sqI?at8CR*n*N{zU7{P_^&;cuNLA@&ad>MA!tfDPY>7qgn&PH>8 zLE$#uBkz6JrJh}7ljgN-=Dn}ZoK~j>f1e!J@?odGslpeQHW$ukOs`afv%9;yhrNfr za;9<$<})NK)R|y(v0^UiIUYnzM-`@ih&5`M#@O=#w3>&>PQOi zcW>aX^zU?0MM@E`P{Vc?6>2c`x0QGAP@fFv752afe-(r)&#N(Vag`cOow^PsZ)ork z&OPU*%CYp9I|eB{tMer*)Hy-i_sJVStZ=^R-}kpoCG*))HR^26jvoc&&Hwj*(f{xN zVL!7wr^-ZM!Xy5~rN8FXDA=geHEXci^E^u4GsI*Is~o+kZBv)g`x*wbtWkrlj}E+) zlM5D9(WkdqdTA=0&z4@PjwOhmCFEGYkSk@7SE|mNC|~Q0;jKb)<#}xK|Nh@r1$!PV zTvcaDl&@np(CG^Pzf;9>$Sqr7Jj8WsZ9h@Od~)oAlT5}aFq|$dbIF3^g{)D7tCNKj z1rKD%7S1f7c6gIfu@8TK4jxX;`Uno9EAt1!<`o!i7#JL3<@!B1Prrw`oTl8N#F)gUyimhngH?5eS$gupn$@VKiO=_Jezrz!%{+8dA4IY+e*U!=V5EN-D)Q( zE*T3>QY60W18}k8iOmC0O3aJi({K*d?EQ&-)ae|&+4(+3Z-B+*d zwmqF593FNK+2Kq3@a6t=*RpJD&pO)Or~A7{N0XQODDx+TkMT>&0kHY?o4pLhf5iJ= zG=IhnP=)V*yY2SDUi$s-V0VA-Kkt8!{Zr-rFYPD*Q(*@b#Jx(1#Pc#Cu-I$q>amFh zH$)OU;ZE=x3z^&xkScogK89*0R~3B7W~<^!sT_e%1u%BtuYpNQ5e^N!hLkeGbX7E( zuaT(=dDn7P!M~p@TNN(JynIzCB_T*Hh6nh`&1=~M2yEyR$LHg)Xz+9p$P6dgBo^A- z0*^895Lzv?Z`>DjQ@Rxsl1Pddr^&g%hAxuqWLP4xKez8|SZ>i=c@8&r8o)@y>i*P7 zRZJ#Z0t(rLM+HqzSFWqMl%`sRC+Zz=VcM~sK(PRYeu5tgS;34wbvS`3i8$FDqYmaO z<}$*(otuD9<~?l1%yBaU;!BG80Kf41j1;w8p;2~Ua~M?TVR>RglCrKBGr;pOr8)R& zn51uUGM|D6Bh1tRUl70Jd@afRS|qjSoV<@<>ltVABe{C~w0;V)JmDNKVaGJ#Wi&@M zy?hSK!*zaTvClh9p(gjrgnu?#tp@I;jaCEp7UfAA6G2DW#mbGGC1m|^X*d^N>{EZ` z+31Y?&<4lOB-BC^Smoe|9|hDwM@%H!6af{GgNp^XhzG0u zSP_9zZ(Vb3R?Mb(m+qgqxHM$j$S0nZO{T;D9dW$M-{1sOw+o4u00#3rKZ`-Gb{tU<1q_$7TVu$#0SWRroH) zW%yLmO6geizkyx&wM>q~hz2Nhv?5(LjgSpqIc^CSUFf^FEJRLZDwav;yO8y+%7~p# zc~vL$8WEu`WH5eEB$~3xc&FY{6S(K+5XdyBhb~A%Ki(Kc5CiDdJLb9)8Caj`e7=d5kfjd` zC8=nH1_{{0zl8&W=Ym(cn#VI1g>tlP=@5?gLK+o1cc>DJt4Bii%L+mvcoG}<%@2}m zW{ou$k8`c{COY=$C5QU3wV;tTXW={7pFoTo&mkN~5?nr1b z(o5?Nj0mAJ9}`YJxuim{r(Bq=otb9S(-{&@*b`DsTM|{ramXc)%G0HY+8*D12>l)Te1pMo zWEmoztC}>S>WXJ1u;)zviLCd1Q0q5sTHjd zN1oRN|8@pi-U~5gUg+7Dm~o{;Y91-(;CvqgFMQQTe$9cCo!SH%@p_E>`obC%bJ8-3Z|eR zVDMFmd|< zC(T$2I62_N3qtm6j35;u;pW*RX=DV)H=Ka+t|QG75=4XmPn{r)h&87$mw3Wue)?^+ z8hEDm;NO9k9uc$lnkD-^En#*aJz@!?$tNy3Vz4EiaF{`_B0p%6#!o--OR=3snfj$R zK@mz^2Z&Pq7 zg>Sce3WB*j~|4}|Qu&<^ZX#mg% z5Wx_xElka`nJ0_n$u?ct^qu~NKj=hUh4Rq{o&uR&;7stoRwjDVO$D3_00ShnK z*^*cEh~pI}#Rf89bo>z?BoRF;HmH|cdkaRxRlwwR_zSIqMBn3=$5Y>R{X4{Wdo0h= zE$9XL{2uU)E*aidftW_lLUZ`JySr=M?IGIQ=yGQs03o)$yCo{?JU~T&g)QPkltn5~ zc1IEd?^dATc(c65!7V`aLsbL5!9%H}Y9NY9G3+7%lV8+tx>yGje2)dR8m*sS6Mj=l z`=IyKA32&)2(|$vsq@&KiQwj@1D4ztdHq+|*uQ$Dus|je`6o6>6yyU~sjSDM z!bZ_AyQqLv1{*&VHWxde0HJrs+A=<25p~>rcSUp^8EZ2Xhq1-vV2%awD|KPMHfB~s zq-516^^N1%W0}qULCZC-w*<9tqWDuXqrrsE;5OHF8Asnz$3mW0-nZ~kL%-;KfqEuIq%%@;w`{_UID0<(D!r%sBMil;cQ(cifvI z(&S zvF)bGm_JEIbg@L3eu?!OO0OOGEEw0RW@Nc;AFv@X2`hM*ky!MhzWCnrpxL3XwJ zI;j_AjAmJ5Og44(zm+ZoB7s6C?Vl|y?4_#ZXI5$Za)T}{h`Vs5QiX+T44hKG-Prob z9lKtvS#7>4sw0kgX&lGu+&GmwS}y85mN@AjySY0t=+GO_zw;8>6t?%#;AGGx=QIfX zJFaQeBR^BBB4#Y||27<)1AH*`9&*%iA2n@=%PJ&Rz%T~k)}g$=7iptaxd)k0sCN|# zbsA$oqm;qC=TCfgp|Un8vi1*!0FDRBpG@FckOg7uIyKQRo-SjWDD_W6y;+DieCSx;b`z?8@&>k%_TrwB0fF2iUq-;cs5 z;8@h?mYev6%qbVt1B(a*^@ek1E9h_>Yn?8Xj#N$!e@eDH>zX`@jbp)UCDZ2-Vq)H{ z6ZqZ&-PCA8T!>)G9fQ~Hjz;|nJ0hKU7of-RUtoyFYaVo5dVEl2IkwBAP#iB+yb-4L z#U^XbT4cQ4!Qh$vX>C2n>!E(?^mJ1`hPv z=6H2`z2KJPHQY~)6?}eratB)866v2Tp0l*^7PR!rDLR;J1iU_ZgbX(&xXBUQL#P1J zwNqgE-_89HY-eV1p{KSSkzYVYo|AFNqSM6!vh_p^Q#oML2X)Z~i6n%*JYiGF*u!^g z5nQ8_Ru^)i){4Cfj+ilZd=RzlQ+7nTVc|ldQ-m}Tlh~sIX@o7 zY0sX1C%-*1%+U1dr4JM6%=ed907398zaou|K-e_0Q=D4hdRHdSj};{3fPK_Pm0E7#6zvS|`d z=f|#5@J&p=e%A7aC-Oy%G&jeDITPHNk7nxb z#&koI+qxIG8m}0BT9i?7vROT`pBQ|Zb}R8v;Q4o(TVo@S>aMc%R$h}LzY6%y1$iQ_ zfK)0X>?*nlGO3MnniDnaJ?V@J21_>B1lM6>GO~D0Vg?-x0yXUdk+9^8Q&CWP4L-Su zo|aRjS%ug1Gy_HhXZlb+&&b>fBYy^JPxvLui#o9#>u*>1<-M!`I*wn?z?%#24hbM2 zc9F0I<($9_Qy%qv@tkAsv*PE+F1bXSaBrd-E$_Sj7LnU;NE-(4C7HZoO%VhV;v3O8 zb&)z2LJH&P2$L^ME4Qg^Gq}}8;!P+!87gepniod`Cn1qq>4{{()z|MJ2HsHK-T%u% zQHU$&XP1Wb$>4Wl2BGMFMvs+<^gl3*#CV@=5>Armnldt3I+!yz4im!*5$!9xx7ae` zdV)vnSk$#vuBKu{syt>nAwM6u?zZLnmSK;^!wdpmc*47F$pQ;}^=2&RRtQg<;SwFM zR}mggs@(&{*FXvMCvxud=t}G=UN2#*PKY-`p6MdUybT$InYPqoQ!sZ-;CUt%Lk7-q4b+Z()GhTRCWEanx0n1tBa zudGsZf4XkwzWei+?`B~1w)vSmTUx0bZcq>+`?=Xw{bWBZZ2~C`!KJ*OTHgT8JP;aAD0_PyF#*TpyO23_Sw{ zya@|e6aF}59;RyY6v0l?tD~v6jA8dVRHQkZAkt2bhu$^*;4d+lU;y#_sXQJak0wS| zc@ShJAWEu9D1C(_P4`^EhXk_M3hIFNL0w}bC;)*B`OAt0j)+^Upp7w)d4UR++3t&U zxlA~V!HDRGEKLoa0YO3D_sbn7ock-+2F}so0e3NJj}`TJK|KzUfU7vcUTk1j(QxtF zLO+hAlHw{B{P?u{l;j$N4{I#2v@x1kYQ=_VuaM9)tT<`QHu6`EEMizWsYO!UH>nx1 zGjJVCKEGuEiz6Pg;iuT0dkUXgurynDa~j>vFcjcV__K@xfV=iBLlY2JhNjO|;L2M= z&e$q&4dwX_ZR7{&s0|g=FF2)|gtcZ}(!jTNB@Y(4}|D!lmzpjJ)yfhiXC$M3rrzRUk!PY8cUI6-qhcPYnRe z!e1@lHrW&qE`G~|=R4GtKX7*~a>6h8x}?!q{}csNFu6qHD_Zyy&$O2ngV>6>smSCUsg;U=_8S$pfpV z{a_%GQD+$!7Ou?lb(yBhl#^$U^^j{k#C~yj!Y_7r=F<~xNA%_s_pl#QS4C-SK&v3I z&(IxKUPvN18oPHwd{aw%3CO=T1Pa;6PBR0q>VceE304Wqe0YX)HHI8sf#D;I8)x;P642^=#UE2IUnJRZtvkDg8qDj+Au@h?} z$%cNxm2LWm62ih}>!u!WN@%52+w-^$W@c>-0xC(zw2AJ|! zcJMq@hZW^2t|3P(9G8WW@2wv@;VHJd=9yi3Y}cRjD?Oyc4F~v?w$m4i{2fQgPLf3I z{jqccso70@LM-+37&5_tIHW8M#;|k>ovfx)7LX93Yy~GGTtYejy3DrQ7g|`B4kn0DtLpGhXDV(p!e`!DYLR`Y0xO2$FX)F z=fx6>K;)f2+5TcX9a!vR-7O_aJ{pxKQ)2Ve9W>1IhfLUvdQGWr@U9f0)v|BW)z?tm z{nDxSJL#fN0bPa(Pay7w$*nu}D{7#GITY|vU_IDKI6v8DAE)F2R)$ND)p-ZP_pQL0 z#Q3y{SQ>u)k4wby#9f}m{YklD^LJmFEF*8-i16_E2N}z&|CR_wZYIB&qRI6V1;OM- zhLo^Ff5GIF!sb?*Aw8PBF=wvp1CFI@H@1FAw4T!n4`G)h^*Rx39f=p|O`U_SJbo($ z!^1_bj1tf51(Ycai8nT17$sj^Oujv)OF~G!?Sz)^dCZDZpT8#mnGC;I=Z>&TKF8Dc zORAPmU}pz%pJ>`%0w)NyFHOFzktIhj#URGO8=E>cFV7fd3-rvw30V^~frGCL%8^#` zL8FLrm|$Oeib55RMGfb8d1{Kmv|v3YIrp)n=$4vn1^g$yTmL5Q3CAtfsb|!ya=!j$ zq+%U726R9dA;x)q{(_T_dJliyoO)d{(r@=t4j5ZqGAeXi;;t8b<8VR(;bgI4qJT)! zagMy2)Y9=QtWN#&n4?U!5~~pd*0g=nX1C0R{h+n*e|21!;++liwy%aewr_D_eAgbpsyyD(uhzmV)5&2NT6G8Ik(;H4W)V+k!5iNE`pi)mrV zN1fLG;lbhFD|1OLS~8~qS`J{7C7qMS|9myos@L5G0}zy_>+aDZfLA?JcQe0z$(;+& zu?ORXTyrCiG&vS*zFGJgoR3M$*+MvqMZ0c=!@#%nRajSJmij8_grC@LA^Vd4ADwN~ z*}~yMOw#Ap-%qO0ULCa#_77gY>U?{JR#VuXzhoe6Fy}u%8CAYH3hDiOZN-Ost%J_d ztG$1}p;ST_&qd{<`n_#_$x|pFued)&htcn1Km0yD#-4o7tn4xNpM5T8y`m4?zoT+I zIA|TcdU>?>T!#C1c1}4sZ0#MiJNt*#_e zN7Oqp&jG<<^NbMxRfbfbswK~LL-`t0i91X_s_})O3@P77vDwNxVGMg|%dAwB2Qn7d zv+*t&@-$WQcibiOK;r&AcS*N&XWZE#$B2={FVGQD7A+MBQf!eiP#DLcn9)37jBu#o zr`AaD=CBYzmUBji1%OrwUsMmu9e21y8ir|_jUY8%_Mn_Kf;f~0VMGw zL0H(|GQSahI}5w<1Fh0-x=pG7;ZN%ff>TABy8Oh;B)LbG@Dt_X@;$2ggtK3~;xn=O z3et-2x!|I}BFK-Y9#?5ZMLt6b&EWbJ{|+Jd9-+&nE7pG_j9r7jE0DOPGsD^dSuxD8 zDz^@dYGp79M?!4?5*5eOu$^!TsWIhPjM1Stv5qS!TmmB9v!KR)X6b8K%jIKhumjX(PKjS5~3hvP>-5VI6a!=4#N$Od8 zn|dWqOckEeIA9iYZXIu?x1!RyO&%g880k?g|BVHnK@feYn-k6fK~efdMm`CdwG#SBI!?xNdjf%Q`p1go?>}== zvf=wD%SeX<>lyb?70W2Dh@N8WL|g7#FQYtJm`n+7YeHgO^KOQjt?_iOtvfsjfa%}l z1{!3+27Fi+a(O?ADETN=S#mw;sGSiM`c`j(C#n^(DBMaImpT#%kMcoJYz_z&Cg;kW z(bOZu)M2h2lBK&!6A#Afvb62G;L`HPxBo^tp!E^wDD$Lm?UH@UuxDwiyYv%RD)ddd0Vqy|X&iKJ|NlKYmlE#@n;ryW#cu zpnjd>!TE4>d38LxzU+^Br|12X`ZV4SE|1r#H~i=M@%zic`QU1Jeeu3`J{o+uzPKD5 z_lLvN^LO>>_0G<&dmnqJXT3LP{p)wV%QwAu{q@N7|1s)cp7+kKKlDEgF8{ek-;Uq+ zPp;1T*QY0EDIOAOW8>wLczsC2K`NZ055DI_eo%@uhkF%WEM3qp0gW)$LJxOMsFe>Q za$|;f4+s(DkzZNhn;{!JdHO~gDK#J(W2m{pzQkcx*ee#sfPNxIQz6-z73RyC0jH$U7nue>H1Qm1GPp*^rXhvNbb}`N%Ob9SQqrZl1S^Z zP*WlcdM~9>g%x=DP-l%Cc5;lMN+MyjT9UAZ<2~E3REQF+&qCc{alDF?RFCrIpz)MP zq|TgM=1B}d$IZDl$w)-T{=^k|yp;S0Z$m`z2h^J}ve|BuPP_fZjO7>C-HiXLg|AjL zZ`bT!zSN(wqkQPh-K{vBl#D;nrL@Dv^PoKGP|I2^1Wu&JvF(8O-ei@3B~)ep#{?m) zpDzC*5KcrF{`!qrueE%%KFDPRJ>jx%iZLkaNhl-E1++f1H85a!lU+l;AuIR)5ZEN1 zO#_?Q?AA#f*q%e>hLLTv+hQR5Q~290bz}2SKH*j{2>TvHMssPdmNvI;IXxap*itiR z90eg>WYLRqcB9`jlal==xO`pLx5;; zpRh>nKG~epOsCQ#Y(kT+F~*9OgVrm)O83*LAf&nl5sl(>MR>=L=-5Kj8ZB^r-a_Hc zTk2}37QUX#*4D8E*X84u%9pg61mND1$g3e)(lACEO5MO_GahgTPna7~3A@UF5_lq_ z*`nT75ocN=qQMdo^lV$(Nd+477$JMd{PD#JpW``8ga^tU1FX&iJZdG^2j)& z*VLwkLnRN1d<@~vJbj*#MEOa@$44u`sgMY3;J%TL%QhpuEB>xRj)u=QMdZW&2^`Vo zGVt%61?Za0843J406N2>JnIaT)Z)}KVx9-+>=VJ&r39|QfN=5h<~mbmJy>q+jNnXG zw~Cr-7kY?yj1aocc@Q%ixxzkkW>TLOLz1Qj@)R^hR698E3+VyEVS-VB&Exa5cX7(& z*CUy8CmxO{cAZd?)w~pA4@I)zcQoqG<^;JdaX6G7hI8`TOkndj?SiFCcH6OQ-wQHt z$*o5Hw6jA_d_jE~+$mqG{=`KW{A@FZUC@&;7(`ZZ&QZ5IJMWKxGp_jt);A*v))wk>sUM-c~| z%~&AL7>SF#cFrxHQO_=%#O)p52dky)$XqPcXLaFtW@dSw($q>7bT5FtfgAWOC}vAR3`gih1ocWY_|= zyh??8eR{H|(~QK^+&ovej2p0+=V>Qx9X^AGK*^s&L_a~?6SSqHZAbujzeAVK4rd{3&7+0; zCvEni6R**je3hH3{FVk8p1bI+?N3Et(NL79l%#hzBw5ABTJ10G%987Q38&ie2_TNb;qa>GTfNIr|u{TP4#;Y z6mRm8W5tO){cuUTYmZn7Txd>ERJ~DCo5k-qY%hIM*l|{*Dh;?Xc|!HkPMKK0<4{YdLLQR!xN%PQ z;>ia&O@7@Gt_Vu6qbyV#Q2mVYI}V|7&<+a+E#d9+6vLDtSZiRkn)0;y^^Z2QT(})u z_>jDrY^0>PAvlAWz90hs*6eZP>mUD+`U6CEB$Tt=io$e(C-~C_2(^9khjzR3@}L9% zZFde2@xSf8_QB!aOY(=#{>%Nt_TE9~;P4Oa&SAT~NB+=$23|6MR`7cChjtrqc3H4K zoi_d<>c8K?A6=&U-}OJ~NhPL&oJ?XFzre(<(Sw*%IP;?DVIz63KtA!n#;J)yB6}v8_FxMf7C1SpLXCG+RAN4 ze$Htvx3-~7vh4@Y606eCa{STIZb8jV3B5WGY0g#>zh_#?E3bdlD_L{LwXfy;$y7^z z&a_ri+fXLawz~==6SML|w!OR>iLZ$^_+_@C4e=q{MqZ7?*K`}`B5iJke=@d{Q!Dj7 z(N^%VjC?~w{P%1tIpy__dLCqE?V6^L?LGzx_^GbQxuU;<~W;IElh%w^+GX}Y^+ z!npjPU;v8{r^GnC11y=)Sc5aZTa zwyyX+({5gQ{bQmMGubfAVE33y$}f6x-_TdzAR|*b`9Uwdq|rQE5`WFmG?$G(rRnZ0 z{m{8LQy1TiZRFKU7s#}C=XiUDWu<*Hx0h2dT_Dk3d;rY07k|sPS5PlqAkki)4VP>C z6F(|5OBYDB=XkSg9-(V6AyVH>?H1NI70M8S8_%4o_{msdM|dCRj&-V#PK3J+X6uRH zv+d=S*FR?I7tDinft(i0W>OKE$ThX=n%XjzR9_M_18TAByt7K;Yqpiby4fO$cB2PF zbJ2sL6;ny|MK8Vz3`!P$%+NHJR9_M_BgaG(e$7%fmW@9pR_TL5WM;C)qGqb_!w!_p zAuhfdInS$?E}&PwJ<689J<8HIm6IP5^bC8 zR}uHv)_!Awj=Li{WDmrmULzuq7aLu{qX&FmQViZP;xP_A2_Daji8EV)t2?m51q;}i zG?4=`6~RL7A#U61X$~6Ee*W!iPSsC=6EQBL__u1KI{YH)?n zCOnIpMLkUY==yiWW=rOAJW)?#P-3tTCk5cgeirsv(cQ`X20>Au%i&BJ9iMaLALbJw&V`qd^#&a?g?se5`S>s}FUC+or^3i9?Y1+Vw4K zwRD(@g+eSnF%A$6Xfd)Wv0X4xJEWME0Tg~jT{&9J7S*;S{GN$1G5wkXA_*N=U6&mH z*MH%v{u{leLo0BWkxJD7KZ99XS-@uT77A+$F)EQyJ{~nf*?FA2)f$~Mx*UNlzD?6t zAv54x$v>c70`F10C6^_D8-agCF9_%Z&k{W5!!#bwX~68nhxABGd@=q#grFV=HZ94J(czja$i?ym`9ec)7|`3;?E_Kjh&<7_mjY z#)O@4$y`Q5QV zna~iO{Ji~y0KUnJ_tP%yUAuMAI;htg*gNyh_J4=u&RmX5Hl(ltf;8+9*SEzu7L zl;`Qi?P2NA?bYnx^7ioe?V9M3QTczCsQCTk4?SVEh!sgz7*ab1Fi$4{3p>v3Tk23K zSM|dFlW1X^SqmCs3)|xBHny-W8rUk7^zQB&b4gIX=Iwn46KZreeCqiWxxcq=Gj*(Y zc5x17Ls=Fe>Mp(SpqGQ=;YF2Rwp*b3>JQ|#Z-vY6pr6C@(`wyZXSQC4 zp0iFLQ+>l%gXIQxPcxl^mB;hmjkmYi{gMUF0`NQCZ7jZx7lz}esfFh)5#IpX#f)I~k@^0+Jv7*0l zbN#Oda~t;7>m?2F(35up!AsKIueV3}-)I29RC!;alX>6ZPB#Cm*vs<^_)F%6p=&OX zlp$W8Ubr-Z8BAVhNd1d!Q0IQb_`7EZzGEA|*)+IwJmaTnz}O@-SDRDkW@Y^1I^N36 z26Q%$Ubyo7(D;SBo0z^>53@YhJr+SrKV&7?3#_>VP#zFpX_jKJFiSC59PS&xI5dYt z*Y~|yPNjvjG*6$@`-?$Az01Md+;5*Q^FIC0)oCu9!~VOEx!*>Ae|wf+b2P}6^YEX!13v2K z&y&$*FPG$KILiMvIz7+-Hn__Bc6EL=?B`CutIKz}pN5y6f^TLmGCY0vaa6QSKAoN) zzt8*lkK>Ene*EL@@PBjH-ete{_q>m1gJJ%xKYu$gDTyo3qN~|F>fb}AGROA@0RXd* z*JNXr{)G10%7e5eF0(J$&pfGwiR_1!8#zlC!wcP826^3pWWfK4gaWK@s{9616!h<% z2trPo#{x)YYM~(^;5Cz3NfWi>#GiWYq8jVAq$Kd3OGKw3oKL!7Tftxcvhr>`|IYhs z5y8x0=oDEHz!g&;{?jBr4pTR8{Bl~!7}77u2S1E-Y%UIUm>Fb+Zbm)H!ek}zxx%@> za&37fA27_9uv$v!uedE5k{8r_K;)|z@^Lbn2mYP6!>0p)BRVprLBNxlth|s;(ZHr5 z_@{9@KZc3rz;Vb_%92hQ$wJ2IuIWM!7!3i(ONAHz<3EY7+p*j&+Oi{e1X z-A{Zk90+v(NQ?vi(iLBF>c%Idp>N%=NF9j4$spk@km1w`N27oK*d=hVtNO&TvqO5W zL;3TU137;~`l z;GdNaqoe=*vC8>L%Q$ceInC?%Rqz)~gd$`!00g_`=U32Xzx}uCcsI&lWgZ|}BgY)u z+{z}6B`;*^B!No?n5>Q$1-`wq`1@k~N^Ux@n_1LcKR64T*GHh?UCTQP$SSq1Wt9q; zz?lUGC>ehiSdvX0Sn|u5M60FC#LKDquILWEgvMI6v6NoG!2JMj&Xrr3vOE0Kmmy ztOn^yd{*0;PWcU(E?}GnCVoz3t|ZBT0E2Zrg*=*)GNAGLg~&yvPFP z(g=LHVEgq54JJ+mulj0Ma;fQPX&N=SS_Ii46|Q5Ho#9W3O&4fNUDVYxk*OFod{>RJ?5ezlS!NG22UPuBjbo_>S)*KMZNaXuB zz~_S$O~P1|AkC_?tJ;GtHN;sUn#mB4%h&UY6MKRzhW+cwwZJyxqAGwxV>$+ zUbYU6-^G@71wI|cdzDlS=38QpwT*LSR9|aU+RAajf9#Ua$@~Ccwz5A}zPiV)k#}*d z@7tgqjPd|MBsNZ!RJ6+0sf{ptDXF%rs>LhMb#C%m!$XVhvrs57{-gl<(zYG3w;?Yy zn62O;CI%VDc`Oig;6(JZ*z>>+T!GG%so4P#J6uh`<4I2y5Z(EzH)fxdT#csiJCsV( zVS0o%GtK&ZrNy&>OI4vJah~$(yy~g@3%|0_ z|B(gG)L~(K1t2r$f*~oM;i$!P>8jK*q2(``0CyKlEzbt@d=1cwqto9yHrz@mz$;D- z+QZujyNM=;gHRh5YsOl3sXEx2({Qsf4O{R;*D$JGfuufX){T6)lwE_=1iiB}GKKsp z+=md~`bgY>apC9b-ME8u)P(>Mj{a>F4Bpr|96Qdt+ahoMfUtYS$!`k#R8qMEUr@}; zDJAn3I303MfqIC%b9dFL?}CS69fo7fe{2B_QE`;1n;&%k#IenT^|!AKU;5Td^zbOzGAl zS4JgiDJuES7CGVq{Ryt^h0=l@8zN&wx03RJU;I_HTt%pKI5BZe1EUx?>6kdtG#;K* z4)-RxI6dJ`QXwRXhq=Q~JFRLXQ%zEm#oB_3(+_B2JOh4%lFbH9NepKt1u6oE;Ch$e z0_KmfupgjWBh(uVBWm4XGzOOeydrt+ysp*c&R3j8H>1{f_JYU<+Djw1SnOO z4qWR6E7ml2+zH7H-UaY#%J;~WLSz-bvxUa%tZ-$`;rs}0UH()?={p+q7wzqY{vNd#*`xYdZ4&N z4dDyXsMM*{<6`9=ps5iWM+6Rbs3lSBD~&EL=i_slZZF7E#>)>qIs_8?HBskl>Yip4 z{_m&}3*IRBPU9zqAhyAAgNJK3#-NYzUn~e3}!DOe$?9pAYe7Q)uY@LmP?r|Ox&_bdnVRUj`9WCgo*ldj6TI@(a}1 z#1c%$3NK$FWS2S~ZpBtD$NIw-$`~v4Jz*zvr z8K}O=9?6^7@~)Xq_x2+>EEyr#B{E(QD(RcF+FWPhL@AxD*%P&gN$zMYo_f{95&58t z-%9@08Zzw#jNPM=B22H?JA)Z~_i|X`NyZ-^MSkpiQ)gyad2zfF4Q4F57BURGrbnhk z`1aJLvk=okd^S9Ul4LYA61}#Nixt0!%-+^EK~_~z6mNw#dqJp%a_} zf8_|{(>~m5D=;hY@B;d#Zcs7?>m78Cq+NBNOulXU#PXL936VJ7IN?7dx?S}RvfKef zK(2{1_oMtUkW_2wEZHU}SLdk!TR^10s_;B42b(*rh@A2mFs#nIT<-Wt#QR3kmG&WQ zks$;3Qy(5eJ#~q2x-%Gak3D!U(qPW283UZ7ZUWcs|H#>IrgoQfD(ztv*9qL>)L182 z9M{S2qu0sqw^=8d-hWp!fdxVJnXvnmGXc~?^@#wbaUQfEJrCNCn+I?kvaY`5c6bO! z$+>^0Ui$e3r|2albQ=ev5qvk_+^Xzx*E4j!nGrj9%pr!EjAC#+vf;b-21I#t*L9=f z4ON_lE6yPtnn2w^;#`cc@fgZ&_SP_WxdeuC9%z9bmBnx>`y&^W=ogEn z%*lhZ5=9YA)cK-GLZA4a@%|fq>(MhbDbp6XkaCyu#GpD+i=4xvMRALm0M|vpojd|g z6f$>8?(oVs#M=_dZscp@RC$d<#G3~6S+v62PqxBoFuOG^a8EeyTfP^G01CVu_7@B4 z+32QVTzJ9-G?XC*>ZvVtYm6}{E?s#53&tOtr%nJ4jV?nUQn>3jwJ=eRs_dRw7c`oG z68oGI|4U=w&1ECAFym zd>Rl}H}}i}7uc3~WRYPiqJdD0Nqo>fZ7Yw!S_UGz{mH?e`mXEWp&tvsc1Hw5A?9rw z%)-{s;S(B)Ao|DIhdVo<&b;_i2uS8g>9#fXgFdz9o13@PMHdrxU*>SDTwwqF8R>BMpsXBaM>DaoF0g=+=iU z)b_nfObw87&ul8-dpbvO7DK%)(b-EkD_^`3)ixGFrs~>0I7t|l{Bp@?AmjMBJ;S-? zhNKpc10wpW`o>)(@(Ig3ew|gmpTl9G8NX18mBP1Ad|`*(Tyn1VS5q5tJq{S3>NPk% zu0l3lxzIm9uo>F$=nYLQ-N%}7w65GXfKSdm81>A%bppu$>_rkoe@TNHejH^R&Gxoq zt+s6%(QVraUbl9pzE8F#>Lh9HOlW}Wf=46&9FpyA5kvL39q1CH$MDdeoz{;wVm@z} zI=0ay8>(;c581s9qu#0BnI6E}C2aV|_n=|eM8P#(jRgEd4MyXUJwPmQym%D;{20#^ ztoS3MeD~xhaV^vrpLel>c|v0<4EgxRV_a}am%z}yY*pK4<%D_cRx8ggIr@}NFw~D9 zEp$y1YZ-I*sfbczw$ZPd3?CK~-*qekS}#ODE$V^3!)R#4v#9(~o;#C_6KPHJr_-*s z$4P-cZkwYMaMFok3=qUUG;T?ePuM+NKrI%`c4)+04EHuQp{!nrEeN=SSoIJg2>a%! z;3`;Og$#i%`y>Km#N02P=oM`SE{QJj*li7j|AaKHx$OkHG!cO#2?~+tWo9Ct9s<-6 zfq%!5`K4%|o%OTlJ2C+HQ+|5wA&y8cxxH$He-8*4q1V&!(z>5NE66?-> ze0ZulnGRw7CqxQoRO`;(+{!zpM!`ewp%=%nu@fzpIdMU$gYh}LtI_gTVo|s_1IM_n zvV%8zQf!WqC7{fLAeZjrHm9dvb)8nH+Wx}Dorx^j>KcH2NY!Ns15k*}Qs(MuYN8;J zV$H?yq^saqbglYStgsm!RU1QSWvzV(B_Xf5^-Tv841lXUo{*Ra)9~^8v=F^ir;iZ5 zoD9h4g^yA42S*1->k0a0Yqyf1Rco~q(InP~?SdKuT&K=L7plHihcXo|LZO15-Fs(hKgf#7;jUUzMQ)GDw zOc*2>GPq71%OJzHUK0x?Ii&1rL675g9O(uFBBmO91kdq~gU$%imr&VFUBSY#8y5Fb zWV_Ts+sIIac-aVG?Ly9#;FiJ9I?A%p#GwY5ERV__-i64N0)+9Fi9k(wHiGw%56ceb zdojcn&gYx+moF~9d-Z)N^!ocj7gD-~>LHN}jb3n277$tAVN7|{p5pUnT zY_}|@v^w1DU@VI$nC8jOjyIWwf2uMg&`jXhC(1h@7-d-vFpK{@^c;8Y_;j*pXD+$6 zL&EpD0eRg-cXWcPOV{EOvLZaBCzB)|)Il-W6T}*Kk-pL8qcze6Y8U4n7NeEpOkqP9dYCh3|G-|i?cIzyIxrcYIF#Agm ze_M|e0d1+CXj6HDM~4p{JlWB>tv%r(wb^ayS2U5F+X%@RtIX*)W==bzb&Q;>lRuhG zGS6}8Rd=Sp`MaCxrQA0+QytOz{^-qjdwctxcU3TgIr~NvS!Iu?DTl_hb|~ zKA=%E7a`{7g)Cvq>CzaWoZ_9JKdY6KSWcLHT414?US9d66$`Ro;XN)(+oqo#gYVoV zI07Ek&j)ZU?R+i>?`u&yRUHAwhTi!c3HZ2h1!CaKwY~ZF&lkXVr{8_O3JpwDLL$4n z;>>0(tw4hGf1m-~&`7^30{}f6=Hmp~dHc66#FuH7%i+%ULXhtMpkgq0o?7oA z#k%iIcjTD>?G;~JQ4x4cMbo)SbR-#nlXF)#mD20*1WaFWON(b!(eGD)%}cP9@RB|r z);WU=wO{&dX?jl=p+QXM%Qv7UgEyj_G07zY*kpq+P)2)!_`1^8YkD?(e+7|+RgD_c zW6K0prv!AMnR6_`ITNd~1%%G!B#8!OYXB8I1$o2>GPJu(FRo^fB{5T4b6&PN4Uk82)kWenC{TN8kXWz@cN|7K5NJg^Q_IpH7gud z{7-pgSGJUe;OQoIZKsrF-CKexBLJC4%FXz;~Ca`0z& z5?xA#U+nT5!DBT0HunA=rN-)qmyKBI&L>&+UI~C)-dJy`QO2QgRZp}aY;oK@cyu_( zk}Pl4*tX8TIeGcAHy5-4L0omOygfU4(-W<6G>GMobq~EhI{&68TK~�OWc|z8|MO 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

    ryElMPT7P6vsIY{f2bE{ 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%0A4*)$g^)LO@0p+@{F6elQWgZ|nG+?llf(hq%S* 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�h$bhOGW+L>_Z=+t~c}W7R0rb$T#H^xcA*$`ITu@?-Y#Q;{F4?FC-iL0t9Tej7xaV$r4PLifrYpdZ;3N_kn z&GWTb;2>>PZ7l?M*f3;fPBEVrJ#q+uDcXzWqubRNB3MzXzth`ksUv0FL9RySy7B^J zVEsnX24B-frDk9mH50dt z!U;>F57yLk?Tf7M_SaW+A+YKCsn&HH6nAf{Ja?(jO~O^*>e1fkyTQ-hN4B@&iU^a^ zv6m8Pt$Y2nQ}4V9@p5~A1!;n~CP${<5cSp4V72S2xv!CHcL9r$tiBGZln9g z5MWInYjwp)Kz`rkRfM78j@-?(wC?Aj16E72ujaQRkWj^i(MT&p)fnH3efYa!A&qaPapcqZ2}PuzsRHm<{d#tPwjgrVI;ObaCl8N-wJ3?A*J=giOE?>??OEj;_xSFZqt1DxWAm` zX^~&H_omK-ifhl#1NvaV__bJ@sPpTekg+Q^KZpqKF}=U5h{Bz90w{XY$@I~F`!_r) z3=uZ`qv3Q1BfkZJt@1A-pv9q)DWPiUU{)@w<{P?d& zdruyTul7G%kDQoch{fW#s2}GXg%zY z0_LiD?@Y$YIYL~p!vH?~5fDT4r)cXWgP)ibsLvu;FrqfwLY59pVQCTbO$k6_n1#+! zAO~bk8W(D6St~-VZoX>nX$sZ6Q!{-3=w`)&3OB6SPepYr2q?FlF&HzrS3XvP zG`%H3M4tsgaMqhu8Tjje*jqIfTT(puhOWyS zA)1>H$WJ<3`#tdsC}dwFz<8#l&rCJmuh2JW5iqi}s)*b3g7ZKL5!ovRK>l>7E=L7N zIOEq_xm#?^J9`?+Kq{-#7dJslb1lp;JD+1GIuG5!vHny;x zh3@6iC?PkiQpGTh{c<%Ane}i!7@WhcL(_H2y@Qzo-BX$(I)kw6Z!WJe48hz&@=9LG z5RCGE@2UBa&_YIuI5fpo@SdehvYJ%Wnx@RdA0--jYO`kW@ov4Gok9{CEJbKQ1XOk^ zQ+RRlSCqs#gmh(Mn3luYMDtHbJdsI8l1Zz=umd|bKx`TXf zczWTaa^eW^v9P@&+{pyFtjC}}UPS~A_TbE^i{@otJF?HdomOhI)$DgDB3_cnB+dBT z32c`td&P%-jMA%FN!Bq&+(&uu5-wwaYr0N{vdz9vIPef71YDm%?MB1fXljeiI$##G z>Y|N8_sg7DzL$o>aWQ-!J28Q!6(^Nq(TuD?8C!Jzso6k5d{|E55h&CnC9AXe<_8E! z3R*dLdQW;!g7&*qoy9jbMh{IqmBH1M8Jje?I-{z>oZY6n0l|kYoncf2oM`|lF`ZS; zd^-XB+DZ<#;3^>Qy(%wURpif{pkhW#PF2{WlUs+|`QefA^Uh6>a#an{qg zhFq}*fT6Uk)0x*LOSLDCsxte3NA)5o1lJmy@Cjrue^f?MlPfK^7K-o!uM(Rfo~LX#*&l-LZLq^S+jJ(vpIN6zCeQvR$>TrIEvpt$T6t*Pv6vIjOe# zVoOg{CP%Ce3}>aXkPBi5oS@ql$Yc$*W}IXvSe(TJEE zXq&S&88jI7f!OHv0RKv1>7w^Pxv-f&vj?a>D5XmODIa+B+9}9MTKOFjzX&y-42ldf zINWXojwJVW-E!!;BEN^xS|V!>vdD+>UfQ>0*6hKw#K^OIT>2J@x9iv2d?@d~Zy~B{ z_OI?@zOfsTAS7R>ImQg(AIi%c$Bak37J^1vlQF)knHUjiD%w%>UXqrpX>SH*l40=0 zNq${?kO?vkgDY^B7p5s>vZ^00d@eedGj#Nm)PZt3Tq=k{q9}X{qZ+G1+{9_+faoV> zoSM=o44wpA6;n^;s9^NFG@o&;1Dsb^Mnd+(bBgQ%U@jkKQTT_RU5F$t5A1o6x@V!%dMU-<)-kk>ddffA>;C+u{e9(i4H42W--RcD4~~%bYFu%N zxm@YByrdc}s13=G;M#8R>1X4Dic}&8@DBhs&#Dngy~CGcW7|$mAt^x}~ZOunI9~D4_w1RqA_@ zgE?UkU7dVvaUGYbjxdb9^AR%1vQ&zAP|PZt0oSDBKt0j(Cyl{Cp+&B|9?AUL#E$`> zZ90LPrIIrY<14;YvUnec3^|-hXwhCrv&=e7#>I_!+Z&;hRfT{>SmdwWdI$mhR2JHH zgH}ziGGTTWxygsbaG+pgZLK^MyUYm(BKr32+0pUk(c9N=&%_I{6NwEIo=wke`mY)` zZoJ!%YK`o-KDry#iPrW=#V1(@9m!R#j(DMum* z>wglCTg_$}A^t|x6F)Gdo3o<3Vq=iOd5D>|V+U=txs_nPJh1<|C<7WsbU}y6^)sL# zT2CYJr)x86YqSyFU-M0lV}*27Ef9Wt+srCVs*$pOc33(Rk+x(tC)n(r-bx+V-G6-l zeXv`8wNCsjE`E6Tmjlu1cj`F`7hk&M zv5SRce%a7_oTvYkZv7b)DFCWf7;mDlWtD`; zkgz`7ygZOIgM#!^6DfeU@#uX%n;aF{Yy#jr`D}7l+^C--oxp6r)WAFRgj1l`gX^%} zB6fl|DYhOwb(}5W_ZW=otK3q&|YiC+27sU>o?+m_xt_+Z}FdZ{kc{A=d8?{@t?CQ z%~Gglh8Bl+XRpEAU1T$JLD$vdSZ=e7ks2XQwrOtOHGhG??^-<8>0Qp&8u7HTxTbX=cM z3)IiR&`(0?q7|QXD>g2D5>g9Se7cmQ)t&_Wl-22KJoVL{Rx&P!E6#+h%d zQIxfL!{d6lLEw{Sp0|iSiLq0_J+OaefO%?cQ)|`dl=d$RRW1Ay)~)@4 zQjVG_|FGPxuV`Lqe}I?2^#NM(_OEG?>uc<_qDzBA=+_P20+c~a>KX^c zi1G;1j|_We7(cQJZRIbq>d`~d-}K^xJ58~6;k9J;mi?ssReH9-#$z^T<1UCgKQ7;@7w{@doI zL+i9ToWO8uF+kQ?yCS@sw36a&za1ye$+kl}grMc#of=P^K4O;7ZFwI?NL!|58{$KqsKrI!s15D?C59G zj5?#D=yV;er33GFK1HI8(Nl^g`=X!S2XqUaPi=)@Y0V7B>2rJYAaLM654~!{c7uj> zMc3K$fNkE6Tz5*d*ViskBX-5UHM3>(d8W3+C|^)VKm;12e}wA&@amJ_h{7J+ z%$8AssWJ7s=b(~6*;6Vbp~W5vBJ3;&ocHVt-hg^~#Um~w!~>zAj(7^5I~0mr6iuQ@ zJM{cYr){LMfVQKKqSD|iTV0H?s4G`aOCXCekA{YMO~^$>OQUE0f}Hjz;wNRRQI?7-$tPBGGei z_-@uO9jLacrkY%pvuZqNh;uHFY@f%YSQL%VK-NS?J#@IM>o?zMT2HCQvr2OZ(Mk^k zp?Lyx&TDB^tNNn-vBn9t(bH(WRA*;j04w;b8m2&FU$kdKoQeNw-LM|rRW__ccH!1- z83!Cv&P5ufQk#~Pa2S;uFhdkih(VoUilDI}4=l-8P{hLiCI?z|||9HJZ1cC@)bcy_is zt*h;`X6qW8E-oXp=ooZ~+{ZE4oJz80whI+(rSTSB>AYplMZ}6u_yl~}Iui}4SQrEJ zFo4GE+(X?`9P~*#a^V5MY@ly$p+%x$tg;e%nj8iWGHIw4{cf07;VoiT^b%ohG(#84 zwTO-A<#Gk1eR@~pS9gH7@%46CR@BIPR;*UHJ>pnE_vHG0KCXPeXQkWl0ar;WMpJy zWMo|GR>C*;Lxd`ep*ZST~Ag z*L!r4zf|7+9zVh2j53+1j9uv|y8|821DTR%kWJWwIbb6!Za57>$!S6)m9-F8Y9Iy> zMWYfPfDU*equ~WO^%YA$+{8ejXVd7!k?LeuaR=(yVXdceJWm=>hLHbtI>NTXFG~Tz zH6nL82WZffp#h+hR?uKoh|m^*W>;~8>MfPEf^Vy@{U@=I!;3(1Z8i+{WnUf}@$K(~ z{N3E6xM4JnIMBT%vUt-qhfrAvZUQd6;t;R*@815<%;J{$ojNzTVXxC^IAt0H$dsl7 z#N6$~;o+g})!6hcF`bU+17JQN4U4{e`-3a}7|Bn@+|y#u=@yCHYjNn#z`by4k5%1M z{Dr%UzhGad?X~@tJGm3eV)DOn3SM02sDCHCd$)XhUp#xKavS9V$TK69I6*t;30Yjn z91J0gsiLTrc3G_FULk$mO<}#QvbeWY^1gM#XHVbEqXl>pS}#>70Gzf1m5s4{CsgL_ zB;(=3gRi<@q?EpEYp=bx$vQ)-5=_f(lFZ`KJc_3>i2CFK$$yZ#Y~*QlDZ^kS=u6Tq zJd<3>X=@COnSlB*aWbV@1aPROZZ@7Q)~=ca|0I4F1u)O+TMBt=1G5!jFfNdXL83Gp zDxJyy_MhVr?Y)~`i6|~S_aWNaf>v?3_3=tVyA?tI_y6+${Ez?bf2{{R4*s#Tb1+;3 zD)b8e+keJ2sfL}quh#6VN9{cfw%^C7`*IfcQJ}xpV_#m>wV6;P zp*8hctbA2nW?c)o!)E1>Ew8Qx_t#=Xjl`;~NLj`;6cwc=sj_zCM>lQEI24b8U4~E+ zOhx3o?WC-hX8o@ec%-KU4OLVD#hueFC{hmGCP;3|0Y;W8)C?-(EXo+`6UMu|d;0@L z9q9nddN#|%`8jk$4dl>=&?La^smf$~o`i*0Car-rpj)rg={)V>%TlMYX)HZo8@1wv z4uR+i)6i&y-nb?3JO$;ch9kt&-cQitC()$*2s)cmC619y!F9ZyeaP}y=5XXz^(cDa zzAi=ar=KF3{=|(|#9oA&Nen(f~yDg>rzaeCOK3qO0{)& zjL>kd>Gb>vbt;^9XAb$ciOu-3O&3;}qgDHyOy}cy7%sN7sxI_4-!h3@bb4zX&jpje zk9$;^CvMng?iIc)@Nj)GCo>&jhsPvOKntdjpCe558Yip@Qr{$T=t;oDNKGu_N+J?# zH8341K|d1nJ0|^V0&iv`2;cs&T;LgIg)RF<7q36SVeSUV^QmS*?4bd9;~H=tlmdr3 zfWF+>?JnC-_MQIA_ArlWIf`zNDoj176#}aWZ|7lqc;j7##~7AVf?x8xC%@qS4$>RZ zk6A1P`nYp+1EbxYQ5J2wiEb<9+k#R)ESy5EgtiX3WNAQr8;Lj>1re6>;y_mZ-k$&J z!%U$iPZvLjds&+kPJxjOpZM^y=6-tg=0&>NZkWTq|7(`bbS!P2krgzV~frdy4JO|Qbk1{BB1{?*RI?#OF_ zA@>c$&iPnJt~UVnDvzA}=kQs+J;mL7G;uKL7|J+ZC`CX+_6Ei>kvGMZZJUSfN0h&8 zuiZVUJe9m)&GNG-%5h&|Q@!@SF5gat#l!;#*0Wd4^}&ffY%G1w3vAVRZhg=59lkic zn`>`#LNp4Q^&)0%fVZ)dmj`ZBp)>P^jm+kpAeCX+cQ=7?A}3P}SiUXJ8q(*%n~jtI zpo}fI#oc5Sxf$l#Jm9Jsvzd|!mv91vF<={#H^&h~n6vGmI7vvh%u0zavI|lxcPbCZVjYF2%vqlQ160up)24iwLqT#mNZEvf;C*ehfm% z7@-)V`cnLi7_g(9BS_6*3d*WWNtr_KJz}tEgqbVhcgBnm$8!u)3%0y?Wqa~Nc5ZKQ z>a8^hB8xb=n5Pf`9tQ7~=(D}rdRwOEoN==3jud1j?~C_p0di1aHmXJ4L`74zCvDx6 zQ~>Mm*2;gO{WV%bWy4L(_Zr1QjmP-7IOiz#Gz-E|qo)(2yLstctIc+m)rP1E8?^G! zc#0mJpn~-qkm{-jstu60*KW5PeJ`T`+)fg|z!8V1LuM;;gu=4gY||sM&u58w?c&yu z$2xKMxhI(NX=$}i=6)tHyH?Bph%Z;P#&DN&zxMPuO1{ohYaWU=iLV zPcj*XnnfUuz6i2PmT;LY<=nCc7p@GOIi+jhMNU#?3EJR)kCXR)g3%Lf0(G~1;6=cY z%!K-TMTd=Ob)iC4IFwpf*a1_}17ct))mVAwn^s%*L2dQEfh$fDfasKA`LUnL3=*!F zFkH_ho!cyCyDDVJ)4#qMFZ%GoZ+y_t}wM3SAqRjOXfrBIf*AO_+z@MXR1N#ZI3*^r;cQA4+;!x_L zlJHLB31IqkCy_NzFn0Z(8G^%$xWQCDTDr}~+gkXYOHo=5c%X$^FaVUqp zPQ-7Ez-wiLlj#^T=_F*cc>=c&Oj~SRnjpcIVIWO5(A3+$Y~<X|(- zGoT*S#q7ra3y5wRkfp*U# z#aLufKLiMkG<-mmFT0a)cim-2<8sN`Bip}M3o#1dBCbGA4^(!gRD|Bngrg4A@&mN! zMb-ZpJ@(I|I6HUEtlqu>=ZjyL9!+?H{5oJecj&61--4b|J?l3 zYwSV)J>s5JgXO%x{&8I|cM~-R1}F>22Q}qx`MKjOE;VfMy|X?22xS=354-^l{!)fq zqEZL4@!72P#_OsTJ1!r|DZ4_tF)W=4@yrbgRt~&oxqzXAYvE?=Szq%20^97j#dA5l zFw=87G*Z`IuCHg)c!Xx8s`+>!S;b9Lpq_K{BA*>E34$5ci&4t&s?tR8Wjl&2pK`Pn zN8zH}hxXmu9~xll3noEyPrD4*@CoR~%XS-KvBrK|jk&7~N~5R(e{y-KL6^F&h_B-; zP-BG3fnIj#mIKWZ!6`1JcW3u51TajayR+*~qq7>L-tPXUr}97R9Zt{hM$DUCd?tf~91J@j79XDgGc9Lc zdR49BC=F~02Xoxmp=dydks9B%5rUw?ls*q17qTndlzCmGz*PBbGOu5WWgX^)7v$BM z_e6Ig^0Fs}GzIW%Y9_ZnrTL!MCc$e>f4h%wOZyKW?mp~`Caz!_Tte(|QIX>X)NU_` zM2Vi2>gRWxUFXWU4bU7osFZQ(Q(6%kWT1xe)C7d^(&mGDn*BzjUsJKxqY%GOxZr>%>m1Xyr2;Dz-9n;-qvyAGmu2nU@ktnmVAEK|o2YA)r~x+lTIcr$BBK<9j+K(d*eC<7`PY+^H^+t@8>zn|gH-J8?Rv$=E&gzb?CmX8 zgX*SQhu!UuqWYtdX3*W)-MhsEp!?k#WB_6n=IC+{Eg_!5Y%!b(m!@&eEY+(9XY_5B zEjR02qaVB-O(TtRAea%z1;LvcN@JIy4&Vo z%Q`;+PFq-inpV=5W*?|9zPh_zRIM$(@+iVOiI5Ok8BAp;W^oW@oFPW?Ghe_WXiB%(3SX1BSujlHZGxr1`Wo0>tV>IJ~+>#M&2 z;(XW4L;umex=JhMJ`k=Nba&+Tzn3rpp*OX!{W|82VfoydNp1+imd*TySW!) zD)Lu%V2?t=JuL%QzPWn@a4k^3=FQ!&fV$k?4p-e{?DGa(i_*TWG{ z$`*hrV(-E%OoZMy=6rkR6(Dk6a|8vL5z4S1#lt!J%IZ91Vgzp5VOq80;bnFR(g@>; z^))y3fWk!KHD}?NB>1TFPUIOE$>U%d9i~mHLp`~n7NrYH`v_#HNgykafJDu$Q;0SpRMY!7)ir^1mzyM@lsN|Ea%Oy3<;KQCK!Rw}>Kx4YHLrlr@F# zIF1khQ^99zHDQb)%rh3j8c?-n{?f7oAa@x^;j)Y$+TaOpZji=F*1QWmzkKw(_OZ6) zDaS(bl`;&L|$HoxiI==U?QdJRT;&EbF{g?4{TF9^*&PDc&XRz!)7f zM&)Zkovcg6p*VHF6Gho~b#>MD!MH(hg^F^3BO(p+02z$^xNa|8m^6U$yi{-_Cz=^zf<0XIEsZWfM9XY7iw>yuKo4{}Co{TfeZ+&))HkSPd9 zhJq!0dnRQc6V+1mQw2l{eg*v;gP^sNP6f?Fi08vC0>8M|g$EF8o%kg+w0plv8&W&u z&BCrvte#v1Y?qqS1gX*-=i)+Mnpx<~z8v_{GB+G25~dOm2%|VLuqFzsorf(jzy%pZ ze#cjwyltLl@zn8z8mTat0)x0GW3x{+aoC&p(7Y%<5U)9M8{;LRl6#Bng_uJWt*CT( z&*ll3^~an!ikN`y`nAbi*3g;pmhW0DsufSxS|=)Ng4v-w^PaI>7|cpQP%dwR(h?1@ zU(^lnYFEn)7kWNKe9weYhY`iA^Sr*UX_(^d0qemX;(R#Bp-3wjsVjF+*tK*&Emr{MSdoO#8)T0q@d0U!9U)%?&YdQH-c4zydjB*{O(t)-z63>tKMPKWZeGy-(L@3AIynrZQ`EfNpTN65|2br4cu3CGgRO9x3 zBl^f`tWT0BklT;H)(?4o&f-G1N2t42+q!;zj=}(|@KF&mcW<8l^FKT4b_MNK1nE`M zI(59Tf2x@^dx_@GSZAXwKG7sp=iQvtO)@+lVRi=h}5zR2fH-~{^- zJVnOfgaGWcbooj^fc|}yOrS`G6II`bkG1b0fJSpfe;he^TuPaf$^Xp>+Bgmo{A2&1 z8b>|RgwJ~dTjj(nEt&nR)?SNi31X(@4Z)LoqDQc&$BII!5YR&sB2U{=fyusjiMM{_ zE366Ri>7aFcPVyy*m{`{C}(=!1_| zs~;wYHb4*;aE>;{t5kwut)h`Pp`$P?pVR4C<#cR5mfGhjcCJYwe$|;{Gu_0nel$2b z=d{TqDMND*%VdHtbE}=%?s?7WC@6OyZo{&LcVS_H83!K?SbYf6tnw+aUTg5Ma2Zi% z;N=1dt0MQHb|F`9mD07mkm)kTVp(F5CAx*yDUf-~gyx#(*sSi-*noGcflPFvVE7{+ z(*+W?$v07;5M>gCP#4^#T%!{Xy%Jp0Eg zJ1xzf)ob2Hv3ydT$hJ4_c}OP!nUa1jX|_U z?lP2hE=Xu+wy`hAQHMz2L77 zgFZJMzBtb00JD~FwnQ4+#7%KBQi;x1QGa*WIvAe8`m{p_rsT3Z$ijUPbbO3jAQxvc z$%5fLln^BnLo`^TB)aVkA$vkleWKs!v_k1~dUhxWLt<6P%z8*lIDMd76utfQPAYhJ z+-&>cKwm!m_RELQEIRIo#@g-RSa)eMHo8Xz8(n_W;S|=mEU?wnaprO!nWbA=8(E}0 z)-GQMhb=)09>kA2Br`3h>0RqB`NMHU0Do5JY~mv$|I0qpNvoEkONrUEbU4QQqqN{P6Ja-P<2}0{A-~W7n_q z-yVDSW2a@gU(rk2HiV%27>dpN?@fg5c3YzRK-XP>B7a~1@%oP= zH4H(Y=eO+*O}Pz5O?^O8KkzpH^&kK6`@b9g1M+sD)=PWT&eHoCV|#mhe{WCxVSBs# z=wTOrZg=G9mb-#B3$WM^Ymgu(l@h0EJWqyBLD)%)jbq7+Ae&~e3fHud^ zP_XVnry!l+OD&lgnFkp7wwS4uMU+9QgP*dl!g9=N4=*C{xL;m42JC!j#%tLGPLLW` zMe`{=*oqXDGxB$KaywzvQZ5+<`L2RphLR6>H_86rm3;qF&e#kIe;uo=uWy}XsR8FH z1C>_}eu9gu;F=z`Mudw`Q+l!BPMKDNRb`NM>p+g8|kaao;zn>k(hE`7HhhRFN zQm*qflf(CTU&o9vqW>ZqgUi68Z(kV7X|_{JuaTNz$se9Dy&J4VFoyxr8El?GT4Zo- z%@(0H@EyH6ej$c&2&vlR5m*AA!XI1?Py3+_!V3Rr?3u2)l7JZ1wP`e?+Reic>Mct0HZp%{fzrxL6!xKU$H<0y2%DNeHcDKt_?Wz2L6a7I&lN;`> zWpu4fQ1xq3$|6)rt7>YI;o}zMI>8ui=nn5#6j(-C+I28*qC`3i!3`FR4U6eK%z{~{ zL>NS>e6k*Wh?L}tf`G{u6hsq-;X-HzP$qFY2qMyM=&1uMRt>X0y+_3Q5e_t=XrU+l z_)zq_{fblXpqzq(M9KF>>aDqadAyazPKL ze0x2MgHLGL#7LixIn`=n&_%geP>eiD8y9rQ|(M4Z)+dC89-|< z6(6W|MnR^rbk+@!r-$i(NNgBpRyHQ&Vvx`V@g9GMrxH$ef$ zP*(EHp>ftd-H4IBqhbxNvuo+>0CV(~l_-OUcw|F9F7T+p-{1^!VY?bB*nX{oOKL6F zyDPlN6;W~%d8M2-2rT&(y`fWL!MYII!8mE=mmp+lQGJVP42f zE)Wk@dDB@OjdBq4qZNmsCz)V!k&##vm`jT)x22rU43+poLNmgmblp}_sdy4kdSYXu zvJLTz*huN;n%ZD)^<;$Il5`l8=Z21APZbyjGbPj|JUm0mDiG0=AVWt>*j59`e#!x` zoWf<@Y2ocM7#`DLak9L4Bj0fG)^`k71951e0Z~BJk>Q5>8R6!AM5y~8(YW4c27?^D z&>w*IlK&B2mc5TgGE?3MiJGVnGw&m^0Qi@Aoa$5e4)C3>DtjpC?$I;H7?-N;~&9=8%t0BvWg`^12iVyN<%|REt_yKIsSXFbfCreXcbGN+X^^5 zm0@@s=%QTJ)(rOzPP@*aT|yHs?>T}x3*Cr=tm5{lJHJ{b!nO(nD1!s`B09Q_3mHBZ zk_$3dD{_I^n)UeIa#RV_`iL?Ub+^!gt)-Dh?M7EoGNf~gc*`&>M+ACON~)#)04^eo z09@GTQ-~=WgV^E_x^iqrtDr;hd{oMV6Y-u;nvN4ftUcbOW8w0WL0ZQk?b@fI;_2PT zECu8K7M3IBTL1&l`7tAtwd;K@d~MfTw_k^;aAYe0hR;*BVFilGioCZxKgt}GPVb=}i&oi%Y%G{`v#qsloFuQ$#@+DpA%uomm+St1?qXflg2pI;<1 zJCJs%HLPYlu1O)lf{E!&4pn-?#bS@LoWoej(hX!Hph@-my%?8lIj0ng$$v-LBJ^@< z(zFU>wL9Fcc*_wSmRua^3R2io^fnagw!}_L>{bw?D|Wslk zo=ImwQN4k|O)KDFOt6NZH5U9!@nu@Iw)AE7bn=UWZ{+DB8eSxE6wgzK`6*d#1UiVm zB8}8wKADjE9_xbu{LQAyH{*b;WdVf=f*~zYgeiY;Xm|q$510#xM5p5#oUp=p_}<-d z3d&)NFpg(!Oq_)0vpI{%uZNsZ!EkX&3IC+HK=vF_I`u+9=k4~x_OAJm!#aq0kLpel z4XESlPpgyWr8ApZIm4hn5Pc z&DVfzT5PcT@^zynK7s3IPweg3a2}Vjy$(*>MvGmx`g=PRC<6m&ZgtbVQZiDowc-lv z%7&EUN?KMfi7<72HELJiowL6H`8z{P+>lWmhcdEffr(iwtR`={lP{gpU&2dNJk~%^ z-aZ&FHaty#1edar`rrnoJ;49FfcqK+@lT(yx%i9dUibR$7`Yzi z=16ygfBK{cY`eFc>pBn|DOmtu?;N$=e*o=WUkRM<_NGwV{VClDN&t{YYT*QoQ}2it#A*qyoQ`Ma~Qb-%7cq5#IUbcHD& zwBW7#G@eHp&lv<5ewb2`u30uu(A-~;YK9089&jG|-h&6C-`(!F#Sx@TK~D-wULB;y zdAy6-!Or%!RRlQB@2F0O<`03L9a}5A;t=ozmz}72>Dlb%j4V1%u0*~&S&Pxcfo?e3 zq$d>A;1ZlQ5p5k)?Ytt5v(M3+7hXP{shrIKo+gY1LS{z#o8ogozYS#uhtw8XUTq}Z z14@PYG@ef5NE|Ox2+PK*U}@jj4otAukeVUz`b;w8v`wx<&BizgRR?C)f$K&min9(z zGBjGEsgfiwx}7*Kdxj8Vh!^Zp=+{Ef45wKLjbi(IpL+8HS_ClI7fHIv_tpD zF5P`lCtKpOyVvfn$2o|8518Q_ZBMLl)vp&R>?3>wsiJ|d%U1rtOIYhOi-(tl)S64K z-#0t)SXjo7T+MKH;Esotg{`8EH0(p<+A* zdKn)kW3NIFyG%}JwJWv6$J6U*P;8uN*lMKNq}`|`;da|5{DB9tS)#ClhB&70ai57T zv>ZsV9Y9e)2`Nc+8n!6SlpNJx>;buyOU#!909I@?LsmJ4r%5uwqMb8Zh;*JL@dUIq zvQj`H21C6jq?ItKv%*CSyUZhq1_E2L-xvHP(oJKG)n1^dMJz2JW->kke?8C1$bA@;xyBH z%VdCYXmZf*b{#%bA7&~EFz0ue(Ry{eLj=6py^K%~+DEm?-@4bEPQ7liO zG&ZKAJe|tOgdQB_bgD5Jq&PUFB*{;W&}urrw?VYT^Q_t3-gfe*v5DY9Mv)3RfRb@| zN*_AMIXAQ8(2Py0{M@JWO^AM~86`5C%9`tENjwcwWo*LZc{mPi&RmjrW^bBJ zIl$K~ohLvW7W?{{7WeT)CIiq!hQQV6#xhW2c&n)g+VY-L41(zeD9DML!o!627YWGG zAb`46tDIY(^dPxdu(IQe_|qsb;!wl`u)KjmJi7>@39bz+W6_euqcpAhquJDavf0iq zRMc$dH5w?z7Gu_H9E6s^VgWXNCVo*F(Vy61t;{9AvXF3 zPWPf7ZB;7gMY8aC&5Ew6p<&*$`eaz>`~H*<>;nrGkKp$e%96&O`q0}QxR067LEKFg zxY2@w0P@osWJcib3pvf{boQFIW}QL7?dJm&`na8)NoQLLhK8OLK%%ZaQgo9KkIPn6G>X=RK9m+!Y?7?0MD&V zPUzASIgW4mP^ zF_0g{p&%1b8*9X?Ch$DGf|McD6Q6Vj3Vh=g*CpH8qdy#z-^DQm`h%=!z|2nvGC32U zt{as-zLkmTLFkva9mtPx2f}~Q_H-P_9^~Sy$r(A!GUd97h(&0s%!1FFW z{!3@;qXoY9fz-%uMsj7@9S?pMhvL(|nfK|S*l^G$cjiO-EB772 zjt4)N4Q=YEGgafk&wk?AZxS^Y54w&trX+SfaVky?K_7I_#97O0G3asMoySO!2rSD^ zkDW6NMC;|CTsuIntCte9H=69-+B=zNQSi>z=^80WkwoAs3%Sze(IunDq3{RnCL3Z# zPme8OT>8RLTyK`0VDH>+e4ycJd#biqkdL<+R;ypEX+ax`XfVHg3g$6lK)(zr(|# zARdI+E0GvL=ABLPNdTom2kf>4P#S)vLEzXal0!$PSl)*i9B@h&`kclpr((!gfAqwH zbVl&{oCGQwfpZNiI_)(V5Qn+J3KryPjy@}_XMy0wPnPXOXP5cQw#pW@8?qA2t#+zA zi%J$l1}l7imiwg0e%{~JteER&8ME+(%ckC!WoKF$^Lha~Su9k0(iYu^+oZ;#(G(^8 zhO?p@6b}R*M-E6QXsN`f#Jfw_(@7r~y7a@T3A?<9axx5h)4l7Tn!wI`8t_YzY37G(QZ%zp&Z@yp<}#5{rgYUhH_pgJ!NKiHW@4&jgnoKSpe~KG z4BSpWGd-??Ay%`prWd$X0c+X1d@Lfxck=|M4diKQ2)ZBIIir{@ARIy!<8{=i-E^xf zF}yez$<@pxH&nGj;&yYVHGa8+-wt|Wr||6+k&G>XOu#0n=%~u>oE7AJnTpL&$}~ey z8SHfQ5aN@;w`Fi!rXBYwM9gez6{YjUctS@u34|?`8KsI#+F{~5?PTkaTn;nm!d);4 zEVIb2v1qz2-1n2rZAPC|t!~#>PX|453U0TkwRu`=qc8jXxX8x7{-Ez_ghSH&aEUdD zWqO{`5W2X$xB}%%`>6&8#9Hu};;aRz02;fX8L=O+%K*zUXv&rtpiynm4&$K=)l&*H zY|70dX6|siI2>|b9;?a;6pazIHaq^>q0TF_&S} zcCKBmR!O^^x^~O1as7NKoIP(xqcj(%R}zy4#`DmaE&Xu3JC>2)8J>du?of2kx3{-* za&Q`iAqA)5w%xDGtP+S%P}Q|ndas74ajBv0D% zJ%`xVf#iv;32_-zLyR@xIy74XnhCfL&X&&A99xWfsc_M+vK+t2Qk{rG!(>A;XI==f zm}e4y2&NKVMMQV!K)ejTZHpJ+!_Oy`RYEx2pMii%tlwSFe8uaI9hjw}4yD0_{Ur)@2ZG+w54ZGDaB433S}hno@#|6=nfCD znLnenhl*EKKsyZR_o;wgGPqjLYq)J(1z>0~MF}YT$lW>tX|kN2c{0;PHrXT>xelPo zFh$qw`KdJ4r02%eS2!N+*E$~UIgUqt9<0Bbw~5Ze6wW98K1f}rzW>q z@MkhppLMyP;k%}~68OvNtAou;`jAn%siP+wk-BO)5AXC|x>*M7bL?|ni5e0{^0?Ql zZh1tqZuOzT&DTB>eRLrGtgHW={AJY@IfbvW{guLw7E-+YOqqd`_RfNiJto=&37H6Ad3wM>MB?I-jZJ zsnfSu@EqNw1IS%~X0Fr=(ho*_g9b-#h%M5BD^=MWjo|BX(?QS5w3f&ZZ@+U~sE;U4 z*#Lb&g1`EfVXBlU01CEBreLN|fgZpcmaCF@KDp3t7Is_&a^5$#^xI22ZuA^HBA-tK zN-bs^qo-tAIQGnzez`c#5+$d;8<`8O4O;-~F;>S^`kPwAYQ z&})ulCOymmkG7fyS+fD(HCh6jSj@@|l_`#-U9!!b>&%DTMZ5OLy0HrYkO-TG${JG^7NPl#TX$I2>n(KRd5Lp?J|=+vGGrz;Fs$SC;r({8F&Pwbh7~o zHRI%c`lkk=l!s-$->B9sKtgMWBhG|VCa+gG<$b&acCpNpBO;us+5T+)q2hpaMbHEywDjUk0B~=9OzN1{- z$(nRxX#Vy?-JFDrbaXn&KTV1_eKdvU?HyM-C40J!SLEn8l_Y&zfs|4|VT8rdWTET7 zdj0JA`LpNWzWctfqRSwGk}MINxe59(n|O$RN}0m@><~ShDaq+MITNZ=57(wAD}#xi z5Ro4fVWtY_BHjzqU>bn4C(OkUYuxOc%87N5(2x+tTk-AV|4ifrEt?L^G|T8`9@Cxd z*B2@bV}d>g=jJa*;4s(S*{ypEM8Z?CSMYzwBu#Uj^w}=k;W&=_IvcG+ZlaBuC8q-B zR}mYG0hxnJL^D%dfAZby*J5{P?_p2mr_$ZoJ*%Drr@Mi!ruz9Ti9ufy0r}84ncwv6 zmN5`0oV@gUUQ~}39G_&gz?l^_OqYpG<&mo(91UeM!tBboc7a`mQMTM7nq|xqkf#u2 z=K86DRU)B_=9-<|-CDK@G)b$NP+eojW4%sN;O{+85bd)B+6uFUMAXlK4H>Uq_S2PrX_b1`LZ5dYNCeDni#p2x-d_Q8Vr0~67uzyslYSM6N2UmWSs^d!5C%P4ZDMPBtE^3xqhM%>U`ST)()ch z>xwa7+YmUJPpziMIntp~9MH4S4tGF2e#^zIqfW6Qcs3(9K4d?QR^L041_~hY?YNyA zUGtVWvcGbr5GT7K_`H=em*9M`I)>QMAPleSs7OgJi+TY@1z@EQ+7;|vuJ9R#VWL{C zOi%7fPc+9-uS~r%TH2=fwWqT=!q!xN(}UjT@!?xi<36hen#XK*SFkbWx@@oC1;4wY z!Li$I8-I{x&xyP!q#D94xWOuNW91h{jdGpQ(bKzcxaM<^#GiM`ameN;c68~9?Uii% ze($OW=$bC{qYYSU)$}S(!qF;klDFmvjm7HgPe|7-KQ+0{>T9X|4x=7z;3W$* zh-N(0vCUO)5+;AyO3#J)PT$4x%5PMr)3-ADRYZm+*XlCEpj_md+lmTu5e*l*Bw7i- z+>^L?H4npeWIeVwbqm()2b22@i)~k#>PM}(zKCL-L;z?vUSg+~l_8(E&>G-9pARt0 z*U3AL!n$kkc3r{-CA&Tk;j=S@L0SCri?{`!xRY4MGR0COH#<(qjrX%E6EtLo zG~xXNo$V(VxmuDshjI`(9?Is~`7`n#O`-X4b>8D1)q*YGsb(Y23X+BOQNse1!dc8qFI$a24B>ET`>LQ|_a--->tNLci5c zz(Tk6k6zn%9o^pcT7%UKeLMg0pDMgu>-#P9oV?o&*7Ww%pPcwGLxOU;4z?+-gO3Uw}_qOt6i-I@a!$LhtvtIUU zwFYb0PUAJqP^(-;??a9A?xHL6!)kZV>dU6g1-kG;bt4BHI*^EjaUi zn9WV}CbpBnb&S;2@kJ0V+*Z7ZrH)bhlfT1*I6bGe%GLrO%K2?9@2i8~fkzp}vT&~; zj{Yu_2oo*aB7yzJ6@A#~Q@T@1rpO=W<5v~BwT;jZ%P9?HynRYu3ClcV%qGX_wZ+j` zr%2S}!b2;KMcGU7Z8_&&+M4yTo}|k4Kbc6?`*7e#kfV)M2dD z)-Q8c!r0@o9Nk=kaaFXTE*L2@9`UXPX4EaRHt?`!zZP;d=lX4l#4JL9++|<}iYg)p z;J=XCr3T2=+wH|zr~o76a93R8Y&mIFcU`*tIfS-w=W7ClQoJ;^dKavz_ywca?aXnIaE!QizL4CiBgz8 zPoY(uHFREe*60QWu|Zh1jtcjoB(W@z#8;7xZYrNx#f(nYm=2{eUp@z@rYGPFHB!1# zVFe@kAoI*nk`m#dkP=}`jv)SVXZ%`<3WV-AO(){WaFj0T0io@b=4vTH*$<}RG6Ul3 z$lH$aQ5y@sARB~1iW!I;xJPeZaNQRv^w(JZqtxl83?Y3SLiRP1gt@b>$|Z(DeRE=b zi?t|!jIJ;zE#WyZ16ogZI^lCQiePI8(598 zstza5fx(V(tml|NXOk$5Zbm^w6$ClS^*nP?Gl~OaSm492mR2+j(r3BRVRDXlIZSXZ zgH4(xrn1OF9KAYzAyhh)GsR_M5;cu4m*~lb#E>xG*^eh&7~!d|aFI3}Kh3wdyWgJf zP4Uvfe{D~5x8FBZ4`l-zm4sxtr7@hU0Od5RL?+FW<+U+RpoS+tUPwsx;yAfAaa;KU z!UjI~Ic<4=(=V%GR1I6CQfIS8S5@%*-l8+bxW-|;UP}aR)dndTL=z1K@Pg7aExOa= z&7$3I_ibNROhW0D3xh)NY<&Z1;8H z{z!Yq6A8v^Rfg$;t#LRy?W&dyGcg>W8o(5V&bb3@z56%`CQve$!KE1%+{MDn;{fV1 zfD<{^`G6tnZ-dKr3(uoXQ_I<@KKG`9w2)e*V#LIiOquSc%n%Ey%q68RsD-q26R(nI zc9E)R*4Bj0lM;@eBoTl9;=|7V*Ytl~PT)eOudgDSLW8~s7M-T#(EAl-OL8IZqTJs zYh`18bMh7wFg)fAhC+xU7P<{x6<0>5#mOCdf&ttJziu8inM}Gpandak%HpTnSnu(> zCtSBBDu`E#VUdVyB6&yTY>AVdDui1gop*ZTWM?(v>ely7=AEUauE4yG=xZWxvgO^` zDzwDO?(+HIZ@WElvb*k@=zgDLb#~WSp^6!;wpMFS>V8(OB~JF%nJ50X*ApjuH(x^y z;d8C#-i=nYVy4BlH6RT%_Y;EZenQaQPly`kle=LDM(`Fidw4T);cpLn;^g67u!x5B zIhp0*Eg7bQ0-u3(47GlH%+wMm`?n=0{6B zsTsUYsc_HgP{7P0xzTIJJv77oQjhcF>V`gPOG-JCskO>9>Q<}2ZwqP5H`nbVb0&##o@YMi=F#wGcHI2n)3v^B*neRG_);R`oaj?9{kc0*S!g}>9KrAxUq zv&>RsX1LyL4`nvIKvPUysOR44h`*x2&Dya`>YSDs6<;SUue7#KuH;*8`|0hIR@?`D z4WIdTX5g-4p!{aB<~@>C913|QgUqf^g{`-bDdS8Xd$2*pSK#I{Scrf6gs|H4V07It zn&4bx8X>bR4GX`g!KTrsuT!4@TDCY3vz+_Ag-@>3%J&)qPYm3BP$)}@K1&(hI&jRT z#jF$-DAv4A)A>|aZ812q$EbaaK@s4ZwPXrdXqaQP=^1lwfF+*9P{J+-Lim6&OvM0i z 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 literal 0 HcmV?d00001 diff --git a/tests/registry/npm/@types/node/node-22.5.4.tgz b/tests/registry/npm/@types/node/node-22.5.4.tgz deleted file mode 100644 index 2a7f1911a03e1d967a7923dbe6b3e528733c8ca9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 404125 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⩔MQs+|&?hG1)5l_)mfc$p;jbHGyQ5w#2 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

    B2sekB#ENr0$6R9Ca1tM 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 k3R-mU9mAF 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%0DOG)9d&lQ5r?MGqLdf_FG*U<;zsdCuukr@I`W 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 diff --git a/tests/registry/npm/undici-types/undici-types-6.20.0.tgz b/tests/registry/npm/undici-types/undici-types-6.20.0.tgz new file mode 100644 index 0000000000000000000000000000000000000000..a5cf2d685eb9ad8686be50289cdb806fa011cf88 GIT binary patch literal 20933 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 literal 0 HcmV?d00001 diff --git a/tests/registry/npm/unique-filename/registry.json b/tests/registry/npm/unique-filename/registry.json index 7821fb59ca..d3d2b07ed7 100644 --- a/tests/registry/npm/unique-filename/registry.json +++ b/tests/registry/npm/unique-filename/registry.json @@ -77,6 +77,5 @@ "homepage": "https://github.com/iarna/unique-filename", "bugs": { "url": "https://github.com/iarna/unique-filename/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/unique-slug/registry.json b/tests/registry/npm/unique-slug/registry.json index b32216a694..25092bd591 100644 --- a/tests/registry/npm/unique-slug/registry.json +++ b/tests/registry/npm/unique-slug/registry.json @@ -77,6 +77,5 @@ "homepage": "https://github.com/npm/unique-slug#readme", "bugs": { "url": "https://github.com/npm/unique-slug/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/universalify/registry.json b/tests/registry/npm/universalify/registry.json index c26a344e30..006e13da44 100644 --- a/tests/registry/npm/universalify/registry.json +++ b/tests/registry/npm/universalify/registry.json @@ -61,6 +61,5 @@ "bugs": { "url": "https://github.com/RyanZim/universalify/issues" }, - "license": "MIT", - "readmeFilename": "README.md" + "license": "MIT" } diff --git a/tests/registry/npm/uri-js/registry.json b/tests/registry/npm/uri-js/registry.json index 8f1d688e54..77914746ea 100644 --- a/tests/registry/npm/uri-js/registry.json +++ b/tests/registry/npm/uri-js/registry.json @@ -77,6 +77,5 @@ "bugs": { "url": "https://github.com/garycourt/uri-js/issues" }, - "license": "BSD-2-Clause", - "readmeFilename": "README.md" + "license": "BSD-2-Clause" } diff --git a/tests/registry/npm/utf-8-validate/registry.json b/tests/registry/npm/utf-8-validate/registry.json index 43dc313781..eb74315b0a 100644 --- a/tests/registry/npm/utf-8-validate/registry.json +++ b/tests/registry/npm/utf-8-validate/registry.json @@ -70,6 +70,5 @@ "type": "git", "url": "git+https://github.com/websockets/utf-8-validate.git" }, - "description": "Check if a buffer contains valid UTF-8", - "readmeFilename": "README.md" + "description": "Check if a buffer contains valid UTF-8" } diff --git a/tests/registry/npm/v8flags/registry.json b/tests/registry/npm/v8flags/registry.json index 66e1dd52eb..af79ddfd66 100644 --- a/tests/registry/npm/v8flags/registry.json +++ b/tests/registry/npm/v8flags/registry.json @@ -79,6 +79,5 @@ "bugs": { "url": "https://github.com/gulpjs/v8flags/issues" }, - "readmeFilename": "README.md", "license": "MIT" } diff --git a/tests/registry/npm/vue/registry.json b/tests/registry/npm/vue/registry.json index 827538ed34..ea0808a034 100644 --- a/tests/registry/npm/vue/registry.json +++ b/tests/registry/npm/vue/registry.json @@ -89,7 +89,6 @@ "type": "git", "url": "git+https://github.com/vuejs/core.git" }, - "readmeFilename": "README.md", "homepage": "https://github.com/vuejs/core/tree/main/packages/vue#readme", "bugs": { "url": "https://github.com/vuejs/core/issues" diff --git a/tests/registry/npm/which-module/registry.json b/tests/registry/npm/which-module/registry.json index 762e068c44..46f42b46e4 100644 --- a/tests/registry/npm/which-module/registry.json +++ b/tests/registry/npm/which-module/registry.json @@ -61,6 +61,5 @@ "bugs": { "url": "https://github.com/nexdrew/which-module/issues" }, - "license": "ISC", - "readmeFilename": "README.md" + "license": "ISC" } diff --git a/tests/registry/npm/which/registry.json b/tests/registry/npm/which/registry.json index 855222fd3c..fdd943d578 100644 --- a/tests/registry/npm/which/registry.json +++ b/tests/registry/npm/which/registry.json @@ -153,6 +153,5 @@ "homepage": "https://github.com/npm/node-which#readme", "bugs": { "url": "https://github.com/npm/node-which/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/wrap-ansi/registry.json b/tests/registry/npm/wrap-ansi/registry.json index f64be8385a..53cc2cb2f4 100644 --- a/tests/registry/npm/wrap-ansi/registry.json +++ b/tests/registry/npm/wrap-ansi/registry.json @@ -178,6 +178,5 @@ "bugs": { "url": "https://github.com/chalk/wrap-ansi/issues" }, - "license": "MIT", - "readmeFilename": "readme.md" + "license": "MIT" } diff --git a/tests/registry/npm/ws/registry.json b/tests/registry/npm/ws/registry.json index 1738dc57dd..39ab8dab67 100644 --- a/tests/registry/npm/ws/registry.json +++ b/tests/registry/npm/ws/registry.json @@ -92,6 +92,5 @@ "homepage": "https://github.com/websockets/ws", "bugs": { "url": "https://github.com/websockets/ws/issues" - }, - "readmeFilename": "README.md" + } } diff --git a/tests/registry/npm/y18n/registry.json b/tests/registry/npm/y18n/registry.json index dcb5f0f07a..55e0fdd589 100644 --- a/tests/registry/npm/y18n/registry.json +++ b/tests/registry/npm/y18n/registry.json @@ -67,6 +67,5 @@ "bugs": { "url": "https://github.com/yargs/y18n/issues" }, - "license": "ISC", - "readmeFilename": "README.md" + "license": "ISC" } diff --git a/tests/registry/npm/yallist/registry.json b/tests/registry/npm/yallist/registry.json index 02e10e5ae3..6839793164 100644 --- a/tests/registry/npm/yallist/registry.json +++ b/tests/registry/npm/yallist/registry.json @@ -63,6 +63,5 @@ "bugs": { "url": "https://github.com/isaacs/yallist/issues" }, - "license": "BlueOak-1.0.0", - "readmeFilename": "README.md" + "license": "BlueOak-1.0.0" } diff --git a/tests/registry/npm/yargs-parser/registry.json b/tests/registry/npm/yargs-parser/registry.json index cf10f5e055..603e40a6ce 100644 --- a/tests/registry/npm/yargs-parser/registry.json +++ b/tests/registry/npm/yargs-parser/registry.json @@ -60,7 +60,6 @@ "email": "ben@npmjs.com" }, "license": "ISC", - "readmeFilename": "README.md", "homepage": "https://github.com/yargs/yargs-parser#readme", "repository": { "type": "git", diff --git a/tests/registry/npm/yargs/registry.json b/tests/registry/npm/yargs/registry.json index 1d9797fd32..b42df8eb4f 100644 --- a/tests/registry/npm/yargs/registry.json +++ b/tests/registry/npm/yargs/registry.json @@ -95,7 +95,6 @@ "type": "git", "url": "git+https://github.com/yargs/yargs.git" }, - "readmeFilename": "README.md", "homepage": "https://yargs.js.org/", "bugs": { "url": "https://github.com/yargs/yargs/issues" diff --git a/tests/specs/check/check_node_builtin_modules/mod.ts.out b/tests/specs/check/check_node_builtin_modules/mod.ts.out index 638dd640d4..4e14cdad44 100644 --- a/tests/specs/check/check_node_builtin_modules/mod.ts.out +++ b/tests/specs/check/check_node_builtin_modules/mod.ts.out @@ -1,14 +1,18 @@ TS2769 [ERROR]: No overload matches this call. - [WILDCARD] + Overload 1 of 3, '(path: PathOrFileDescriptor, options?: { encoding?: null | undefined; flag?: string | undefined; } | null | undefined): Buffer', gave the following error. + Type '123' has no properties in common with type '{ encoding?: null | undefined; flag?: string | undefined; }'. + Overload 2 of 3, '(path: PathOrFileDescriptor, options: { encoding: BufferEncoding; flag?: string | undefined; } | BufferEncoding): string', gave the following error. + Argument of type '123' is not assignable to parameter of type '{ encoding: BufferEncoding; flag?: string | undefined; } | BufferEncoding'. + Overload 3 of 3, '(path: PathOrFileDescriptor, options?: BufferEncoding | (ObjectEncodingOptions & { flag?: string | undefined; }) | null | undefined): string | Buffer<...>', gave the following error. + Argument of type '123' is not assignable to parameter of type 'BufferEncoding | (ObjectEncodingOptions & { flag?: string | undefined; }) | null | undefined'. const _data = fs.readFileSync("./node_builtin.js", 123); ~~~ - at file:///[WILDCARD]/mod.ts:2:52 + at file:///[WILDLINE]/mod.ts:2:52 -TS2322 [ERROR]: Type 'string[]' is not assignable to type 'number[]'. - Type 'string' is not assignable to type 'number'. +TS4104 [ERROR]: The type 'readonly string[]' is 'readonly' and cannot be assigned to the mutable type 'number[]'. const _testString: number[] = builtinModules; ~~~~~~~~~~~ - at file:///[WILDCARD]/mod.ts:9:7 + at file:///[WILDLINE]/mod.ts:9:7 Found 2 errors. diff --git a/tests/specs/npm/compare_globals/main.out b/tests/specs/npm/compare_globals/main.out index 290e9c3b23..f4e08bfd1a 100644 --- a/tests/specs/npm/compare_globals/main.out +++ b/tests/specs/npm/compare_globals/main.out @@ -5,8 +5,8 @@ Download http://localhost:4260/@denotest%2fglobals [UNORDERED_END] [UNORDERED_START] Download http://localhost:4260/@denotest/globals/1.0.0.tgz -Download http://localhost:4260/@types/node/node-22.5.4.tgz -Download http://localhost:4260/undici-types/undici-types-6.19.8.tgz +Download http://localhost:4260/@types/node/node-[WILDLINE].tgz +Download http://localhost:4260/undici-types/undici-types-[WILDLINE].tgz [UNORDERED_END] Check file:///[WILDCARD]/main.ts true diff --git a/tests/specs/publish/bare_node_builtins/bare_node_builtins.out b/tests/specs/publish/bare_node_builtins/bare_node_builtins.out index 6baedd906f..fb1d0361d8 100644 --- a/tests/specs/publish/bare_node_builtins/bare_node_builtins.out +++ b/tests/specs/publish/bare_node_builtins/bare_node_builtins.out @@ -3,8 +3,8 @@ Warning Resolving "url" as "node:url" at file:///[WILDLINE]/mod.ts:1:22. If you [UNORDERED_START] Download http://localhost:4260/@types%2fnode Download http://localhost:4260/undici-types -Download http://localhost:4260/@types/node/node-22.5.4.tgz -Download http://localhost:4260/undici-types/undici-types-6.19.8.tgz +Download http://localhost:4260/@types/node/node-[WILDLINE].tgz +Download http://localhost:4260/undici-types/undici-types-[WILDLINE].tgz [UNORDERED_END] Check file:///[WILDLINE]/mod.ts Checking for slow types in the public API... diff --git a/tests/specs/publish/node_specifier/node_specifier.out b/tests/specs/publish/node_specifier/node_specifier.out index 0ba14043df..ccfb861f31 100644 --- a/tests/specs/publish/node_specifier/node_specifier.out +++ b/tests/specs/publish/node_specifier/node_specifier.out @@ -1,8 +1,8 @@ [UNORDERED_START] Download http://localhost:4260/@types%2fnode Download http://localhost:4260/undici-types -Download http://localhost:4260/@types/node/node-22.5.4.tgz -Download http://localhost:4260/undici-types/undici-types-6.19.8.tgz +Download http://localhost:4260/@types/node/node-[WILDLINE].tgz +Download http://localhost:4260/undici-types/undici-types-[WILDLINE].tgz [UNORDERED_END] Check file:///[WILDCARD]/mod.ts Checking for slow types in the public API... diff --git a/tests/unit/body_test.ts b/tests/unit/body_test.ts index 28a1c697b1..63e702484c 100644 --- a/tests/unit/body_test.ts +++ b/tests/unit/body_test.ts @@ -27,7 +27,7 @@ Deno.test(async function arrayBufferFromByteArrays() { const buffer = new TextEncoder().encode("ahoyhoy8").buffer; for (const type of intArrays) { - const body = buildBody(new type(buffer)); + const body = buildBody(new type(buffer as ArrayBuffer)); const text = new TextDecoder("utf-8").decode(await body.arrayBuffer()); assertEquals(text, "ahoyhoy8"); } diff --git a/tests/unit/fetch_test.ts b/tests/unit/fetch_test.ts index 094b963e19..84d05ddb3c 100644 --- a/tests/unit/fetch_test.ts +++ b/tests/unit/fetch_test.ts @@ -553,7 +553,7 @@ Deno.test( const data = "Hello World"; const response = await fetch("http://localhost:4545/echo_server", { method: "POST", - body: new TextEncoder().encode(data).buffer, + body: new TextEncoder().encode(data).buffer as ArrayBuffer, }); const text = await response.text(); assertEquals(text, data); diff --git a/tests/unit/structured_clone_test.ts b/tests/unit/structured_clone_test.ts index fc5d68e9da..9d52039e32 100644 --- a/tests/unit/structured_clone_test.ts +++ b/tests/unit/structured_clone_test.ts @@ -27,7 +27,10 @@ Deno.test("correct DataCloneError message", () => { assertThrows( () => { const sab = new SharedArrayBuffer(1024); - structuredClone(sab, { transfer: [sab] }); + structuredClone(sab, { + // @ts-expect-error cannot assign SharedArrayBuffer because it's not tranferable + transfer: [sab], + }); }, DOMException, "Value not transferable", diff --git a/tests/unit/url_search_params_test.ts b/tests/unit/url_search_params_test.ts index 9846c7a91c..d72366a1a4 100644 --- a/tests/unit/url_search_params_test.ts +++ b/tests/unit/url_search_params_test.ts @@ -304,7 +304,9 @@ Deno.test(function urlSearchParamsDeletingAppendedMultiple() { // ref: https://github.com/web-platform-tests/wpt/blob/master/url/urlsearchparams-constructor.any.js#L176-L182 Deno.test(function urlSearchParamsCustomSymbolIterator() { const params = new URLSearchParams(); - params[Symbol.iterator] = function* (): IterableIterator<[string, string]> { + params[Symbol.iterator] = function* (): URLSearchParamsIterator< + [string, string] + > { yield ["a", "b"]; }; const params1 = new URLSearchParams((params as unknown) as string[][]); @@ -345,7 +347,7 @@ Deno.test( Deno.test(function urlSearchParamsOverridingEntriesNotChangeForEach() { class CustomSearchParams extends URLSearchParams { - override *entries(): IterableIterator<[string, string]> { + override *entries(): URLSearchParamsIterator<[string, string]> { yield* []; } } diff --git a/tests/unit/version_test.ts b/tests/unit/version_test.ts index fd570fb16d..0733381209 100644 --- a/tests/unit/version_test.ts +++ b/tests/unit/version_test.ts @@ -6,5 +6,5 @@ Deno.test(function version() { const pattern = /^\d+\.\d+\.\d+/; assert(pattern.test(Deno.version.deno)); assert(pattern.test(Deno.version.v8)); - assertEquals(Deno.version.typescript, "5.6.2"); + assertEquals(Deno.version.typescript, "5.7.3"); }); diff --git a/tests/unit_node/_fs/_fs_read_test.ts b/tests/unit_node/_fs/_fs_read_test.ts index 6def1ff71d..aa236d46d1 100644 --- a/tests/unit_node/_fs/_fs_read_test.ts +++ b/tests/unit_node/_fs/_fs_read_test.ts @@ -348,10 +348,11 @@ Deno.test({ for (const offset of offsets) { // test read resetBuffer(); - const buf = new constr( + // deno-lint-ignore no-explicit-any + const buf = new (constr as any)( buffer, innerOffset, - ); + ) as Int8Array | Uint8Array; await readTest( testData, buf, diff --git a/tests/unit_node/_fs/_fs_write_test.ts b/tests/unit_node/_fs/_fs_write_test.ts index 6a5d4c9c26..5ceca16952 100644 --- a/tests/unit_node/_fs/_fs_write_test.ts +++ b/tests/unit_node/_fs/_fs_write_test.ts @@ -117,7 +117,7 @@ Deno.test({ for (const innerOffset of offsets) { for (const offset of offsets) { resetBuffer(); - const buffer = new constr( + const buffer = new (constr as Uint8ArrayConstructor)( arrayBuffer, innerOffset, offset + bytes.length, diff --git a/tests/unit_node/zlib_test.ts b/tests/unit_node/zlib_test.ts index cc8730c546..07e5beed97 100644 --- a/tests/unit_node/zlib_test.ts +++ b/tests/unit_node/zlib_test.ts @@ -76,7 +76,7 @@ Deno.test("brotli compression", { await Promise.all([ promise.promise, - new Promise((r) => stream.on("close", r)), + new Promise((r) => stream.on("close", r)), ]); const content = Deno.readTextFileSync("lorem_ipsum.txt"); diff --git a/tests/util/server/Cargo.toml b/tests/util/server/Cargo.toml index 6e31dd4587..44aebf3499 100644 --- a/tests/util/server/Cargo.toml +++ b/tests/util/server/Cargo.toml @@ -44,6 +44,7 @@ monch.workspace = true once_cell.workspace = true os_pipe.workspace = true parking_lot.workspace = true +percent-encoding.workspace = true pretty_assertions.workspace = true prost.workspace = true regex.workspace = true diff --git a/tests/util/server/src/servers/npm_registry.rs b/tests/util/server/src/servers/npm_registry.rs index c814b83340..df0d3734e3 100644 --- a/tests/util/server/src/servers/npm_registry.rs +++ b/tests/util/server/src/servers/npm_registry.rs @@ -301,9 +301,12 @@ fn replace_default_npm_registry_url_with_test_npm_registry_url( npm_registry: &npm::TestNpmRegistry, package_name: &str, ) -> String { + let package_name = percent_encoding::percent_decode_str(package_name) + .decode_utf8() + .unwrap(); text.replace( &format!("https://registry.npmjs.org/{}/-/", package_name), - &npm_registry.package_url(package_name), + &npm_registry.package_url(&package_name), ) } From 9da6a20e578dd5b275d70d467b7628c32d78cacd Mon Sep 17 00:00:00 2001 From: Nayeem Rahman Date: Sat, 1 Feb 2025 02:53:24 +0000 Subject: [PATCH 11/12] Revert "fix(lsp): silence debug error for 'move to a new file' action (#27780)" (#27903) --- cli/lsp/language_server.rs | 41 ++++++++++++-------------------------- 1 file changed, 13 insertions(+), 28 deletions(-) diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs index 012cdd1e45..3ff69e19f2 100644 --- a/cli/lsp/language_server.rs +++ b/cli/lsp/language_server.rs @@ -1880,7 +1880,7 @@ impl Inner { })?; let asset_or_doc = self.get_asset_or_document(&action_data.specifier)?; let line_index = asset_or_doc.line_index(); - let refactor_edit_info = self + let mut refactor_edit_info = self .ts_server .get_edits_for_refactor( self.snapshot(), @@ -1901,34 +1901,19 @@ impl Inner { )), asset_or_doc.scope().cloned(), ) - .await; - - match refactor_edit_info { - Ok(mut refactor_edit_info) => { - if kind_suffix == ".rewrite.function.returnType" - || kind_suffix == ".move.newFile" - { - refactor_edit_info.edits = - fix_ts_import_changes(&refactor_edit_info.edits, self).map_err( - |err| { - error!("Unable to remap changes: {:#}", err); - LspError::internal_error() - }, - )? - } - code_action.edit = refactor_edit_info.to_workspace_edit(self)?; - } - Err(err) => { - // TODO(nayeemrmn): Investigate cause for - // https://github.com/denoland/deno/issues/27778. Prevent popups for - // this error for now. - if kind_suffix == ".move.newFile" { - lsp_warn!("{:#}", err); - } else { - return Err(err); - } - } + .await?; + if kind_suffix == ".rewrite.function.returnType" + || kind_suffix == ".move.newFile" + { + refactor_edit_info.edits = + fix_ts_import_changes(&refactor_edit_info.edits, self).map_err( + |err| { + error!("Unable to remap changes: {:#}", err); + LspError::internal_error() + }, + )? } + code_action.edit = refactor_edit_info.to_workspace_edit(self)?; code_action } else { // The code action doesn't need to be resolved From 7d196682557ab191ea24cc6c604ff0860ee0506d Mon Sep 17 00:00:00 2001 From: Divy Srivastava Date: Sat, 1 Feb 2025 13:19:53 +0530 Subject: [PATCH 12/12] fix(ext/node): throw RangeError when sqlite INTEGER is too large (#27907) Signed-off-by: Divy Srivastava --- ext/node/ops/sqlite/mod.rs | 3 +++ ext/node/ops/sqlite/statement.rs | 15 ++++++++++----- tests/unit_node/sqlite_test.ts | 10 ++++++++++ 3 files changed, 23 insertions(+), 5 deletions(-) diff --git a/ext/node/ops/sqlite/mod.rs b/ext/node/ops/sqlite/mod.rs index 7a5af66a14..29c246dae5 100644 --- a/ext/node/ops/sqlite/mod.rs +++ b/ext/node/ops/sqlite/mod.rs @@ -38,4 +38,7 @@ pub enum SqliteError { #[class(generic)] #[error("Invalid constructor")] InvalidConstructor, + #[class(range)] + #[error("The value of column {0} is too large to be represented as a JavaScript number: {1}")] + NumberTooLarge(i32, i64), } diff --git a/ext/node/ops/sqlite/statement.rs b/ext/node/ops/sqlite/statement.rs index 8f96d5131a..1fa8ade599 100644 --- a/ext/node/ops/sqlite/statement.rs +++ b/ext/node/ops/sqlite/statement.rs @@ -12,6 +12,9 @@ use serde::Serialize; use super::SqliteError; +// ECMA-262, 15th edition, 21.1.2.6. Number.MAX_SAFE_INTEGER (2^53-1) +const MAX_SAFE_JS_INTEGER: i64 = 9007199254740991; + #[derive(Serialize)] #[serde(rename_all = "camelCase")] pub struct RunStatementResult { @@ -122,17 +125,19 @@ impl StatementSync { &self, index: i32, scope: &mut v8::HandleScope<'a>, - ) -> v8::Local<'a, v8::Value> { + ) -> Result, SqliteError> { // SAFETY: `self.inner` is a valid pointer to a sqlite3_stmt // as it lives as long as the StatementSync instance. unsafe { - match ffi::sqlite3_column_type(self.inner, index) { + Ok(match ffi::sqlite3_column_type(self.inner, index) { ffi::SQLITE_INTEGER => { let value = ffi::sqlite3_column_int64(self.inner, index); if self.use_big_ints.get() { v8::BigInt::new_from_i64(scope, value).into() - } else { + } else if value.abs() <= MAX_SAFE_JS_INTEGER { v8::Integer::new(scope, value as _).into() + } else { + return Err(SqliteError::NumberTooLarge(index, value)); } } ffi::SQLITE_FLOAT => { @@ -162,7 +167,7 @@ impl StatementSync { } ffi::SQLITE_NULL => v8::null(scope).into(), _ => v8::undefined(scope).into(), - } + }) } } @@ -183,7 +188,7 @@ impl StatementSync { let mut values = Vec::with_capacity(num_cols); for (index, name) in iter { - let value = self.column_value(index, scope); + let value = self.column_value(index, scope)?; let name = v8::String::new_from_utf8(scope, name, v8::NewStringType::Normal) .unwrap() diff --git a/tests/unit_node/sqlite_test.ts b/tests/unit_node/sqlite_test.ts index 04522083af..43b6914f3c 100644 --- a/tests/unit_node/sqlite_test.ts +++ b/tests/unit_node/sqlite_test.ts @@ -73,6 +73,16 @@ Deno.test("[node/sqlite] StatementSync read bigints are supported", () => { assertEquals(stmt.get(), { key: 1n, __proto__: null }); }); +Deno.test("[node/sqlite] StatementSync integer too large", () => { + const db = new DatabaseSync(":memory:"); + db.exec("CREATE TABLE data(key INTEGER PRIMARY KEY);"); + db.prepare("INSERT INTO data (key) VALUES (?)").run( + Number.MAX_SAFE_INTEGER + 1, + ); + + assertThrows(() => db.prepare("SELECT * FROM data").get()); +}); + Deno.test("[node/sqlite] StatementSync blob are Uint8Array", () => { const db = new DatabaseSync(":memory:"); const obj = db.prepare("select cast('test' as blob)").all();

    #~V`sPT7P6vz1MP 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

    2. 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 diff --git a/tests/registry/npm/@types/node/node-18.8.2.tgz b/tests/registry/npm/@types/node/node-18.8.2.tgz deleted file mode 100644 index 8afc9d21dfb2996a1e28f71f59d981df5113b9ff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 649087 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%0AlHRv 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�MOjtnjv$oa6-JVkjI3pGR(qK@ao~^#bCs` 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