@rgrove/parse-xml 3.0.0 → 4.0.0

package/src/lib/syntax.ts

@@ -0,0 +1,136 @@
+/**
+ * Regular expression that matches one or more `AttValue` characters in a
+ * double-quoted attribute value.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
+ */
+export const attValueCharDoubleQuote = /[^"&<]+/y;
+
+/**
+ * Regular expression that matches one or more `AttValue` characters in a
+ * single-quoted attribute value.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
+ */
+export const attValueCharSingleQuote = /[^'&<]+/y;
+
+/**
+ * Regular expression that matches a whitespace character that should be
+ * normalized to a space character in an attribute value.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#AVNormalize
+ */
+export const attValueNormalizedWhitespace = /[\t\n]/g;
+
+/**
+ * Regular expression that matches one or more characters that signal the end of
+ * XML `CharData` content.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dt-chardata
+ */
+export const endCharData = /<|&|]]>/;
+
+/**
+ * Mapping of predefined entity names to their replacement values.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent
+ */
+export const predefinedEntities: Readonly<{[name: string]: string;}> = Object.freeze(Object.assign(Object.create(null), {
+  amp: '&',
+  apos: "'",
+  gt: '>',
+  lt: '<',
+  quot: '"',
+}));
+
+/**
+ * Returns `true` if _char_ is an XML `NameChar`, `false` if it isn't.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-NameChar
+ */
+export function isNameChar(char: string): boolean {
+  let cp = getCodePoint(char);
+
+  // Including the most common NameStartChars here improves performance
+  // slightly.
+  return (cp >= 0x61 && cp <= 0x7A) // a-z
+    || (cp >= 0x41 && cp <= 0x5A) // A-Z
+    || (cp >= 0x30 && cp <= 0x39) // 0-9
+    || cp === 0x2D // -
+    || cp === 0x2E // .
+    || cp === 0xB7
+    || (cp >= 0x300 && cp <= 0x36F)
+    || (cp >= 0x203F && cp <= 0x2040)
+    || isNameStartChar(char, cp);
+}
+
+/**
+ * Returns `true` if _char_ is an XML `NameStartChar`, `false` if it isn't.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-NameStartChar
+ */
+export function isNameStartChar(char: string, cp = getCodePoint(char)): boolean {
+  return (cp >= 0x61 && cp <= 0x7A) // a-z
+    || (cp >= 0x41 && cp <= 0x5A) // A-Z
+    || cp === 0x3A // :
+    || cp === 0x5F // _
+    || (cp >= 0xC0 && cp <= 0xD6)
+    || (cp >= 0xD8 && cp <= 0xF6)
+    || (cp >= 0xF8 && cp <= 0x2FF)
+    || (cp >= 0x370 && cp <= 0x37D)
+    || (cp >= 0x37F && cp <= 0x1FFF)
+    || (cp >= 0x200C && cp <= 0x200D)
+    || (cp >= 0x2070 && cp <= 0x218F)
+    || (cp >= 0x2C00 && cp <= 0x2FEF)
+    || (cp >= 0x3001 && cp <= 0xD7FF)
+    || (cp >= 0xF900 && cp <= 0xFDCF)
+    || (cp >= 0xFDF0 && cp <= 0xFFFD)
+    || (cp >= 0x10000 && cp <= 0xEFFFF);
+}
+
+/**
+ * Returns `true` if _char_ is a valid reference character (which may appear
+ * between `&` and `;` in a reference), `false` otherwise.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-references
+ */
+export function isReferenceChar(char: string): boolean {
+  return char === '#' || isNameChar(char);
+}
+
+/**
+ * Returns `true` if _char_ is an XML whitespace character, `false` otherwise.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#white
+ */
+export function isWhitespace(char: string): boolean {
+  let cp = getCodePoint(char);
+
+  return cp === 0x20
+    || cp === 0x9
+    || cp === 0xA
+    || cp === 0xD;
+}
+
+/**
+ * Returns `true` if _codepoint_ is a valid XML `Char` code point, `false`
+ * otherwise.
+ *
+ * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Char
+ */
+export function isXmlCodePoint(cp: number): boolean {
+  return cp === 0x9
+    || cp === 0xA
+    || cp === 0xD
+    || (cp >= 0x20 && cp <= 0xD7FF)
+    || (cp >= 0xE000 && cp <= 0xFFFD)
+    || (cp >= 0x10000 && cp <= 0x10FFFF);
+}
+
+/**
+ * Returns the Unicode code point value of the given character, or `-1` if
+ * _char_ is empty.
+ */
+function getCodePoint(char: string): number {
+  return char.codePointAt(0) || -1;
+}

