@coroboros/uri 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,560 @@
+//#region src/parser/index.d.ts
+interface ParsedURI {
+  scheme: string | null;
+  authority: string | null;
+  authorityPunydecoded: string | null;
+  userinfo: string | null;
+  host: string | null;
+  hostPunydecoded: string | null;
+  port: number | string | null;
+  path: string | null;
+  pathqf: string | null;
+  query: string | null;
+  fragment: string | null;
+  href: string | null;
+}
+interface URIComponents {
+  scheme?: string | null;
+  userinfo?: string | null;
+  host?: string | null;
+  port?: number | string | null;
+  path?: string | null;
+  query?: string | null;
+  fragment?: string | null;
+}
+/**
+* @func recomposeURI
+*
+* Recompose an URI from its components with basic URI checking.
+*
+* The empty string is returned if unable to recompose the URI.
+*
+* Rules:
+* 1. scheme is required and must be at least 1 character;
+* 2. path is required and can be empty;
+* 3. if host is present path must be empty or start with /;
+* 4. if host is not present path must not start with //;
+* 5. host, if any, must be at least 3 characters;
+* 6. userinfo will be ignored if empty;
+* 7. port will be ignored if empty or not an integer;
+* 8. query is emitted when defined (a string, including ''); a null
+*    or undefined query is omitted (RFC-3986 §5.3);
+* 9. fragment is emitted when defined (a string, including ''); a null
+*    or undefined fragment is omitted (RFC-3986 §5.3).
+*
+* Support:
+* - IPv4 and IPv6.
+*
+* Note:
+* / is added to any URI with a host and an empty path.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+declare const recomposeURI: (components?: URIComponents) => string;
+/**
+* @func parseURI
+*
+* Parse a string to get URI components.
+*
+* Support:
+* - IPv4 and IPv6 hosts;
+* - Internationalized Domain Name (IDN).
+*
+* Note:
+* - RegExp from RFC-3986 https://tools.ietf.org/html/rfc3986#appendix-B;
+* - scheme and host strings will always be put in lowercase once parsed,
+*   as specified in RFC-3986;
+* - authority and its components will be put at null values if authority
+*   parsed is missing or empty.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+declare const parseURI: (uri: string) => ParsedURI;
+//#endregion
+//#region src/checkers/index.d.ts
+interface CheckedURI extends ParsedURI {
+  valid: true;
+}
+/**
+* @func checkURI
+*
+* Check an URI is valid according to RFC-3986.
+*
+* Rules:
+* 1. scheme is required and cannot be empty;
+* 2. path is required and can be empty;
+* 3. if authority is present path must be empty or start with /;
+* 4. if authority is not present path must not start with //;
+* 5. scheme can only have specific characters:
+*    https://tools.ietf.org/html/rfc3986#section-3.1;
+* 6. if authority is present:
+*    1. host must be a valid IP or domain name;
+*    2. userinfo, if any, can only have specific characters:
+*       https://tools.ietf.org/html/rfc3986#section-3.2.1;
+*    3. port, if any, must be an integer in a specific range.
+* 7. path, query and fragment can only have specific characters:
+*    https://tools.ietf.org/html/rfc3986#section-3.3.
+*/
+declare const checkURI: (uri: string, {
+  sitemap
+}?: {
+  sitemap?: boolean | undefined;
+}) => CheckedURI;
+/**
+* @func checkHttpURL
+*
+* Check an URI is a valid HTTP URL (sitemap URLs supported to create aliases).
+*
+* This function uses checkURI to check URI provided is valid.
+*
+* Rules:
+* 1. scheme must be http or HTTP;
+* 2. authority is required;
+* 3. URL must be less than max length.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const checkHttpURL: (uri: string, {
+  https,
+  web,
+  sitemap
+}?: {
+  https?: boolean | undefined;
+  web?: boolean | undefined;
+  sitemap?: boolean | undefined;
+}) => CheckedURI;
+/**
+* @func checkHttpsURL
+*
+* Check an URI is a valid HTTPS URL.
+*
+* Same behavior than checkHttpURL except scheme must be https or HTTPS.
+*/
+declare const checkHttpsURL: (uri: string) => CheckedURI;
+/**
+* @func checkHttpSitemapURL
+*
+* Check an URI is a valid HTTP URL to be used in an XML sitemap file.
+*
+* This function uses checkHttpURL to check URI provided is a valid HTTP URL.
+*
+* Rules:
+* 1. scheme must be http;
+* 2. authority is required;
+* 3. specific characters must be escaped;
+* 4. can only contain lowercase characters;
+* 5. URL must be less than max length.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const checkHttpSitemapURL: (uri: string) => CheckedURI;
+/**
+* @func checkHttpsSitemapURL
+*
+* Check an URI is a valid HTTPS URL to be used in an XML sitemap file.
+* Same behavior than checkHttpSitemapURL except scheme must be https.
+*/
+declare const checkHttpsSitemapURL: (uri: string) => CheckedURI;
+/**
+* @func checkWebURL
+*
+* Check an URI is a valid HTTP or HTTPS URL.
+*
+* Same behavior than checkHttpURL except scheme can be http/HTTP or https/HTTPS.
+*/
+declare const checkWebURL: (uri: string) => CheckedURI;
+/**
+* @func checkSitemapURL
+*
+* Check an URI is a valid HTTP or HTTPS URL to be used in an XML sitemap file.
+*
+* Same behavior than checkHttpSitemapURL except scheme can be http or https.
+*/
+declare const checkSitemapURL: (uri: string) => CheckedURI;
+//#endregion
+//#region src/decoders/index.d.ts
+/**
+* @func decodeURIComponentString
+*
+* Decode an URI component string with Sitemap's escape codes support.
+*
+* Native function decodeURIComponent could throw and to be consistent with
+* encodeURIComponentString the empty string is returned if unable to decode.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const decodeURIComponentString: (component: string, {
+  sitemap,
+  lowercase
+}?: {
+  sitemap?: boolean | undefined;
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func decodeURIString
+*
+* Decode an URI string according to RFC-3986 with basic checking.
+*
+* Checked:
+* - scheme is required;
+* - path is required, can be empty;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid ip or domain name;
+* - maximum size once encoded for URLs.
+*
+* Support:
+* - IDNs: returns URI with its Punydecoded host (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - if one of userinfo, path, query or fragment component cannot be decoded, it will be ignored;
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to only use with encodeURIString.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const decodeURIString: (uri: string, {
+  web,
+  sitemap,
+  lowercase
+}?: {
+  web?: boolean | undefined;
+  sitemap?: boolean | undefined;
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func decodeWebURL
+*
+* Decode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs.
+*
+* Uses a fixed decodeURI function to be RFC-3986 compliant.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - parseURI prechecked host, will be null if invalid and so does authority.
+*
+* Support:
+* - IDNs: returns URI with its Punydecoded host
+*   (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to use only with encodeWebURL.
+*/
+declare const decodeWebURL: (uri: string, {
+  lowercase
+}?: {
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func decodeSitemapURL
+*
+* Decode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs and sitemap requirements regarding escape codes to decode.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - parseURI prechecked host, will be null if invalid and so does authority.
+*
+* Support:
+* - Sitemap's escape codes;
+* - IDNs: returns URI with its Punydecoded host
+*   (Unicode serialization of the domain), if any;
+* - lower and upper case.
+*
+* Note:
+* - native function decodeURI does not support IDNs and cannot properly work
+*   with encodeURI since the function is based on an outdated standard;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase;
+* - to use only with encodeSitemapURL.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const decodeSitemapURL: (uri: string, {
+  lowercase
+}?: {
+  lowercase?: boolean | undefined;
+}) => string;
+//#endregion
+//#region src/domain/index.d.ts
+/**
+* @func isDomainLabel
+*
+* Test a label is a valid domain label according to RFC-1034.
+*
+* "Note that while upper and lower case letters are allowed in domain names,
+* no significance is attached to the case.  That is, two names with the same
+* spelling but different case are to be treated as if identical."
+*
+* By convention uppercased domain label will be considered invalid.
+*
+* Rules:
+* 1. "Labels must be 63 characters or less.";
+* 2. can be minimum one character;
+* 3. must only use lowercase letters, digits or hyphens;
+* 4. must not start or end with a hyphen;
+* 5. must not have consecutive hyphens;
+* 6. can start or end with a digit.
+*
+* Based on:
+* - RFC-1034 https://www.ietf.org/rfc/rfc1034.txt.
+*/
+declare const isDomainLabel: (label: string) => boolean;
+/**
+* @func isDomain
+*
+* Test a name is a valid domain according to RFC-1034.
+*
+* Supports Fully-Qualified Domain Name (FQDN) and Internationalized Domain Name (IDN).
+*
+* Rules:
+* 1. labels rules apply;
+* 2. "[...] the total number of octets that represent a domain name
+*   (i.e., the sum of all label octets and label lengths) is limited to 255.";
+* 3. labels are separated by dots (".");
+* 4. must have at least one extension label;
+* 5. must have labels different from each other;
+* 6. last label can be empty (root label ".");
+* 7. labels can start with `xn--` for IDNs if the ASCII serialization is a valid Punycode;
+* 8. check also Punycodes as ॐ gives xn--'-6xd where ' is not valid.
+*
+* Based on:
+* - RFC-1034 https://www.ietf.org/rfc/rfc1034.txt.
+*/
+declare const isDomain: (name: string) => boolean;
+//#endregion
+//#region src/encoders/index.d.ts
+/**
+* @func encodeURIComponentString
+*
+* Encode an URI component according to RFC-3986 with Sitemap entities support.
+*
+* Support:
+* - Sitemap's special characters;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment components can be encoded;
+* - scheme and authority host+port can never have percent encoded characters;
+* - the empty string is returned if unable to encode;
+* - sitemap characters must be in lowercase and escaped for XML sitemap.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const encodeURIComponentString: (component: string, {
+  type,
+  sitemap,
+  lowercase
+}?: {
+  type?: string | undefined;
+  sitemap?: boolean | undefined;
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func encodeURIString
+*
+* Encode an URI string according to RFC-3986 with basic checking.
+*
+* Checked:
+* - scheme is required;
+* - path is required, can be empty;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid ip or domain name;
+* - maximum size once encoded for URLs.
+*
+* Support:
+* - IDNs: returns URI with its Punycode host, if any;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodeURI also encodes scheme and host that cannot have
+*   percend-encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const encodeURIString: (uri: string, {
+  web,
+  sitemap,
+  lowercase
+}?: {
+  web?: boolean | undefined;
+  sitemap?: boolean | undefined;
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func encodeWebURL
+*
+* Encode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs.
+*
+* Uses a fixed encodeURI function to be RFC-3986 compliant.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid IP or domain name;
+* - maximum size once encoded.
+*
+* Support:
+* - IDNs: returns URL with its Punycode host, if any;
+* - lower and upper case.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodes also scheme and host that cannot have percend encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986.
+*/
+declare const encodeWebURL: (uri: string, {
+  lowercase
+}?: {
+  lowercase?: boolean | undefined;
+}) => string;
+/**
+* @func encodeSitemapURL
+*
+* Encode an URI string with basic checking based on RFC-3986 standard applied
+* to HTTP and HTTPS URLs and sitemap requirements regarding special entities to escape.
+*
+* Checked:
+* - scheme must be http/HTTP or https/HTTPS;
+* - path is required, can be empty;
+* - authority is required;
+* - port, if any, must be an integer in a specific range;
+* - host must be a valid IP or domain name;
+* - maximum size once encoded.
+*
+* Support:
+* - Sitemap's special characters;
+* - IDNs: returns URI with its Punycode host, if any;
+* - lower case only.
+*
+* Note:
+* - only userinfo, path, query and fragment can be percent encoded;
+* - native function encodeURI encodes string according to RFC-2396 which is outdated;
+* - native function encodes also scheme and host that cannot have percend encoded characters;
+* - characters that should not be percent-encoded in RFC-3986 are [] to represent IPv6 host;
+* - to stay fully RFC-3986 compliant, scheme and host are put in lowercase.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986;
+* - https://support.google.com/webmasters/answer/183668?hl=en&ref_topic=4581190.
+*/
+declare const encodeSitemapURL: (uri: string) => string;
+//#endregion
+//#region src/ip/index.d.ts
+/**
+* @func isIP
+*
+* Test a string is a valid IP.
+*/
+declare const isIP: (ip: string) => boolean;
+/**
+* @func isIPv4
+*
+* Test a string is a valid IPv4.
+*/
+declare const isIPv4: (ip: string) => boolean;
+/**
+* @func isIPv6
+*
+* Test a string is a valid IPv6.
+*/
+declare const isIPv6: (ip: string) => boolean;
+//#endregion
+//#region src/punycode/index.d.ts
+/**
+* @func punycode
+*
+* Returns the Punycode ASCII serialization of the domain.
+* If domain is an invalid domain, the empty string is returned.
+*
+* Note:
+* - native function url.domainToASCII does not support IPv6 only IPv4;
+* - native function url.domainToASCII throws if no domain is provided or returns
+*   `null`, `undefined`, `nan` for `null`, `undefined` or `NaN` values which is
+*   not what to be expected.
+*/
+declare const punycode: (domain: string) => string;
+/**
+* @func punydecode
+*
+* Returns the Unicode serialization of the domain.
+* If domain is an invalid domain, the empty string is returned.
+*
+* Note:
+* - native function url.domainToUnicode does not support IPv6 only IPv4;
+* - native function url.domainToUnicode throws if no domain is provided or returns
+*   `null`, `undefined`, `nan` for `null`, `undefined` or `NaN` values which is
+*   not what to be expected.
+*/
+declare const punydecode: (domain: string) => string;
+//#endregion
+//#region src/resolver/index.d.ts
+/**
+* @func removeDotSegments
+*
+* Remove the special "." and ".." complete path segments from a path,
+* implementing the RFC-3986 §5.2.4 ordered loop verbatim.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-5.2.4.
+*/
+declare const removeDotSegments: (path: string) => string;
+/**
+* @func resolveURI
+*
+* Resolve a URI reference against a base URI, implementing the RFC-3986
+* §5.2.2 strict transform (with §5.2.3 merge and §5.2.4 remove_dot_segments)
+* and recomposing per §5.3.
+*
+* The base must be an absolute URI (a scheme is required, RFC-3986 §5.2.1);
+* a fragment on the base is ignored (RFC-3986 §5.1: the base is used
+* stripped of any fragment); the empty string is returned if base or
+* reference is invalid.
+*
+* Based on:
+* - RFC-3986 https://tools.ietf.org/html/rfc3986#section-5.2.
+*/
+declare const resolveURI: (base: string, reference: string) => string;
+//#endregion
+export { type CheckedURI, type ParsedURI, type URIComponents, checkHttpSitemapURL, checkHttpURL, checkHttpsSitemapURL, checkHttpsURL, checkSitemapURL, checkURI, checkWebURL, decodeSitemapURL, decodeURIComponentString, decodeURIString, decodeWebURL, encodeSitemapURL, encodeURIComponentString, encodeURIString, encodeWebURL, isDomain, isDomainLabel, isIP, isIPv4, isIPv6, parseURI, punycode, punydecode, recomposeURI, removeDotSegments, resolveURI };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/parser/index.ts","../src/checkers/index.ts","../src/decoders/index.ts","../src/domain/index.ts","../src/encoders/index.ts","../src/ip/index.ts","../src/punycode/index.ts","../src/resolver/index.ts"],"mappings":";UAaiB,SAAA;EACf,MAAA;EACA,SAAA;EACA,oBAAA;EACA,QAAA;EACA,IAAA;EACA,eAAA;EACA,IAAA;EACA,IAAA;EACA,MAAA;EACA,KAAA;EACA,QAAA;EACA,IAAA;AAAA;AAAA,UAGe,aAAA;EACf,MAAA;EACA,QAAA;EACA,IAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;EACA,QAAA;AAAA;;AAAA;AAgBmC;;;;AAqCmB;AAAA;;;;AAkFP;;;;ACtIjD;;;;AACE;AA+O2D;;;;;;;;;cD5LvD,YAAA,GAAqC,UAAa,GAAA,aAAA;ACqTrD;AAAA;;;;;;;;;;;;;;;;;;AAAA,cDnOG,QAAA,GAA6B,GAAA,aAAc,SAAA;;;UCtIhC,UAAA,SAAmB,SAAA;EAClC,KAAA;AAAA;;;;;;;;;;;;;;;AAgcC;AAAA;;;;AAuEwD;cAlKrD,QAAA,GACJ,GAAA;EACE;AAAA;EAAa,OAAA;AAAA,MACd,UAAA;;AAqLoE;AAAA;;;;AAUE;AAAA;;;;AAWlB;AAAA;;;;cAzHjD,YAAA,GACJ,GAAA;EAEE,KAAA;EACA,GAAA;EACA;AAAA;EACG,KAAA;EAA6B,GAAA;EAA2B,OAAA;AAAA,MAC5D,UAAA;;;;;;;;cAuEG,aAAA,GAAuC,GAAA,aAAc,UAAA;;;;ACxgBA;AAAA;;;;;;;;;;;;;;cD8hBrD,mBAAA,GAAmD,GAAA,aAAc,UAAA;;;;;AC7dnE;AAAA;cDueE,oBAAA,GAAqD,GAAA,aAAc,UAAA;;;;;;;;cAWnE,WAAA,GAAmC,GAAA,aAAc,UAAA;AC1XpC;;;;;;;AAAA,cDqYb,eAAA,GAA2C,GAAA,aAAc,UAAA;;;;ADrlB/D;;;;;;;;;;;cEqBM,wBAAA,GACJ,SAAA;EACE,OAAA;EAAS;AAAA;EAAe,OAAA;EAA+B,SAAA;AAAA;;;AFXzD;AAGF;;;;;;;;;;;;AAOE;AAgBmC;;;;AAqCmB;AAAA;;;;AAkFP;;cE9E3C,eAAA,GACJ,GAAA;EAEE,GAAA;EACA,OAAA;EACA;AAAA;EAEA,GAAA;EACA,OAAA;EACA,SAAA;AAAA;;ADhEF;AA+O2D;;;;;;;;;;AAyH1D;AAAA;;;;;;;;;;;;;cClLG,YAAA,GACJ,GAAA;EACE;AAAA;EAAe,SAAA;AAAA;;;;;;ADwQhB;AAAA;;;;AAuEwD;AAAA;;;;AAsBY;AAAA;;;;AAUE;AAAA;;;;AAWlB;AAAA;;;cCxVjD,gBAAA,GACJ,GAAA;EACE;AAAA;EAAe,SAAA;AAAA;;;;AFpPnB;;;;;;;;;;;;;;;;;AAYE;AAGF;;;cGIM,aAAA,GAAuC,KAAA;;;;;;;;;AHG3C;AAgBmC;;;;AAqCmB;AAAA;;;;AAkFP;;;cG1F3C,QAAA,GAA6B,IAAA;;;;AHnEnC;;;;;;;;;;;;;;;;;AAYE;cIqBI,wBAAA,GACJ,SAAA;EAEE,IAAA;EACA,OAAA;EACA;AAAA;EAEA,IAAA;EACA,OAAA;EACA,SAAA;AAAA;;;;;;;;AJpBF;AAgBmC;;;;AAqCmB;AAAA;;;;AAkFP;;;;ACtIjD;;;;AACE;AA+O2D;;cGvIvD,eAAA,GACJ,GAAA;EAEE,GAAA;EACA,OAAA;EACA;AAAA;EAEA,GAAA;EACA,OAAA;EACA,SAAA;AAAA;;;;AHuPD;AAAA;;;;;;;;;;;;;;;;;;;;;AAwFA;AAAA;;;;cG3NG,YAAA,GACJ,GAAA;EACE;AAAA;EAAe,SAAA;AAAA;;;AHsToD;AAAA;;;;AAUE;AAAA;;;;AAWlB;AAAA;;;;AAWQ;;;;;;;;;;;;;cGnTzD,gBAAA,GAA6C,GAAA;;;;AJlSnD;;;;cK0BM,IAAA,GAAqB,EAAA;;;;;;cAarB,MAAA,GAAyB,EAAA;;;;;;cAazB,MAAA,GAAyB,EAAA;;;;ALpD/B;;;;;;;;;;;cMSM,QAAA,GAA6B,MAAA;;;;;;ANGjC;AAGF;;;;;;cMcM,UAAA,GAAiC,MAAA;;;;AN7BvC;;;;;;;;cOwCM,iBAAA,GAA+C,IAAA;;;;;;;;;AP5BnD;AAGF;;;;;;cOqIM,UAAA,GAAiC,IAAA,UAAc,SAAA"}