package/src/lib/types.ts

@@ -0,0 +1,2 @@
+export type JsonObject = {[key in string]?: JsonValue};
+export type JsonValue = string | number | boolean | JsonObject | JsonValue[] | null;

package/CHANGELOG.md

@@ -1,162 +0,0 @@
-# parse-xml changelog
-
-All notable changes to parse-xml are documented in this file. The format is
-based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). This project
-adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## 3.0.0 (2021-01-23)
-
-This release includes significant changes under the hood (such as a brand new
-parser!), but backwards compatibility has been a high priority. Most users
-should be able to upgrade without needing to make any changes (or with only
-minimal changes).
-
-### Added
-
--   XML declarations (like `<?xml version="1.0"?>`) and processing instructions
-    are now included in parsed documents as `XmlProcessingInstruction` nodes
-    (with the `type` value "pi"). Previously they were discarded.
-
--   A new `sortAttributes` option. When `true`, attributes will be sorted in
-    alphabetical order in an element's `attributes` object (which is no longer
-    the default behavior).
-
--   TypeScript type definitions. While parse-xml is still written in JavaScript,
-    it now has TypeScript-friendly JSDoc comments throughout, with strict type
-    checking enabled. These comments are now used to generate type definitions
-    at build time.
-
-### Changed
-
--   The minimum supported Node.js version is now 12.x, and the minimum supported
-    ECMAScript version is ES2017. Extremely old browsers (like IE11) are no
-    longer supported out of the box, but you can still transpile parse-xml
-    yourself if you need to support old browsers.
-
--   The XML parser has been completely rewritten with the primary goals of
-    improving robustness and safety.
-
-    While the previous parser was good, it relied heavily on complex regular
-    expressions. This helped keep it extremely small, but also left it open to
-    the possibility of regex denial of service bugs when parsing unusual or
-    maliciously crafted input.
-
-    The new parser uses a less interesting but overall safer approach, and
-    employs regular expressions only sparingly and in ways that aren't risky
-    (they're now only used as performance optimizations rather than as the basis
-    for the entire parser).
-
--   The `parseXml()` function now returns an `XmlDocument` instance instead of a
-    plain object. Its properties are backwards compatible.
-
--   Other node types (elements, text nodes, CDATA nodes, and comments) are also
-    now represented by class instances (`XmlElement`, `XmlText`, `XmlCdata`, and
-    `XmlComment`) rather than plain objects. Their properties are all backwards
-    compatible.
-
--   Attributes are no longer sorted alphabetically by name in an element's
-    `attributes` object by default. They're now defined in the same order that
-    they're encountered in the document being parsed, unless the
-    `sortAttributes` parser option is `true`.
-
--   If the value returned by an optional `resolveUndefinedEntity` function is
-    not a string, `null`, or `undefined`, a `TypeError` will now be thrown. If
-    you don't pass a custom `resolveUndefinedEntity` function to `parseXml()`,
-    then this change won't affect you.
-
--   Some error messages have been changed to improve clarity, and more helpful
-    errors have been added in some scenarios that previously would have resulted
-    in generic or less helpful errors.
-
--   The `browser` field in `package.json` has been removed and the `main` field
-    now points both Node.js and browser bundlers to the same untranspiled
-    CommonJS source.
-
-    When bundled using your favorite bundler, parse-xml will work great in all
-    modern browsers with no transpilation needed. If you don't want to use a
-    bundler, you can still use the prepackaged UMD bundle at
-    `dist/umd/parse-xml.min.js`, which provides a `parseXml` global.
-
-## 2.0.4 (2020-05-01)
-
-### Fixed
-
--   Extremely long attribute values no longer cause the parser to throw a
-    "Maximum call stack size exceeded" `RangeError`. [#13] (@rossj)
-
-[#13]:https://github.com/rgrove/parse-xml/pull/13
-
-## 2.0.3 (2020-04-20)
-
-### Fixed
-
--   Attribute values with many consecutive character references (such as `&lt;`)
-    no longer cause the parser to hang. [#10] (@rossj)
-
-[#10]:https://github.com/rgrove/parse-xml/pull/10
-
-## 2.0.2 (2020-01-10)
-
-### Fixed
-
--   Whitespace in attribute values is now normalized correctly. [#7]
-
-    Previously, attribute values were normalized according to the rules for
-    non-CDATA attributes, but this was incorrect and based on a misreading of
-    the spec.
-
-    Attribute values are now correctly parsed as CDATA, meaning that whitespace
-    is not collapsed or trimmed and whitespace character entities are resolved
-    to their respective characters rather than being normalized to spaces (which
-    was incorrect even by the non-CDATA rules!).
-
-[#7]:https://github.com/rgrove/parse-xml/pull/7
-
-## 2.0.1 (2019-04-09)
-
-### Fixed
-
--   A carriage return (`\r`) character that isn't followed by a line feed (`\n`)
-    character is now [correctly normalized][xml-line-ends] to a line feed before
-    parsing.
-
-[xml-line-ends]:https://www.w3.org/TR/2008/REC-xml-20081126/#sec-line-ends
-
-## 2.0.0 (2019-01-20)
-
-### Added
-
--   There's a new minified UMD bundle at `dist/umd/parse-xml.min.js` in the npm
-    package. This may be useful if you want to load parse-xml directly in a
-    browser using a service like
-    [unpkg](https://unpkg.com/@rgrove/parse-xml/dist/umd/parse-xml.min.js) or
-    [jsDelivr](https://cdn.jsdelivr.net/npm/@rgrove/parse-xml/dist/umd/parse-xml.min.js).
-
-### Changed
-
--   parse-xml no longer depends on CoreJS polyfills or the Babel runtime, which
-    reduces the browser bundle size significantly. If you need to support older
-    browsers, you should provide your own polyfills for `Object.assign()`,
-    `Object.freeze()`, and `String.fromCodePoint()`.
-
--   The browser-friendly CommonJS build has moved from `dist/` to
-    `dist/commonjs/` in the npm package.
-
-## 1.1.1 (2017-09-20)
-
-### Fixed
-
--   Attribute values are no longer truncated at the first `=` character.
-
-## 1.1.0 (2017-09-10)
-
-### Added
-
--   New parsing option `resolveUndefinedEntity`. [#2]
-    ([@retorquere](https://github.com/retorquere))
-
-[#2]:https://github.com/rgrove/parse-xml/pull/2
-
-## 1.0.0 (2017-06-04)
-
--   Initial release.

package/dist/types/index.d.ts

@@ -1,68 +0,0 @@
-export = parseXml;
-/**
-Parses the given XML string and returns an `XmlDocument` instance representing
-the document tree.
-
-@example
-
-  const parseXml = require('@rgrove/parse-xml');
-  let doc = parseXml('<kittens fuzzy="yes">I like fuzzy kittens.</kittens>');
-
-@param {string} xml
-  XML string to parse.
-
-@param {object} [options]
-  Parsing options.
-
-  @param {boolean} [options.ignoreUndefinedEntities=false]
-    When `true`, an undefined named entity (like "&bogus;") will be left in the
-    output as is instead of causing a parse error.
-
-  @param {boolean} [options.preserveCdata=false]
-    When `true`, CDATA sections will be preserved in the document as `XmlCdata`
-    nodes. Otherwise CDATA sections will be represented as `XmlText` nodes,
-    which keeps the node tree simpler and easier to work with.
-
-  @param {boolean} [options.preserveComments=false]
-    When `true`, comments will be preserved in the document as `XmlComment`
-    nodes. Otherwise comments will not be included in the node tree.
-
-  @param {(entity: string) => string?} [options.resolveUndefinedEntity]
-    When an undefined named entity is encountered, this function will be called
-    with the entity as its only argument. It should return a string value with
-    which to replace the entity, or `null` or `undefined` to treat the entity as
-    undefined (which may result in a parse error depending on the value of
-    `ignoreUndefinedEntities`).
-
-  @param {boolean} [options.sortAttributes=false]
-    When `true`, attributes in an element's `attributes` object will be sorted
-    in alphanumeric order by name. Otherwise they'll retain their original order
-    as found in the XML.
-
-@returns {XmlDocument}
-@public
-*/
-declare function parseXml(xml: string, options?: {
-    ignoreUndefinedEntities?: boolean | undefined;
-    preserveCdata?: boolean | undefined;
-    preserveComments?: boolean | undefined;
-    resolveUndefinedEntity?: ((entity: string) => string | null) | undefined;
-    sortAttributes?: boolean | undefined;
-} | undefined): XmlDocument;
-declare namespace parseXml {
-    export { XmlCdata };
-    export { XmlComment };
-    export { XmlDocument };
-    export { XmlElement };
-    export { XmlNode };
-    export { XmlProcessingInstruction };
-    export { XmlText };
-}
-import XmlDocument = require("./lib/XmlDocument");
-import XmlCdata = require("./lib/XmlCdata");
-import XmlComment = require("./lib/XmlComment");
-import XmlElement = require("./lib/XmlElement");
-import XmlNode = require("./lib/XmlNode");
-import XmlProcessingInstruction = require("./lib/XmlProcessingInstruction");
-import XmlText = require("./lib/XmlText");
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CE;AACF,+BAlCQ,MAAM;;;;uCAmBK,MAAM,KAAK,MAAM;;gBAY1B,WAAW,CAKpB"}

package/dist/types/lib/Parser.d.ts

@@ -1,234 +0,0 @@
-export = Parser;
-/**
-Parses an XML string into an `XmlDocument`.
-
-@private
-*/
-declare class Parser {
-    /**
-    @param {string} xml
-      XML string to parse.
-  
-    @param {object} [options]
-      Parsing options.
-  
-      @param {boolean} [options.ignoreUndefinedEntities=false]
-      @param {boolean} [options.preserveCdata=false]
-      @param {boolean} [options.preserveComments=false]
-      @param {(entity: string) => string?} [options.resolveUndefinedEntity]
-      @param {boolean} [options.sortAttributes=false]
-    */
-    constructor(xml: string, options?: {
-        ignoreUndefinedEntities?: boolean | undefined;
-        preserveCdata?: boolean | undefined;
-        preserveComments?: boolean | undefined;
-        resolveUndefinedEntity?: ((entity: string) => string | null) | undefined;
-        sortAttributes?: boolean | undefined;
-    } | undefined);
-    /** @type {XmlDocument} */
-    document: XmlDocument;
-    /** @type {XmlDocument|XmlElement} */
-    currentNode: XmlDocument | XmlElement;
-    options: {
-        ignoreUndefinedEntities?: boolean | undefined;
-        preserveCdata?: boolean | undefined;
-        preserveComments?: boolean | undefined;
-        resolveUndefinedEntity?: ((entity: string) => string | null) | undefined;
-        sortAttributes?: boolean | undefined;
-    };
-    scanner: StringScanner;
-    /**
-    Adds the given `XmlNode` as a child of `this.currentNode`.
-  
-    @param {XmlNode} node
-    */
-    addNode(node: XmlNode): void;
-    /**
-    Adds the given _text_ to the document, either by appending it to a preceding
-    `XmlText` node (if possible) or by creating a new `XmlText` node.
-  
-    @param {string} text
-    */
-    addText(text: string): void;
-    /**
-    Consumes an `AttValue` (attribute value) if possible.
-  
-    @returns {string|false}
-      Contents of the `AttValue` minus quotes, or `false` if nothing was consumed.
-      An empty string indicates that an `AttValue` was consumed but was empty.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
-    */
-    consumeAttributeValue(): string | false;
-    /**
-    Consumes a CDATA section if possible.
-  
-    @returns {boolean}
-      Whether a CDATA section was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-cdata-sect
-    */
-    consumeCdataSection(): boolean;
-    /**
-    Consumes character data if possible.
-  
-    @returns {boolean}
-      Whether character data was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#dt-chardata
-    */
-    consumeCharData(): boolean;
-    /**
-    Consumes a comment if possible.
-  
-    @returns {boolean}
-      Whether a comment was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Comment
-    */
-    consumeComment(): boolean;
-    /**
-    Consumes a reference in a content context if possible.
-  
-    This differs from `consumeReference()` in that a consumed reference will be
-    added to the document as a text node instead of returned.
-  
-    @returns {boolean}
-      Whether a reference was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#entproc
-    */
-    consumeContentReference(): boolean;
-    /**
-    Consumes a doctype declaration if possible.
-  
-    This is a loose implementation since doctype declarations are currently
-    discarded without further parsing.
-  
-    @returns {boolean}
-      Whether a doctype declaration was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#dtd
-    */
-    consumeDoctypeDeclaration(): boolean;
-    /**
-    Consumes an element if possible.
-  
-    @returns {boolean}
-      Whether an element was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-element
-    */
-    consumeElement(): boolean;
-    /**
-    Consumes an `Eq` production if possible.
-  
-    @returns {boolean}
-      Whether an `Eq` production was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Eq
-    */
-    consumeEqual(): boolean;
-    /**
-    Consumes `Misc` content if possible.
-  
-    @returns {boolean}
-      Whether anything was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Misc
-    */
-    consumeMisc(): boolean;
-    /**
-    Consumes one or more `Name` characters if possible.
-  
-    @returns {string}
-      `Name` characters, or an empty string if none were consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Name
-    */
-    consumeName(): string;
-    /**
-    Consumes a processing instruction if possible.
-  
-    @returns {boolean}
-      Whether a processing instruction was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-pi
-    */
-    consumeProcessingInstruction(): boolean;
-    /**
-    Consumes a prolog if possible.
-  
-    @returns {boolean}
-      Whether a prolog was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-prolog-dtd
-    */
-    consumeProlog(): boolean;
-    /**
-    Consumes a reference if possible.
-  
-    This differs from `consumeContentReference()` in that a consumed reference
-    will be returned rather than added to the document.
-  
-    @returns {string|false}
-      Parsed reference value, or `false` if nothing was consumed (to distinguish
-      from a reference that resolves to an empty string).
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Reference
-    */
-    consumeReference(): string | false;
-    /**
-    Consumes a `SystemLiteral` if possible.
-  
-    A `SystemLiteral` is similar to an attribute value, but allows the characters
-    `<` and `&` and doesn't replace references.
-  
-    @returns {string|false}
-      Value of the `SystemLiteral` minus quotes, or `false` if nothing was
-      consumed. An empty string indicates that a `SystemLiteral` was consumed but
-      was empty.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-SystemLiteral
-    */
-    consumeSystemLiteral(): string | false;
-    /**
-    Consumes one or more whitespace characters if possible.
-  
-    @returns {boolean}
-      Whether any whitespace characters were consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#white
-    */
-    consumeWhitespace(): boolean;
-    /**
-    Consumes an XML declaration if possible.
-  
-    @returns {boolean}
-      Whether an XML declaration was consumed.
-  
-    @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-XMLDecl
-    */
-    consumeXmlDeclaration(): boolean;
-    /**
-    Throws an error at the current scanner position.
-  
-    @param {string} message
-    */
-    error(message: string): void;
-    /**
-    Throws an invalid character error if any character in the given _string_ isn't
-    a valid XML character.
-  
-    @param {string} string
-    */
-    validateChars(string: string): void;
-}
-declare namespace Parser {
-    export { XmlNode };
-}
-import XmlDocument = require("./XmlDocument");
-import XmlElement = require("./XmlElement");
-import StringScanner = require("./StringScanner");
-type XmlNode = import("./XmlNode");
-//# sourceMappingURL=Parser.d.ts.map

package/dist/types/lib/Parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../../src/lib/Parser.js"],"names":[],"mappings":";AAaA;;;;EAIE;AACF;IACE;;;;;;;;;;;;MAYE;IACF,iBAZQ,MAAM;;;;2CASK,MAAM,KAAK,MAAM;;mBAwBnC;IApBC,0BAA0B;IAC1B,UADW,WAAW,CACW;IAEjC,qCAAqC;IACrC,aADW,WAAW,GAAC,UAAU,CACD;IAEhC;;;;2CAViB,MAAM,KAAK,MAAM;;MAUZ;IACtB,uBAAyD;IAe3D;;;;MAIE;IACF,cAFQ,OAAO,QAOd;IAED;;;;;MAKE;IACF,cAFQ,MAAM,QAiBb;IAED;;;;;;;;MAQE;IACF,yBANU,MAAM,GAAC,KAAK,CA2DrB;IAED;;;;;;;MAOE;IACF,uBALU,OAAO,CA0BhB;IAED;;;;;;;MAOE;IACF,mBALU,OAAO,CAqBhB;IAED;;;;;;;MAOE;IACF,kBALU,OAAO,CA4BhB;IAED;;;;;;;;;;MAUE;IACF,2BALU,OAAO,CAchB;IAED;;;;;;;;;;MAUE;IACF,6BALU,OAAO,CAyBhB;IAED;;;;;;;MAOE;IACF,kBALU,OAAO,CA4GhB;IAED;;;;;;;MAOE;IACF,gBALU,OAAO,CAchB;IAED;;;;;;;MAOE;IACF,eALU,OAAO,CAShB;IAED;;;;;;;MAOE;IACF,eALU,MAAM,CASf;IAED;;;;;;;MAOE;IACF,gCALU,OAAO,CA0ChB;IAED;;;;;;;MAOE;IACF,iBALU,OAAO,CAkBhB;IAED;;;;;;;;;;;MAWE;IACF,oBANU,MAAM,GAAC,KAAK,CA0ErB;IAED;;;;;;;;;;;;MAYE;IACF,wBAPU,MAAM,GAAC,KAAK,CAuBrB;IAED;;;;;;;MAOE;IACF,qBALU,OAAO,CAOhB;IAED;;;;;;;MAOE;IACF,yBALU,OAAO,CAqDhB;IAED;;;;MAIE;IACF,eAFQ,MAAM,QAuDb;IAED;;;;;MAKE;IACF,sBAFQ,MAAM,QAab;CACF"}