diff options
Diffstat (limited to 'school/node_modules/saxes')
| -rw-r--r-- | school/node_modules/saxes/README.md | 323 | ||||
| -rw-r--r-- | school/node_modules/saxes/package.json | 70 | ||||
| -rw-r--r-- | school/node_modules/saxes/saxes.d.ts | 635 | ||||
| -rw-r--r-- | school/node_modules/saxes/saxes.js | 2064 | ||||
| -rw-r--r-- | school/node_modules/saxes/saxes.js.map | 1 |
5 files changed, 3093 insertions, 0 deletions
diff --git a/school/node_modules/saxes/README.md b/school/node_modules/saxes/README.md new file mode 100644 index 0000000..f863763 --- /dev/null +++ b/school/node_modules/saxes/README.md @@ -0,0 +1,323 @@ +# saxes + +A sax-style non-validating parser for XML. + +Saxes is a fork of [sax](https://github.com/isaacs/sax-js) 1.2.4. All mentions +of sax in this project's documentation are references to sax 1.2.4. + +Designed with [node](http://nodejs.org/) in mind, but should work fine in the +browser or other CommonJS implementations. + +Saxes does not support Node versions older than 10. + +## Notable Differences from Sax. + +* Saxes aims to be much stricter than sax with regards to XML + well-formedness. Sax, even in its so-called "strict mode", is not strict. It + silently accepts structures that are not well-formed XML. Projects that need + better compliance with well-formedness constraints cannot use sax as-is. + + Consequently, saxes does not support HTML, or pseudo-XML, or bad XML. Saxes + will report well-formedness errors in all these cases but it won't try to + extract data from malformed documents like sax does. + +* Saxes is much much faster than sax, mostly because of a substantial redesign + of the internal parsing logic. The speed improvement is not merely due to + removing features that were supported by sax. That helped a bit, but saxes + adds some expensive checks in its aim for conformance with the XML + specification. Redesigning the parsing logic is what accounts for most of the + performance improvement. + +* Saxes does not aim to support antiquated platforms. We will not pollute the + source or the default build with support for antiquated platforms. If you want + support for IE 11, you are welcome to produce a PR that adds a *new build* + transpiled to ES5. + +* Saxes handles errors differently from sax: it provides a default onerror + handler which throws. You can replace it with your own handler if you want. If + your handler does nothing, there is no `resume` method to call. + +* There's no `Stream` API. A revamped API may be introduced later. (It is still + a "streaming parser" in the general sense that you write a character stream to + it.) + +* Saxes does not have facilities for limiting the size the data chunks passed to + event handlers. See the FAQ entry for more details. + +## Conformance + +Saxes supports: + +* [XML 1.0 fifth edition](https://www.w3.org/TR/2008/REC-xml-20081126/) +* [XML 1.1 second edition](https://www.w3.org/TR/2006/REC-xml11-20060816/) +* [Namespaces in XML 1.0 (Third Edition)](https://www.w3.org/TR/2009/REC-xml-names-20091208/). +* [Namespaces in XML 1.1 (Second Edition)](https://www.w3.org/TR/2006/REC-xml-names11-20060816/). + +## Limitations + +This is a non-validating parser so it only verifies whether the document is +well-formed. We do aim to raise errors for all malformed constructs +encountered. However, this parser does not thorougly parse the contents of +DTDs. So most malformedness errors caused by errors **in DTDs** cannot be +reported. + +## Regarding `<!DOCTYPE` and `<!ENTITY` + +The parser will handle the basic XML entities in text nodes and attribute +values: `& < > ' "`. It's possible to define additional +entities in XML by putting them in the DTD. This parser doesn't do anything with +that. If you want to listen to the `doctype` event, and then fetch the +doctypes, and read the entities and add them to `parser.ENTITIES`, then be my +guest. + +## Documentation + +The source code contains JSDOC comments. Use them. What follows is a brief +summary of what is available. The final authority is the source code. + +**PAY CLOSE ATTENTION TO WHAT IS PUBLIC AND WHAT IS PRIVATE.** + +The move to TypeScript makes it so that everything is now formally private, +protected, or public. + +If you use anything not public, that's at your own peril. + +If there's a mistake in the documentation, raise an issue. If you just assume, +you may assume incorrectly. + +## Summary Usage Information + +### Example + +```javascript +var saxes = require("./lib/saxes"), + parser = new saxes.SaxesParser(); + +parser.on("error", function (e) { + // an error happened. +}); +parser.on("text", function (t) { + // got some text. t is the string of text. +}); +parser.on("opentag", function (node) { + // opened a tag. node has "name" and "attributes" +}); +parser.on("end", function () { + // parser stream is done, and ready to have more stuff written to it. +}); + +parser.write('<xml>Hello, <who name="world">world</who>!</xml>').close(); +``` + +### Constructor Arguments + +Settings supported: + +* `xmlns` - Boolean. If `true`, then namespaces are supported. Default + is `false`. + +* `position` - Boolean. If `false`, then don't track line/col/position. Unset is + treated as `true`. Default is unset. Currently, setting this to `false` only + results in a cosmetic change: the errors reported do not contain position + information. sax-js would literally turn off the position-computing logic if + this flag was set to false. The notion was that it would optimize + execution. In saxes at least it turns out that continually testing this flag + causes a cost that offsets the benefits of turning off this logic. + +* `fileName` - String. Set a file name for error reporting. This is useful only + when tracking positions. You may leave it unset. + +* `fragment` - Boolean. If `true`, parse the XML as an XML fragment. Default is + `false`. + +* `additionalNamespaces` - A plain object whose key, value pairs define + namespaces known before parsing the XML file. It is not legal to pass + bindings for the namespaces `"xml"` or `"xmlns"`. + +* `defaultXMLVersion` - The default version of the XML specification to use if + the document contains no XML declaration. If the document does contain an XML + declaration, then this setting is ignored. Must be `"1.0"` or `"1.1"`. The + default is `"1.0"`. + +* `forceXMLVersion` - Boolean. A flag indicating whether to force the XML + version used for parsing to the value of ``defaultXMLVersion``. When this flag + is ``true``, ``defaultXMLVersion`` must be specified. If unspecified, the + default value of this flag is ``false``. + + Example: suppose you are parsing a document that has an XML declaration + specifying XML version 1.1. + + If you set ``defaultXMLVersion`` to ``"1.0"`` without setting + ``forceXMLVersion`` then the XML declaration will override the value of + ``defaultXMLVersion`` and the document will be parsed according to XML 1.1. + + If you set ``defaultXMLVersion`` to ``"1.0"`` and set ``forceXMLVersion`` to + ``true``, then the XML declaration will be ignored and the document will be + parsed according to XML 1.0. + +### Methods + +`write` - Write bytes onto the stream. You don't have to pass the whole document +in one `write` call. You can read your source chunk by chunk and call `write` +with each chunk. + +`close` - Close the stream. Once closed, no more data may be written until it is +done processing the buffer, which is signaled by the `end` event. + +### Properties + +The parser has the following properties: + +`line`, `column`, `columnIndex`, `position` - Indications of the position in the +XML document where the parser currently is looking. The `columnIndex` property +counts columns as if indexing into a JavaScript string, whereas the `column` +property counts Unicode characters. + +`closed` - Boolean indicating whether or not the parser can be written to. If +it's `true`, then wait for the `ready` event to write again. + +`opt` - Any options passed into the constructor. + +`xmlDecl` - The XML declaration for this document. It contains the fields +`version`, `encoding` and `standalone`. They are all `undefined` before +encountering the XML declaration. If they are undefined after the XML +declaration, the corresponding value was not set by the declaration. There is no +event associated with the XML declaration. In a well-formed document, the XML +declaration may be preceded only by an optional BOM. So by the time any event +generated by the parser happens, the declaration has been processed if present +at all. Otherwise, you have a malformed document, and as stated above, you +cannot rely on the parser data! + +### Error Handling + +The parser continues to parse even upon encountering errors, and does its best +to continue reporting errors. You should heed all errors reported. After an +error, however, saxes may interpret your document incorrectly. For instance +``<foo a=bc="d"/>`` is invalid XML. Did you mean to have ``<foo a="bc=d"/>`` or +``<foo a="b" c="d"/>`` or some other variation? For the sake of continuing to +provide errors, saxes will continue parsing the document, but the structure it +reports may be incorrect. It is only after the errors are fixed in the document +that saxes can provide a reliable interpretation of the document. + +That leaves you with two rules of thumb when using saxes: + +* Pay attention to the errors that saxes report. The default `onerror` handler + throws, so by default, you cannot miss errors. + +* **ONCE AN ERROR HAS BEEN ENCOUNTERED, STOP RELYING ON THE EVENT HANDLERS OTHER + THAN `onerror`.** As explained above, when saxes runs into a well-formedness + problem, it makes a guess in order to continue reporting more errors. The guess + may be wrong. + +### Events + +To listen to an event, override `on<eventname>`. The list of supported events +are also in the exported `EVENTS` array. + +See the JSDOC comments in the source code for a description of each supported +event. + +### Parsing XML Fragments + +The XML specification does not define any method by which to parse XML +fragments. However, there are usage scenarios in which it is desirable to parse +fragments. In order to allow this, saxes provides three initialization options. + +If you pass the option `fragment: true` to the parser constructor, the parser +will expect an XML fragment. It essentially starts with a parsing state +equivalent to the one it would be in if `parser.write("<foo">)` had been called +right after initialization. In other words, it expects content which is +acceptable inside an element. This also turns off well-formedness checks that +are inappropriate when parsing a fragment. + +The option `additionalNamespaces` allows you to define additional prefix-to-URI +bindings known before parsing starts. You would use this over `resolvePrefix` if +you have at the ready a series of namespaces bindings to use. + +The option `resolvePrefix` allows you to pass a function which saxes will use if +it is unable to resolve a namespace prefix by itself. You would use this over +`additionalNamespaces` in a context where getting a complete list of defined +namespaces is onerous. + +Note that you can use `additionalNamespaces` and `resolvePrefix` together if you +want. `additionalNamespaces` applies before `resolvePrefix`. + +The options `additionalNamespaces` and `resolvePrefix` are really meant to be +used for parsing fragments. However, saxes won't prevent you from using them +with `fragment: false`. Note that if you do this, your document may parse +without errors and yet be malformed because the document can refer to namespaces +which are not defined *in* the document. + +Of course, `additionalNamespaces` and `resolvePrefix` are used only if `xmlns` +is `true`. If you are parsing a fragment that does not use namespaces, there's +no point in setting these options. + +### Performance Tips + +* saxes works faster on files that use newlines (``\u000A``) as end of line + markers than files that use other end of line markers (like ``\r`` or + ``\r\n``). The XML specification requires that conformant applications behave + as if all characters that are to be treated as end of line characters are + converted to ``\u000A`` prior to parsing. The optimal code path for saxes is a + file in which all end of line characters are already ``\u000A``. + +* Don't split Unicode strings you feed to saxes across surrogates. When you + naively split a string in JavaScript, you run the risk of splitting a Unicode + character into two surrogates. e.g. In the following example ``a`` and ``b`` + each contain half of a single Unicode character: ``const a = "\u{1F4A9}"[0]; + const b = "\u{1F4A9}"[1]`` If you feed such split surrogates to versions of + saxes prior to 4, you'd get errors. Saxes version 4 and over are able to + detect when a chunk of data ends with a surrogate and carry over the surrogate + to the next chunk. However this operation entails slicing and concatenating + strings. If you can feed your data in a way that does not split surrogates, + you should do it. (Obviously, feeding all the data at once with a single write + is fastest.) + +* Don't set event handlers you don't need. Saxes has always aimed to avoid doing + work that will just be tossed away but future improvements hope to do this + more aggressively. One way saxes knows whether or not some data is needed is + by checking whether a handler has been set for a specific event. + +## FAQ + +Q. Why has saxes dropped support for limiting the size of data chunks passed to +event handlers? + +A. With sax you could set ``MAX_BUFFER_LENGTH`` to cause the parser to limit the +size of data chunks passed to event handlers. So if you ran into a span of text +above the limit, multiple ``text`` events with smaller data chunks were fired +instead of a single event with a large chunk. + +However, that functionality had some problematic characteristics. It had an +arbitrary default value. It was library-wide so all parsers created from a +single instance of the ``sax`` library shared it. This could potentially cause +conflicts among libraries running in the same VM but using sax for different +purposes. + +These issues could have been easily fixed, but there were larger issues. The +buffer limit arbitrarily applied to some events but not others. It would split +``text``, ``cdata`` and ``script`` events. However, if a ``comment``, +``doctype``, ``attribute`` or ``processing instruction`` were more than the +limit, the parser would generate an error and you were left picking up the +pieces. + +It was not intuitive to use. You'd think setting the limit to 1K would prevent +chunks bigger than 1K to be passed to event handlers. But that was not the +case. A comment in the source code told you that you might go over the limit if +you passed large chunks to ``write``. So if you want a 1K limit, don't pass 64K +chunks to ``write``. Fair enough. You know what limit you want so you can +control the size of the data you pass to ``write``. So you limit the chunks to +``write`` to 1K at a time. Even if you do this, your event handlers may get data +chunks that are 2K in size. Suppose on the previous ``write`` the parser has +just finished processing an open tag, so it is ready for text. Your ``write`` +passes 1K of text. You are not above the limit yet, so no event is generated +yet. The next ``write`` passes another 1K of text. It so happens that sax checks +buffer limits only once per ``write``, after the chunk of data has been +processed. Now you've hit the limit and you get a ``text`` event with 2K of +data. So even if you limit your ``write`` calls to the buffer limit you've set, +you may still get events with chunks at twice the buffer size limit you've +specified. + +We may consider reinstating an equivalent functionality, provided that it +addresses the issues above and does not cause a huge performance drop for +use-case scenarios that don't need it. diff --git a/school/node_modules/saxes/package.json b/school/node_modules/saxes/package.json new file mode 100644 index 0000000..ac987e7 --- /dev/null +++ b/school/node_modules/saxes/package.json @@ -0,0 +1,70 @@ +{ + "name": "saxes", + "description": "An evented streaming XML parser in JavaScript", + "author": "Louis-Dominique Dubeau <ldd@lddubeau.com>", + "version": "5.0.1", + "main": "saxes.js", + "types": "saxes.d.ts", + "license": "ISC", + "engines": { + "node": ">=10" + }, + "scripts": { + "tsc": "tsc", + "copy": "cp -p README.md build/dist && sed -e'/\"private\": true/d' package.json > build/dist/package.json", + "build": "npm run tsc && npm run copy", + "test": "npm run build && mocha --delay", + "lint": "eslint --ignore-path .gitignore '**/*.ts' '**/*.js'", + "lint-fix": "npm run lint -- --fix", + "posttest": "npm run lint", + "typedoc": "typedoc --tsconfig tsconfig.json --name saxes --out build/docs/ --listInvalidSymbolLinks --excludePrivate --excludeNotExported", + "build-docs": "npm run typedoc", + "gh-pages": "npm run build-docs && mkdir -p build && (cd build; rm -rf gh-pages; git clone .. --branch gh-pages gh-pages) && mkdir -p build/gh-pages/latest && find build/gh-pages/latest -type f -delete && cp -rp build/docs/* build/gh-pages/latest && find build/gh-pages -type d -empty -delete", + "self:publish": "cd build/dist && npm_config_tag=`simple-dist-tag` npm publish", + "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md", + "postversion": "npm run test && npm run self:publish", + "postpublish": "git push origin --follow-tags" + }, + "repository": "https://github.com/lddubeau/saxes.git", + "devDependencies": { + "@commitlint/cli": "^8.3.5", + "@commitlint/config-angular": "^8.3.4", + "@types/chai": "^4.2.11", + "@types/mocha": "^7.0.2", + "@typescript-eslint/eslint-plugin": "^2.27.0", + "@typescript-eslint/eslint-plugin-tslint": "^2.27.0", + "@typescript-eslint/parser": "^2.27.0", + "@xml-conformance-suite/js": "^2.0.0", + "@xml-conformance-suite/mocha": "^2.0.0", + "@xml-conformance-suite/test-data": "^2.0.0", + "chai": "^4.2.0", + "conventional-changelog-cli": "^2.0.31", + "eslint": "^6.8.0", + "eslint-config-lddubeau-base": "^5.2.0", + "eslint-config-lddubeau-ts": "^1.1.7", + "eslint-import-resolver-typescript": "^2.0.0", + "eslint-plugin-import": "^2.20.2", + "eslint-plugin-jsx-a11y": "^6.2.3", + "eslint-plugin-prefer-arrow": "^1.2.0", + "eslint-plugin-react": "^7.19.0", + "eslint-plugin-simple-import-sort": "^5.0.2", + "husky": "^4.2.5", + "mocha": "^7.1.1", + "renovate-config-lddubeau": "^1.0.0", + "simple-dist-tag": "^1.0.2", + "ts-node": "^8.8.2", + "tsd": "^0.11.0", + "tslint": "^6.1.1", + "tslint-microsoft-contrib": "^6.2.0", + "typedoc": "^0.17.4", + "typescript": "^3.8.3" + }, + "dependencies": { + "xmlchars": "^2.2.0" + }, + "husky": { + "hooks": { + "commit-msg": "commitlint -E HUSKY_GIT_PARAMS" + } + } +} diff --git a/school/node_modules/saxes/saxes.d.ts b/school/node_modules/saxes/saxes.d.ts new file mode 100644 index 0000000..41c101f --- /dev/null +++ b/school/node_modules/saxes/saxes.d.ts @@ -0,0 +1,635 @@ +/** + * The list of supported events. + */ +export declare const EVENTS: readonly ["xmldecl", "text", "processinginstruction", "doctype", "comment", "opentagstart", "attribute", "opentag", "closetag", "cdata", "error", "end", "ready"]; +/** + * Event handler for the + * + * @param text The text data encountered by the parser. + * + */ +export declare type XMLDeclHandler = (decl: XMLDecl) => void; +/** + * Event handler for text data. + * + * @param text The text data encountered by the parser. + * + */ +export declare type TextHandler = (text: string) => void; +/** + * Event handler for processing instructions. + * + * @param data The target and body of the processing instruction. + */ +export declare type PIHandler = (data: { + target: string; + body: string; +}) => void; +/** + * Event handler for doctype. + * + * @param doctype The doctype contents. + */ +export declare type DoctypeHandler = (doctype: string) => void; +/** + * Event handler for comments. + * + * @param comment The comment contents. + */ +export declare type CommentHandler = (comment: string) => void; +/** + * Event handler for the start of an open tag. This is called as soon as we + * have a tag name. + * + * @param tag The tag. + */ +export declare type OpenTagStartHandler<O> = (tag: StartTagForOptions<O>) => void; +export declare type AttributeEventForOptions<O extends SaxesOptions> = O extends { + xmlns: true; +} ? SaxesAttributeNSIncomplete : O extends { + xmlns?: false | undefined; +} ? SaxesAttributePlain : SaxesAttribute; +/** + * Event handler for attributes. + */ +export declare type AttributeHandler<O> = (attribute: AttributeEventForOptions<O>) => void; +/** + * Event handler for an open tag. This is called when the open tag is + * complete. (We've encountered the ">" that ends the open tag.) + * + * @param tag The tag. + */ +export declare type OpenTagHandler<O> = (tag: TagForOptions<O>) => void; +/** + * Event handler for a close tag. Note that for self-closing tags, this is + * called right after ``opentag``. + * + * @param tag The tag. + */ +export declare type CloseTagHandler<O> = (tag: TagForOptions<O>) => void; +/** + * Event handler for a CDATA section. This is called when ending the + * CDATA section. + * + * @param cdata The contents of the CDATA section. + */ +export declare type CDataHandler = (cdata: string) => void; +/** + * Event handler for the stream end. This is called when the stream has been + * closed with ``close`` or by passing ``null`` to ``write``. + */ +export declare type EndHandler = () => void; +/** + * Event handler indicating parser readiness . This is called when the parser + * is ready to parse a new document. + */ +export declare type ReadyHandler = () => void; +/** + * Event handler indicating an error. + * + * @param err The error that occurred. + */ +export declare type ErrorHandler = (err: Error) => void; +export declare type EventName = (typeof EVENTS)[number]; +export declare type EventNameToHandler<O, N extends EventName> = { + "xmldecl": XMLDeclHandler; + "text": TextHandler; + "processinginstruction": PIHandler; + "doctype": DoctypeHandler; + "comment": CommentHandler; + "opentagstart": OpenTagStartHandler<O>; + "attribute": AttributeHandler<O>; + "opentag": OpenTagHandler<O>; + "closetag": CloseTagHandler<O>; + "cdata": CDataHandler; + "error": ErrorHandler; + "end": EndHandler; + "ready": ReadyHandler; +}[N]; +/** + * This interface defines the structure of attributes when the parser is + * processing namespaces (created with ``xmlns: true``). + */ +export interface SaxesAttributeNS { + /** + * The attribute's name. This is the combination of prefix and local name. + * For instance ``a:b="c"`` would have ``a:b`` for name. + */ + name: string; + /** + * The attribute's prefix. For instance ``a:b="c"`` would have ``"a"`` for + * ``prefix``. + */ + prefix: string; + /** + * The attribute's local name. For instance ``a:b="c"`` would have ``"b"`` for + * ``local``. + */ + local: string; + /** The namespace URI of this attribute. */ + uri: string; + /** The attribute's value. */ + value: string; +} +/** + * This is an attribute, as recorded by a parser which parses namespaces but + * prior to the URI being resolvable. This is what is passed to the attribute + * event handler. + */ +export declare type SaxesAttributeNSIncomplete = Exclude<SaxesAttributeNS, "uri">; +/** + * This interface defines the structure of attributes when the parser is + * NOT processing namespaces (created with ``xmlns: false``). + */ +export interface SaxesAttributePlain { + /** + * The attribute's name. + */ + name: string; + /** The attribute's value. */ + value: string; +} +/** + * A saxes attribute, with or without namespace information. + */ +export declare type SaxesAttribute = SaxesAttributeNS | SaxesAttributePlain; +/** + * This are the fields that MAY be present on a complete tag. + */ +export interface SaxesTag { + /** + * The tag's name. This is the combination of prefix and global name. For + * instance ``<a:b>`` would have ``"a:b"`` for ``name``. + */ + name: string; + /** + * A map of attribute name to attributes. If namespaces are tracked, the + * values in the map are attribute objects. Otherwise, they are strings. + */ + attributes: Record<string, SaxesAttributeNS> | Record<string, string>; + /** + * The namespace bindings in effect. + */ + ns?: Record<string, string>; + /** + * The tag's prefix. For instance ``<a:b>`` would have ``"a"`` for + * ``prefix``. Undefined if we do not track namespaces. + */ + prefix?: string; + /** + * The tag's local name. For instance ``<a:b>`` would + * have ``"b"`` for ``local``. Undefined if we do not track namespaces. + */ + local?: string; + /** + * The namespace URI of this tag. Undefined if we do not track namespaces. + */ + uri?: string; + /** Whether the tag is self-closing (e.g. ``<foo/>``). */ + isSelfClosing: boolean; +} +/** + * This type defines the fields that are present on a tag object when + * ``onopentagstart`` is called. This interface is namespace-agnostic. + */ +export declare type SaxesStartTag = Pick<SaxesTag, "name" | "attributes" | "ns">; +/** + * This type defines the fields that are present on a tag object when + * ``onopentagstart`` is called on a parser that does not processes namespaces. + */ +export declare type SaxesStartTagPlain = Pick<SaxesStartTag, "name" | "attributes">; +/** + * This type defines the fields that are present on a tag object when + * ``onopentagstart`` is called on a parser that does process namespaces. + */ +export declare type SaxesStartTagNS = Required<SaxesStartTag>; +/** + * This are the fields that are present on a complete tag produced by a parser + * that does process namespaces. + */ +export declare type SaxesTagNS = Required<SaxesTag> & { + attributes: Record<string, SaxesAttributeNS>; +}; +/** + * This are the fields that are present on a complete tag produced by a parser + * that does not process namespaces. + */ +export declare type SaxesTagPlain = Pick<SaxesTag, "name" | "attributes" | "isSelfClosing"> & { + attributes: Record<string, string>; +}; +/** + * An XML declaration. + */ +export interface XMLDecl { + /** The version specified by the XML declaration. */ + version?: string; + /** The encoding specified by the XML declaration. */ + encoding?: string; + /** The value of the standalone parameter */ + standalone?: string; +} +/** + * A callback for resolving name prefixes. + * + * @param prefix The prefix to check. + * + * @returns The URI corresponding to the prefix, if any. + */ +export declare type ResolvePrefix = (prefix: string) => string | undefined; +export interface CommonOptions { + /** Whether to accept XML fragments. Unset means ``false``. */ + fragment?: boolean; + /** Whether to track positions. Unset means ``true``. */ + position?: boolean; + /** + * A file name to use for error reporting. "File name" is a loose concept. You + * could use a URL to some resource, or any descriptive name you like. + */ + fileName?: string; +} +export interface NSOptions { + /** Whether to track namespaces. Unset means ``false``. */ + xmlns?: boolean; + /** + * A plain object whose key, value pairs define namespaces known before + * parsing the XML file. It is not legal to pass bindings for the namespaces + * ``"xml"`` or ``"xmlns"``. + */ + additionalNamespaces?: Record<string, string>; + /** + * A function that will be used if the parser cannot resolve a namespace + * prefix on its own. + */ + resolvePrefix?: ResolvePrefix; +} +export interface NSOptionsWithoutNamespaces extends NSOptions { + xmlns?: false; + additionalNamespaces?: undefined; + resolvePrefix?: undefined; +} +export interface NSOptionsWithNamespaces extends NSOptions { + xmlns: true; +} +export interface XMLVersionOptions { + /** + * The default XML version to use. If unspecified, and there is no XML + * encoding declaration, the default version is "1.0". + */ + defaultXMLVersion?: "1.0" | "1.1"; + /** + * A flag indicating whether to force the XML version used for parsing to the + * value of ``defaultXMLVersion``. When this flag is ``true``, + * ``defaultXMLVersion`` must be specified. If unspecified, the default value + * of this flag is ``false``. + */ + forceXMLVersion?: boolean; +} +export interface NoForcedXMLVersion extends XMLVersionOptions { + forceXMLVersion?: false; +} +export interface ForcedXMLVersion extends XMLVersionOptions { + forceXMLVersion: true; + defaultXMLVersion: Exclude<XMLVersionOptions["defaultXMLVersion"], undefined>; +} +/** + * The entire set of options supported by saxes. + */ +export declare type SaxesOptions = CommonOptions & NSOptions & XMLVersionOptions; +export declare type TagForOptions<O extends SaxesOptions> = O extends { + xmlns: true; +} ? SaxesTagNS : O extends { + xmlns?: false | undefined; +} ? SaxesTagPlain : SaxesTag; +export declare type StartTagForOptions<O extends SaxesOptions> = O extends { + xmlns: true; +} ? SaxesStartTagNS : O extends { + xmlns?: false | undefined; +} ? SaxesStartTagPlain : SaxesStartTag; +export declare class SaxesParser<O extends SaxesOptions = {}> { + private readonly fragmentOpt; + private readonly xmlnsOpt; + private readonly trackPosition; + private readonly fileName?; + private readonly nameStartCheck; + private readonly nameCheck; + private readonly isName; + private readonly ns; + private openWakaBang; + private text; + private name; + private piTarget; + private entity; + private q; + private tags; + private tag; + private topNS; + private chunk; + private chunkPosition; + private i; + private prevI; + private carriedFromPrevious?; + private forbiddenState; + private attribList; + private state; + private reportedTextBeforeRoot; + private reportedTextAfterRoot; + private closedRoot; + private sawRoot; + private xmlDeclPossible; + private xmlDeclExpects; + private entityReturnState?; + private processAttribs; + private positionAtNewLine; + private doctype; + private getCode; + private isChar; + private pushAttrib; + private _closed; + private currentXMLVersion; + private readonly stateTable; + private xmldeclHandler?; + private textHandler?; + private piHandler?; + private doctypeHandler?; + private commentHandler?; + private openTagStartHandler?; + private openTagHandler?; + private closeTagHandler?; + private cdataHandler?; + private errorHandler?; + private endHandler?; + private readyHandler?; + private attributeHandler?; + /** + * Indicates whether or not the parser is closed. If ``true``, wait for + * the ``ready`` event to write again. + */ + get closed(): boolean; + readonly opt: SaxesOptions; + /** + * The XML declaration for this document. + */ + xmlDecl: XMLDecl; + /** + * The line number of the next character to be read by the parser. This field + * is one-based. (The first line is numbered 1.) + */ + line: number; + /** + * The column number of the next character to be read by the parser. * + * This field is zero-based. (The first column is 0.) + * + * This field counts columns by *Unicode character*. Note that this *can* + * be different from the index of the character in a JavaScript string due + * to how JavaScript handles astral plane characters. + * + * See [[columnIndex]] for a number that corresponds to the JavaScript index. + */ + column: number; + /** + * A map of entity name to expansion. + */ + ENTITIES: Record<string, string>; + /** + * @param opt The parser options. + */ + constructor(opt?: O); + _init(): void; + /** + * The stream position the parser is currently looking at. This field is + * zero-based. + * + * This field is not based on counting Unicode characters but is to be + * interpreted as a plain index into a JavaScript string. + */ + get position(): number; + /** + * The column number of the next character to be read by the parser. * + * This field is zero-based. (The first column in a line is 0.) + * + * This field reports the index at which the next character would be in the + * line if the line were represented as a JavaScript string. Note that this + * *can* be different to a count based on the number of *Unicode characters* + * due to how JavaScript handles astral plane characters. + * + * See [[column]] for a number that corresponds to a count of Unicode + * characters. + */ + get columnIndex(): number; + /** + * Set an event listener on an event. The parser supports one handler per + * event type. If you try to set an event handler over an existing handler, + * the old handler is silently overwritten. + * + * @param name The event to listen to. + * + * @param handler The handler to set. + */ + on<N extends EventName>(name: N, handler: EventNameToHandler<O, N>): void; + /** + * Unset an event handler. + * + * @parma name The event to stop listening to. + */ + off(name: EventName): void; + /** + * Make an error object. The error object will have a message that contains + * the ``fileName`` option passed at the creation of the parser. If position + * tracking was turned on, it will also have line and column number + * information. + * + * @param message The message describing the error to report. + * + * @returns An error object with a properly formatted message. + */ + makeError(message: string): Error; + /** + * Report a parsing error. This method is made public so that client code may + * check for issues that are outside the scope of this project and can report + * errors. + * + * @param message The error to report. + * + * @returns this + */ + fail(message: string): this; + /** + * Write a XML data to the parser. + * + * @param chunk The XML data to write. + * + * @returns this + */ + write(chunk: string | {} | null): this; + /** + * Close the current stream. Perform final well-formedness checks and reset + * the parser tstate. + * + * @returns this + */ + close(): this; + /** + * Get a single code point out of the current chunk. This updates the current + * position if we do position tracking. + * + * This is the algorithm to use for XML 1.0. + * + * @returns The character read. + */ + private getCode10; + /** + * Get a single code point out of the current chunk. This updates the current + * position if we do position tracking. + * + * This is the algorithm to use for XML 1.1. + * + * @returns {number} The character read. + */ + private getCode11; + /** + * Like ``getCode`` but with the return value normalized so that ``NL`` is + * returned for ``NL_LIKE``. + */ + private getCodeNorm; + private unget; + /** + * Capture characters into a buffer until encountering one of a set of + * characters. + * + * @param chars An array of codepoints. Encountering a character in the array + * ends the capture. (``chars`` may safely contain ``NL``.) + * + * @return The character code that made the capture end, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + private captureTo; + /** + * Capture characters into a buffer until encountering a character. + * + * @param char The codepoint that ends the capture. **NOTE ``char`` MAY NOT + * CONTAIN ``NL``.** Passing ``NL`` will result in buggy behavior. + * + * @return ``true`` if we ran into the character. Otherwise, we ran into the + * end of the current chunk. + */ + private captureToChar; + /** + * Capture characters that satisfy ``isNameChar`` into the ``name`` field of + * this parser. + * + * @return The character code that made the test fail, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + private captureNameChars; + /** + * Skip white spaces. + * + * @return The character that ended the skip, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + private skipSpaces; + private setXMLVersion; + private sBegin; + private sBeginWhitespace; + private sDoctype; + private sDoctypeQuote; + private sDTD; + private sDTDQuoted; + private sDTDOpenWaka; + private sDTDOpenWakaBang; + private sDTDComment; + private sDTDCommentEnding; + private sDTDCommentEnded; + private sDTDPI; + private sDTDPIEnding; + private sText; + private sEntity; + private sOpenWaka; + private sOpenWakaBang; + private sComment; + private sCommentEnding; + private sCommentEnded; + private sCData; + private sCDataEnding; + private sCDataEnding2; + private sPIFirstChar; + private sPIRest; + private sPIBody; + private sPIEnding; + private sXMLDeclNameStart; + private sXMLDeclName; + private sXMLDeclEq; + private sXMLDeclValueStart; + private sXMLDeclValue; + private sXMLDeclSeparator; + private sXMLDeclEnding; + private sOpenTag; + private sOpenTagSlash; + private sAttrib; + private sAttribName; + private sAttribNameSawWhite; + private sAttribValue; + private sAttribValueQuoted; + private sAttribValueClosed; + private sAttribValueUnquoted; + private sCloseTag; + private sCloseTagSawWhite; + private handleTextInRoot; + private handleTextOutsideRoot; + private pushAttribNS; + private pushAttribPlain; + /** + * End parsing. This performs final well-formedness checks and resets the + * parser to a clean state. + * + * @returns this + */ + private end; + /** + * Resolve a namespace prefix. + * + * @param prefix The prefix to resolve. + * + * @returns The namespace URI or ``undefined`` if the prefix is not defined. + */ + resolve(prefix: string): string | undefined; + /** + * Parse a qname into its prefix and local name parts. + * + * @param name The name to parse + * + * @returns + */ + private qname; + private processAttribsNS; + private processAttribsPlain; + /** + * Handle a complete open tag. This parser code calls this once it has seen + * the whole tag. This method checks for well-formeness and then emits + * ``onopentag``. + */ + private openTag; + /** + * Handle a complete self-closing tag. This parser code calls this once it has + * seen the whole tag. This method checks for well-formeness and then emits + * ``onopentag`` and ``onclosetag``. + */ + private openSelfClosingTag; + /** + * Handle a complete close tag. This parser code calls this once it has seen + * the whole tag. This method checks for well-formeness and then emits + * ``onclosetag``. + */ + private closeTag; + /** + * Resolves an entity. Makes any necessary well-formedness checks. + * + * @param entity The entity to resolve. + * + * @returns The parsed entity. + */ + private parseEntity; +} diff --git a/school/node_modules/saxes/saxes.js b/school/node_modules/saxes/saxes.js new file mode 100644 index 0000000..0436871 --- /dev/null +++ b/school/node_modules/saxes/saxes.js @@ -0,0 +1,2064 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const ed5 = require("xmlchars/xml/1.0/ed5"); +const ed2 = require("xmlchars/xml/1.1/ed2"); +const NSed3 = require("xmlchars/xmlns/1.0/ed3"); +var isS = ed5.isS; +var isChar10 = ed5.isChar; +var isNameStartChar = ed5.isNameStartChar; +var isNameChar = ed5.isNameChar; +var S_LIST = ed5.S_LIST; +var NAME_RE = ed5.NAME_RE; +var isChar11 = ed2.isChar; +var isNCNameStartChar = NSed3.isNCNameStartChar; +var isNCNameChar = NSed3.isNCNameChar; +var NC_NAME_RE = NSed3.NC_NAME_RE; +const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"; +const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"; +const rootNS = { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + __proto__: null, + xml: XML_NAMESPACE, + xmlns: XMLNS_NAMESPACE, +}; +const XML_ENTITIES = { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + __proto__: null, + amp: "&", + gt: ">", + lt: "<", + quot: "\"", + apos: "'", +}; +// EOC: end-of-chunk +const EOC = -1; +const NL_LIKE = -2; +const S_BEGIN = 0; // Initial state. +const S_BEGIN_WHITESPACE = 1; // leading whitespace +const S_DOCTYPE = 2; // <!DOCTYPE +const S_DOCTYPE_QUOTE = 3; // <!DOCTYPE "//blah +const S_DTD = 4; // <!DOCTYPE "//blah" [ ... +const S_DTD_QUOTED = 5; // <!DOCTYPE "//blah" [ "foo +const S_DTD_OPEN_WAKA = 6; +const S_DTD_OPEN_WAKA_BANG = 7; +const S_DTD_COMMENT = 8; // <!-- +const S_DTD_COMMENT_ENDING = 9; // <!-- blah - +const S_DTD_COMMENT_ENDED = 10; // <!-- blah -- +const S_DTD_PI = 11; // <? +const S_DTD_PI_ENDING = 12; // <?hi "there" ? +const S_TEXT = 13; // general stuff +const S_ENTITY = 14; // & and such +const S_OPEN_WAKA = 15; // < +const S_OPEN_WAKA_BANG = 16; // <!... +const S_COMMENT = 17; // <!-- +const S_COMMENT_ENDING = 18; // <!-- blah - +const S_COMMENT_ENDED = 19; // <!-- blah -- +const S_CDATA = 20; // <![CDATA[ something +const S_CDATA_ENDING = 21; // ] +const S_CDATA_ENDING_2 = 22; // ]] +const S_PI_FIRST_CHAR = 23; // <?hi, first char +const S_PI_REST = 24; // <?hi, rest of the name +const S_PI_BODY = 25; // <?hi there +const S_PI_ENDING = 26; // <?hi "there" ? +const S_XML_DECL_NAME_START = 27; // <?xml +const S_XML_DECL_NAME = 28; // <?xml foo +const S_XML_DECL_EQ = 29; // <?xml foo= +const S_XML_DECL_VALUE_START = 30; // <?xml foo= +const S_XML_DECL_VALUE = 31; // <?xml foo="bar" +const S_XML_DECL_SEPARATOR = 32; // <?xml foo="bar" +const S_XML_DECL_ENDING = 33; // <?xml ... ? +const S_OPEN_TAG = 34; // <strong +const S_OPEN_TAG_SLASH = 35; // <strong / +const S_ATTRIB = 36; // <a +const S_ATTRIB_NAME = 37; // <a foo +const S_ATTRIB_NAME_SAW_WHITE = 38; // <a foo _ +const S_ATTRIB_VALUE = 39; // <a foo= +const S_ATTRIB_VALUE_QUOTED = 40; // <a foo="bar +const S_ATTRIB_VALUE_CLOSED = 41; // <a foo="bar" +const S_ATTRIB_VALUE_UNQUOTED = 42; // <a foo=bar +const S_CLOSE_TAG = 43; // </a +const S_CLOSE_TAG_SAW_WHITE = 44; // </a > +const TAB = 9; +const NL = 0xA; +const CR = 0xD; +const SPACE = 0x20; +const BANG = 0x21; +const DQUOTE = 0x22; +const AMP = 0x26; +const SQUOTE = 0x27; +const MINUS = 0x2D; +const FORWARD_SLASH = 0x2F; +const SEMICOLON = 0x3B; +const LESS = 0x3C; +const EQUAL = 0x3D; +const GREATER = 0x3E; +const QUESTION = 0x3F; +const OPEN_BRACKET = 0x5B; +const CLOSE_BRACKET = 0x5D; +const NEL = 0x85; +const LS = 0x2028; // Line Separator +const isQuote = (c) => c === DQUOTE || c === SQUOTE; +const QUOTES = [DQUOTE, SQUOTE]; +const DOCTYPE_TERMINATOR = [...QUOTES, OPEN_BRACKET, GREATER]; +const DTD_TERMINATOR = [...QUOTES, LESS, CLOSE_BRACKET]; +const XML_DECL_NAME_TERMINATOR = [EQUAL, QUESTION, ...S_LIST]; +const ATTRIB_VALUE_UNQUOTED_TERMINATOR = [...S_LIST, GREATER, AMP, LESS]; +function nsPairCheck(parser, prefix, uri) { + switch (prefix) { + case "xml": + if (uri !== XML_NAMESPACE) { + parser.fail(`xml prefix must be bound to ${XML_NAMESPACE}.`); + } + break; + case "xmlns": + if (uri !== XMLNS_NAMESPACE) { + parser.fail(`xmlns prefix must be bound to ${XMLNS_NAMESPACE}.`); + } + break; + default: + } + switch (uri) { + case XMLNS_NAMESPACE: + parser.fail(prefix === "" ? + `the default namespace may not be set to ${uri}.` : + `may not assign a prefix (even "xmlns") to the URI \ +${XMLNS_NAMESPACE}.`); + break; + case XML_NAMESPACE: + switch (prefix) { + case "xml": + // Assinging the XML namespace to "xml" is fine. + break; + case "": + parser.fail(`the default namespace may not be set to ${uri}.`); + break; + default: + parser.fail("may not assign the xml namespace to another prefix."); + } + break; + default: + } +} +function nsMappingCheck(parser, mapping) { + for (const local of Object.keys(mapping)) { + nsPairCheck(parser, local, mapping[local]); + } +} +const isNCName = (name) => NC_NAME_RE.test(name); +const isName = (name) => NAME_RE.test(name); +const FORBIDDEN_START = 0; +const FORBIDDEN_BRACKET = 1; +const FORBIDDEN_BRACKET_BRACKET = 2; +/** + * The list of supported events. + */ +exports.EVENTS = [ + "xmldecl", + "text", + "processinginstruction", + "doctype", + "comment", + "opentagstart", + "attribute", + "opentag", + "closetag", + "cdata", + "error", + "end", + "ready", +]; +const EVENT_NAME_TO_HANDLER_NAME = { + xmldecl: "xmldeclHandler", + text: "textHandler", + processinginstruction: "piHandler", + doctype: "doctypeHandler", + comment: "commentHandler", + opentagstart: "openTagStartHandler", + attribute: "attributeHandler", + opentag: "openTagHandler", + closetag: "closeTagHandler", + cdata: "cdataHandler", + error: "errorHandler", + end: "endHandler", + ready: "readyHandler", +}; +class SaxesParser { + /** + * @param opt The parser options. + */ + constructor(opt) { + this.opt = opt !== null && opt !== void 0 ? opt : {}; + this.fragmentOpt = !!this.opt.fragment; + const xmlnsOpt = this.xmlnsOpt = !!this.opt.xmlns; + this.trackPosition = this.opt.position !== false; + this.fileName = this.opt.fileName; + if (xmlnsOpt) { + // This is the function we use to perform name checks on PIs and entities. + // When namespaces are used, colons are not allowed in PI target names or + // entity names. So the check depends on whether namespaces are used. See: + // + // https://www.w3.org/XML/xml-names-19990114-errata.html + // NE08 + // + this.nameStartCheck = isNCNameStartChar; + this.nameCheck = isNCNameChar; + this.isName = isNCName; + // eslint-disable-next-line @typescript-eslint/unbound-method + this.processAttribs = this.processAttribsNS; + // eslint-disable-next-line @typescript-eslint/unbound-method + this.pushAttrib = this.pushAttribNS; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this.ns = Object.assign({ __proto__: null }, rootNS); + const additional = this.opt.additionalNamespaces; + if (additional != null) { + nsMappingCheck(this, additional); + Object.assign(this.ns, additional); + } + } + else { + this.nameStartCheck = isNameStartChar; + this.nameCheck = isNameChar; + this.isName = isName; + // eslint-disable-next-line @typescript-eslint/unbound-method + this.processAttribs = this.processAttribsPlain; + // eslint-disable-next-line @typescript-eslint/unbound-method + this.pushAttrib = this.pushAttribPlain; + } + // + // The order of the members in this table needs to correspond to the state + // numbers given to the states that correspond to the methods being recorded + // here. + // + this.stateTable = [ + /* eslint-disable @typescript-eslint/unbound-method */ + this.sBegin, + this.sBeginWhitespace, + this.sDoctype, + this.sDoctypeQuote, + this.sDTD, + this.sDTDQuoted, + this.sDTDOpenWaka, + this.sDTDOpenWakaBang, + this.sDTDComment, + this.sDTDCommentEnding, + this.sDTDCommentEnded, + this.sDTDPI, + this.sDTDPIEnding, + this.sText, + this.sEntity, + this.sOpenWaka, + this.sOpenWakaBang, + this.sComment, + this.sCommentEnding, + this.sCommentEnded, + this.sCData, + this.sCDataEnding, + this.sCDataEnding2, + this.sPIFirstChar, + this.sPIRest, + this.sPIBody, + this.sPIEnding, + this.sXMLDeclNameStart, + this.sXMLDeclName, + this.sXMLDeclEq, + this.sXMLDeclValueStart, + this.sXMLDeclValue, + this.sXMLDeclSeparator, + this.sXMLDeclEnding, + this.sOpenTag, + this.sOpenTagSlash, + this.sAttrib, + this.sAttribName, + this.sAttribNameSawWhite, + this.sAttribValue, + this.sAttribValueQuoted, + this.sAttribValueClosed, + this.sAttribValueUnquoted, + this.sCloseTag, + this.sCloseTagSawWhite, + ]; + this._init(); + } + /** + * Indicates whether or not the parser is closed. If ``true``, wait for + * the ``ready`` event to write again. + */ + get closed() { + return this._closed; + } + _init() { + var _a; + this.openWakaBang = ""; + this.text = ""; + this.name = ""; + this.piTarget = ""; + this.entity = ""; + this.q = null; + this.tags = []; + this.tag = null; + this.topNS = null; + this.chunk = ""; + this.chunkPosition = 0; + this.i = 0; + this.prevI = 0; + this.carriedFromPrevious = undefined; + this.forbiddenState = FORBIDDEN_START; + this.attribList = []; + // The logic is organized so as to minimize the need to check + // this.opt.fragment while parsing. + const { fragmentOpt } = this; + this.state = fragmentOpt ? S_TEXT : S_BEGIN; + // We want these to be all true if we are dealing with a fragment. + this.reportedTextBeforeRoot = this.reportedTextAfterRoot = this.closedRoot = + this.sawRoot = fragmentOpt; + // An XML declaration is intially possible only when parsing whole + // documents. + this.xmlDeclPossible = !fragmentOpt; + this.xmlDeclExpects = ["version"]; + this.entityReturnState = undefined; + let { defaultXMLVersion } = this.opt; + if (defaultXMLVersion === undefined) { + if (this.opt.forceXMLVersion === true) { + throw new Error("forceXMLVersion set but defaultXMLVersion is not set"); + } + defaultXMLVersion = "1.0"; + } + this.setXMLVersion(defaultXMLVersion); + this.positionAtNewLine = 0; + this.doctype = false; + this._closed = false; + this.xmlDecl = { + version: undefined, + encoding: undefined, + standalone: undefined, + }; + this.line = 1; + this.column = 0; + this.ENTITIES = Object.create(XML_ENTITIES); + // eslint-disable-next-line no-unused-expressions + (_a = this.readyHandler) === null || _a === void 0 ? void 0 : _a.call(this); + } + /** + * The stream position the parser is currently looking at. This field is + * zero-based. + * + * This field is not based on counting Unicode characters but is to be + * interpreted as a plain index into a JavaScript string. + */ + get position() { + return this.chunkPosition + this.i; + } + /** + * The column number of the next character to be read by the parser. * + * This field is zero-based. (The first column in a line is 0.) + * + * This field reports the index at which the next character would be in the + * line if the line were represented as a JavaScript string. Note that this + * *can* be different to a count based on the number of *Unicode characters* + * due to how JavaScript handles astral plane characters. + * + * See [[column]] for a number that corresponds to a count of Unicode + * characters. + */ + get columnIndex() { + return this.position - this.positionAtNewLine; + } + /** + * Set an event listener on an event. The parser supports one handler per + * event type. If you try to set an event handler over an existing handler, + * the old handler is silently overwritten. + * + * @param name The event to listen to. + * + * @param handler The handler to set. + */ + on(name, handler) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this[EVENT_NAME_TO_HANDLER_NAME[name]] = handler; + } + /** + * Unset an event handler. + * + * @parma name The event to stop listening to. + */ + off(name) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + this[EVENT_NAME_TO_HANDLER_NAME[name]] = undefined; + } + /** + * Make an error object. The error object will have a message that contains + * the ``fileName`` option passed at the creation of the parser. If position + * tracking was turned on, it will also have line and column number + * information. + * + * @param message The message describing the error to report. + * + * @returns An error object with a properly formatted message. + */ + makeError(message) { + var _a; + let msg = (_a = this.fileName) !== null && _a !== void 0 ? _a : ""; + if (this.trackPosition) { + if (msg.length > 0) { + msg += ":"; + } + msg += `${this.line}:${this.column}`; + } + if (msg.length > 0) { + msg += ": "; + } + return new Error(msg + message); + } + /** + * Report a parsing error. This method is made public so that client code may + * check for issues that are outside the scope of this project and can report + * errors. + * + * @param message The error to report. + * + * @returns this + */ + fail(message) { + const err = this.makeError(message); + const handler = this.errorHandler; + if (handler === undefined) { + throw err; + } + else { + handler(err); + } + return this; + } + /** + * Write a XML data to the parser. + * + * @param chunk The XML data to write. + * + * @returns this + */ + write(chunk) { + if (this.closed) { + return this.fail("cannot write after close; assign an onready handler."); + } + let end = false; + if (chunk === null) { + // We cannot return immediately because carriedFromPrevious may need + // processing. + end = true; + chunk = ""; + } + else if (typeof chunk === "object") { + chunk = chunk.toString(); + } + // We checked if performing a pre-decomposition of the string into an array + // of single complete characters (``Array.from(chunk)``) would be faster + // than the current repeated calls to ``charCodeAt``. As of August 2018, it + // isn't. (There may be Node-specific code that would perform faster than + // ``Array.from`` but don't want to be dependent on Node.) + if (this.carriedFromPrevious !== undefined) { + // The previous chunk had char we must carry over. + chunk = `${this.carriedFromPrevious}${chunk}`; + this.carriedFromPrevious = undefined; + } + let limit = chunk.length; + const lastCode = chunk.charCodeAt(limit - 1); + if (!end && + // A trailing CR or surrogate must be carried over to the next + // chunk. + (lastCode === CR || (lastCode >= 0xD800 && lastCode <= 0xDBFF))) { + // The chunk ends with a character that must be carried over. We cannot + // know how to handle it until we get the next chunk or the end of the + // stream. So save it for later. + this.carriedFromPrevious = chunk[limit - 1]; + limit--; + chunk = chunk.slice(0, limit); + } + const { stateTable } = this; + this.chunk = chunk; + this.i = 0; + while (this.i < limit) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + stateTable[this.state].call(this); + } + this.chunkPosition += limit; + return end ? this.end() : this; + } + /** + * Close the current stream. Perform final well-formedness checks and reset + * the parser tstate. + * + * @returns this + */ + close() { + return this.write(null); + } + /** + * Get a single code point out of the current chunk. This updates the current + * position if we do position tracking. + * + * This is the algorithm to use for XML 1.0. + * + * @returns The character read. + */ + getCode10() { + const { chunk, i } = this; + this.prevI = i; + // Yes, we do this instead of doing this.i++. Doing it this way, we do not + // read this.i again, which is a bit faster. + this.i = i + 1; + if (i >= chunk.length) { + return EOC; + } + // Using charCodeAt and handling the surrogates ourselves is faster + // than using codePointAt. + const code = chunk.charCodeAt(i); + this.column++; + if (code < 0xD800) { + if (code >= SPACE || code === TAB) { + return code; + } + switch (code) { + case NL: + this.line++; + this.column = 0; + this.positionAtNewLine = this.position; + return NL; + case CR: + // We may get NaN if we read past the end of the chunk, which is fine. + if (chunk.charCodeAt(i + 1) === NL) { + // A \r\n sequence is converted to \n so we have to skip over the + // next character. We already know it has a size of 1 so ++ is fine + // here. + this.i = i + 2; + } + // Otherwise, a \r is just converted to \n, so we don't have to skip + // ahead. + // In either case, \r becomes \n. + this.line++; + this.column = 0; + this.positionAtNewLine = this.position; + return NL_LIKE; + default: + // If we get here, then code < SPACE and it is not NL CR or TAB. + this.fail("disallowed character."); + return code; + } + } + if (code > 0xDBFF) { + // This is a specialized version of isChar10 that takes into account + // that in this context code > 0xDBFF and code <= 0xFFFF. So it does not + // test cases that don't need testing. + if (!(code >= 0xE000 && code <= 0xFFFD)) { + this.fail("disallowed character."); + } + return code; + } + const final = 0x10000 + ((code - 0xD800) * 0x400) + + (chunk.charCodeAt(i + 1) - 0xDC00); + this.i = i + 2; + // This is a specialized version of isChar10 that takes into account that in + // this context necessarily final >= 0x10000. + if (final > 0x10FFFF) { + this.fail("disallowed character."); + } + return final; + } + /** + * Get a single code point out of the current chunk. This updates the current + * position if we do position tracking. + * + * This is the algorithm to use for XML 1.1. + * + * @returns {number} The character read. + */ + getCode11() { + const { chunk, i } = this; + this.prevI = i; + // Yes, we do this instead of doing this.i++. Doing it this way, we do not + // read this.i again, which is a bit faster. + this.i = i + 1; + if (i >= chunk.length) { + return EOC; + } + // Using charCodeAt and handling the surrogates ourselves is faster + // than using codePointAt. + const code = chunk.charCodeAt(i); + this.column++; + if (code < 0xD800) { + if ((code > 0x1F && code < 0x7F) || (code > 0x9F && code !== LS) || + code === TAB) { + return code; + } + switch (code) { + case NL: // 0xA + this.line++; + this.column = 0; + this.positionAtNewLine = this.position; + return NL; + case CR: { // 0xD + // We may get NaN if we read past the end of the chunk, which is + // fine. + const next = chunk.charCodeAt(i + 1); + if (next === NL || next === NEL) { + // A CR NL or CR NEL sequence is converted to NL so we have to skip + // over the next character. We already know it has a size of 1. + this.i = i + 2; + } + // Otherwise, a CR is just converted to NL, no skip. + } + /* yes, fall through */ + case NEL: // 0x85 + case LS: // Ox2028 + this.line++; + this.column = 0; + this.positionAtNewLine = this.position; + return NL_LIKE; + default: + this.fail("disallowed character."); + return code; + } + } + if (code > 0xDBFF) { + // This is a specialized version of isCharAndNotRestricted that takes into + // account that in this context code > 0xDBFF and code <= 0xFFFF. So it + // does not test cases that don't need testing. + if (!(code >= 0xE000 && code <= 0xFFFD)) { + this.fail("disallowed character."); + } + return code; + } + const final = 0x10000 + ((code - 0xD800) * 0x400) + + (chunk.charCodeAt(i + 1) - 0xDC00); + this.i = i + 2; + // This is a specialized version of isCharAndNotRestricted that takes into + // account that in this context necessarily final >= 0x10000. + if (final > 0x10FFFF) { + this.fail("disallowed character."); + } + return final; + } + /** + * Like ``getCode`` but with the return value normalized so that ``NL`` is + * returned for ``NL_LIKE``. + */ + getCodeNorm() { + const c = this.getCode(); + return c === NL_LIKE ? NL : c; + } + unget() { + this.i = this.prevI; + this.column--; + } + /** + * Capture characters into a buffer until encountering one of a set of + * characters. + * + * @param chars An array of codepoints. Encountering a character in the array + * ends the capture. (``chars`` may safely contain ``NL``.) + * + * @return The character code that made the capture end, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + captureTo(chars) { + let { i: start } = this; + const { chunk } = this; + // eslint-disable-next-line no-constant-condition + while (true) { + const c = this.getCode(); + const isNLLike = c === NL_LIKE; + const final = isNLLike ? NL : c; + if (final === EOC || chars.includes(final)) { + this.text += chunk.slice(start, this.prevI); + return final; + } + if (isNLLike) { + this.text += `${chunk.slice(start, this.prevI)}\n`; + start = this.i; + } + } + } + /** + * Capture characters into a buffer until encountering a character. + * + * @param char The codepoint that ends the capture. **NOTE ``char`` MAY NOT + * CONTAIN ``NL``.** Passing ``NL`` will result in buggy behavior. + * + * @return ``true`` if we ran into the character. Otherwise, we ran into the + * end of the current chunk. + */ + captureToChar(char) { + let { i: start } = this; + const { chunk } = this; + // eslint-disable-next-line no-constant-condition + while (true) { + let c = this.getCode(); + switch (c) { + case NL_LIKE: + this.text += `${chunk.slice(start, this.prevI)}\n`; + start = this.i; + c = NL; + break; + case EOC: + this.text += chunk.slice(start); + return false; + default: + } + if (c === char) { + this.text += chunk.slice(start, this.prevI); + return true; + } + } + } + /** + * Capture characters that satisfy ``isNameChar`` into the ``name`` field of + * this parser. + * + * @return The character code that made the test fail, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + captureNameChars() { + const { chunk, i: start } = this; + // eslint-disable-next-line no-constant-condition + while (true) { + const c = this.getCode(); + if (c === EOC) { + this.name += chunk.slice(start); + return EOC; + } + // NL is not a name char so we don't have to test specifically for it. + if (!isNameChar(c)) { + this.name += chunk.slice(start, this.prevI); + return c === NL_LIKE ? NL : c; + } + } + } + /** + * Skip white spaces. + * + * @return The character that ended the skip, or ``EOC`` if we hit + * the end of the chunk. The return value cannot be NL_LIKE: NL is returned + * instead. + */ + skipSpaces() { + // eslint-disable-next-line no-constant-condition + while (true) { + const c = this.getCodeNorm(); + if (c === EOC || !isS(c)) { + return c; + } + } + } + setXMLVersion(version) { + this.currentXMLVersion = version; + /* eslint-disable @typescript-eslint/unbound-method */ + if (version === "1.0") { + this.isChar = isChar10; + this.getCode = this.getCode10; + } + else { + this.isChar = isChar11; + this.getCode = this.getCode11; + } + /* eslint-enable @typescript-eslint/unbound-method */ + } + // STATE ENGINE METHODS + // This needs to be a state separate from S_BEGIN_WHITESPACE because we want + // to be sure never to come back to this state later. + sBegin() { + // We are essentially peeking at the first character of the chunk. Since + // S_BEGIN can be in effect only when we start working on the first chunk, + // the index at which we must look is necessarily 0. Note also that the + // following test does not depend on decoding surrogates. + // If the initial character is 0xFEFF, ignore it. + if (this.chunk.charCodeAt(0) === 0xFEFF) { + this.i++; + this.column++; + } + this.state = S_BEGIN_WHITESPACE; + } + sBeginWhitespace() { + // We need to know whether we've encountered spaces or not because as soon + // as we run into a space, an XML declaration is no longer possible. Rather + // than slow down skipSpaces even in places where we don't care whether it + // skipped anything or not, we check whether prevI is equal to the value of + // i from before we skip spaces. + const iBefore = this.i; + const c = this.skipSpaces(); + if (this.prevI !== iBefore) { + this.xmlDeclPossible = false; + } + switch (c) { + case LESS: + this.state = S_OPEN_WAKA; + // We could naively call closeText but in this state, it is not normal + // to have text be filled with any data. + if (this.text.length !== 0) { + throw new Error("no-empty text at start"); + } + break; + case EOC: + break; + default: + this.unget(); + this.state = S_TEXT; + this.xmlDeclPossible = false; + } + } + sDoctype() { + var _a; + const c = this.captureTo(DOCTYPE_TERMINATOR); + switch (c) { + case GREATER: { + // eslint-disable-next-line no-unused-expressions + (_a = this.doctypeHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text); + this.text = ""; + this.state = S_TEXT; + this.doctype = true; // just remember that we saw it. + break; + } + case EOC: + break; + default: + this.text += String.fromCodePoint(c); + if (c === OPEN_BRACKET) { + this.state = S_DTD; + } + else if (isQuote(c)) { + this.state = S_DOCTYPE_QUOTE; + this.q = c; + } + } + } + sDoctypeQuote() { + const q = this.q; + if (this.captureToChar(q)) { + this.text += String.fromCodePoint(q); + this.q = null; + this.state = S_DOCTYPE; + } + } + sDTD() { + const c = this.captureTo(DTD_TERMINATOR); + if (c === EOC) { + return; + } + this.text += String.fromCodePoint(c); + if (c === CLOSE_BRACKET) { + this.state = S_DOCTYPE; + } + else if (c === LESS) { + this.state = S_DTD_OPEN_WAKA; + } + else if (isQuote(c)) { + this.state = S_DTD_QUOTED; + this.q = c; + } + } + sDTDQuoted() { + const q = this.q; + if (this.captureToChar(q)) { + this.text += String.fromCodePoint(q); + this.state = S_DTD; + this.q = null; + } + } + sDTDOpenWaka() { + const c = this.getCodeNorm(); + this.text += String.fromCodePoint(c); + switch (c) { + case BANG: + this.state = S_DTD_OPEN_WAKA_BANG; + this.openWakaBang = ""; + break; + case QUESTION: + this.state = S_DTD_PI; + break; + default: + this.state = S_DTD; + } + } + sDTDOpenWakaBang() { + const char = String.fromCodePoint(this.getCodeNorm()); + const owb = this.openWakaBang += char; + this.text += char; + if (owb !== "-") { + this.state = owb === "--" ? S_DTD_COMMENT : S_DTD; + this.openWakaBang = ""; + } + } + sDTDComment() { + if (this.captureToChar(MINUS)) { + this.text += "-"; + this.state = S_DTD_COMMENT_ENDING; + } + } + sDTDCommentEnding() { + const c = this.getCodeNorm(); + this.text += String.fromCodePoint(c); + this.state = c === MINUS ? S_DTD_COMMENT_ENDED : S_DTD_COMMENT; + } + sDTDCommentEnded() { + const c = this.getCodeNorm(); + this.text += String.fromCodePoint(c); + if (c === GREATER) { + this.state = S_DTD; + } + else { + this.fail("malformed comment."); + // <!-- blah -- bloo --> will be recorded as + // a comment of " blah -- bloo " + this.state = S_DTD_COMMENT; + } + } + sDTDPI() { + if (this.captureToChar(QUESTION)) { + this.text += "?"; + this.state = S_DTD_PI_ENDING; + } + } + sDTDPIEnding() { + const c = this.getCodeNorm(); + this.text += String.fromCodePoint(c); + if (c === GREATER) { + this.state = S_DTD; + } + } + sText() { + // + // We did try a version of saxes where the S_TEXT state was split in two + // states: one for text inside the root element, and one for text + // outside. This was avoiding having to test this.tags.length to decide + // what implementation to actually use. + // + // Peformance testing on gigabyte-size files did not show any advantage to + // using the two states solution instead of the current one. Conversely, it + // made the code a bit more complicated elsewhere. For instance, a comment + // can appear before the root element so when a comment ended it was + // necessary to determine whether to return to the S_TEXT state or to the + // new text-outside-root state. + // + if (this.tags.length !== 0) { + this.handleTextInRoot(); + } + else { + this.handleTextOutsideRoot(); + } + } + sEntity() { + // This is essentially a specialized version of captureToChar(SEMICOLON...) + let { i: start } = this; + const { chunk } = this; + // eslint-disable-next-line no-labels, no-restricted-syntax + loop: + // eslint-disable-next-line no-constant-condition + while (true) { + switch (this.getCode()) { + case NL_LIKE: + this.entity += `${chunk.slice(start, this.prevI)}\n`; + start = this.i; + break; + case SEMICOLON: { + const { entityReturnState } = this; + const entity = this.entity + chunk.slice(start, this.prevI); + this.state = entityReturnState; + let parsed; + if (entity === "") { + this.fail("empty entity name."); + parsed = "&;"; + } + else { + parsed = this.parseEntity(entity); + this.entity = ""; + } + if (entityReturnState !== S_TEXT || this.textHandler !== undefined) { + this.text += parsed; + } + // eslint-disable-next-line no-labels + break loop; + } + case EOC: + this.entity += chunk.slice(start); + // eslint-disable-next-line no-labels + break loop; + default: + } + } + } + sOpenWaka() { + // Reminder: a state handler is called with at least one character + // available in the current chunk. So the first call to get code inside of + // a state handler cannot return ``EOC``. That's why we don't test + // for it. + const c = this.getCode(); + // either a /, ?, !, or text is coming next. + if (isNameStartChar(c)) { + this.state = S_OPEN_TAG; + this.unget(); + this.xmlDeclPossible = false; + } + else { + switch (c) { + case FORWARD_SLASH: + this.state = S_CLOSE_TAG; + this.xmlDeclPossible = false; + break; + case BANG: + this.state = S_OPEN_WAKA_BANG; + this.openWakaBang = ""; + this.xmlDeclPossible = false; + break; + case QUESTION: + this.state = S_PI_FIRST_CHAR; + break; + default: + this.fail("disallowed character in tag name"); + this.state = S_TEXT; + this.xmlDeclPossible = false; + } + } + } + sOpenWakaBang() { + this.openWakaBang += String.fromCodePoint(this.getCodeNorm()); + switch (this.openWakaBang) { + case "[CDATA[": + if (!this.sawRoot && !this.reportedTextBeforeRoot) { + this.fail("text data outside of root node."); + this.reportedTextBeforeRoot = true; + } + if (this.closedRoot && !this.reportedTextAfterRoot) { + this.fail("text data outside of root node."); + this.reportedTextAfterRoot = true; + } + this.state = S_CDATA; + this.openWakaBang = ""; + break; + case "--": + this.state = S_COMMENT; + this.openWakaBang = ""; + break; + case "DOCTYPE": + this.state = S_DOCTYPE; + if (this.doctype || this.sawRoot) { + this.fail("inappropriately located doctype declaration."); + } + this.openWakaBang = ""; + break; + default: + // 7 happens to be the maximum length of the string that can possibly + // match one of the cases above. + if (this.openWakaBang.length >= 7) { + this.fail("incorrect syntax."); + } + } + } + sComment() { + if (this.captureToChar(MINUS)) { + this.state = S_COMMENT_ENDING; + } + } + sCommentEnding() { + var _a; + const c = this.getCodeNorm(); + if (c === MINUS) { + this.state = S_COMMENT_ENDED; + // eslint-disable-next-line no-unused-expressions + (_a = this.commentHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text); + this.text = ""; + } + else { + this.text += `-${String.fromCodePoint(c)}`; + this.state = S_COMMENT; + } + } + sCommentEnded() { + const c = this.getCodeNorm(); + if (c !== GREATER) { + this.fail("malformed comment."); + // <!-- blah -- bloo --> will be recorded as + // a comment of " blah -- bloo " + this.text += `--${String.fromCodePoint(c)}`; + this.state = S_COMMENT; + } + else { + this.state = S_TEXT; + } + } + sCData() { + if (this.captureToChar(CLOSE_BRACKET)) { + this.state = S_CDATA_ENDING; + } + } + sCDataEnding() { + const c = this.getCodeNorm(); + if (c === CLOSE_BRACKET) { + this.state = S_CDATA_ENDING_2; + } + else { + this.text += `]${String.fromCodePoint(c)}`; + this.state = S_CDATA; + } + } + sCDataEnding2() { + var _a; + const c = this.getCodeNorm(); + switch (c) { + case GREATER: { + // eslint-disable-next-line no-unused-expressions + (_a = this.cdataHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text); + this.text = ""; + this.state = S_TEXT; + break; + } + case CLOSE_BRACKET: + this.text += "]"; + break; + default: + this.text += `]]${String.fromCodePoint(c)}`; + this.state = S_CDATA; + } + } + // We need this separate state to check the first character fo the pi target + // with this.nameStartCheck which allows less characters than this.nameCheck. + sPIFirstChar() { + const c = this.getCodeNorm(); + // This is first because in the case where the file is well-formed this is + // the branch taken. We optimize for well-formedness. + if (this.nameStartCheck(c)) { + this.piTarget += String.fromCodePoint(c); + this.state = S_PI_REST; + } + else if (c === QUESTION || isS(c)) { + this.fail("processing instruction without a target."); + this.state = c === QUESTION ? S_PI_ENDING : S_PI_BODY; + } + else { + this.fail("disallowed character in processing instruction name."); + this.piTarget += String.fromCodePoint(c); + this.state = S_PI_REST; + } + } + sPIRest() { + // Capture characters into a piTarget while ``this.nameCheck`` run on the + // character read returns true. + const { chunk, i: start } = this; + // eslint-disable-next-line no-constant-condition + while (true) { + const c = this.getCodeNorm(); + if (c === EOC) { + this.piTarget += chunk.slice(start); + return; + } + // NL cannot satisfy this.nameCheck so we don't have to test specifically + // for it. + if (!this.nameCheck(c)) { + this.piTarget += chunk.slice(start, this.prevI); + const isQuestion = c === QUESTION; + if (isQuestion || isS(c)) { + if (this.piTarget === "xml") { + if (!this.xmlDeclPossible) { + this.fail("an XML declaration must be at the start of the document."); + } + this.state = isQuestion ? S_XML_DECL_ENDING : S_XML_DECL_NAME_START; + } + else { + this.state = isQuestion ? S_PI_ENDING : S_PI_BODY; + } + } + else { + this.fail("disallowed character in processing instruction name."); + this.piTarget += String.fromCodePoint(c); + } + break; + } + } + } + sPIBody() { + if (this.text.length === 0) { + const c = this.getCodeNorm(); + if (c === QUESTION) { + this.state = S_PI_ENDING; + } + else if (!isS(c)) { + this.text = String.fromCodePoint(c); + } + } + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + else if (this.captureToChar(QUESTION)) { + this.state = S_PI_ENDING; + } + } + sPIEnding() { + var _a; + const c = this.getCodeNorm(); + if (c === GREATER) { + const { piTarget } = this; + if (piTarget.toLowerCase() === "xml") { + this.fail("the XML declaration must appear at the start of the document."); + } + // eslint-disable-next-line no-unused-expressions + (_a = this.piHandler) === null || _a === void 0 ? void 0 : _a.call(this, { + target: piTarget, + body: this.text, + }); + this.piTarget = this.text = ""; + this.state = S_TEXT; + } + else if (c === QUESTION) { + // We ran into ?? as part of a processing instruction. We initially took + // the first ? as a sign that the PI was ending, but it is not. So we have + // to add it to the body but we take the new ? as a sign that the PI is + // ending. + this.text += "?"; + } + else { + this.text += `?${String.fromCodePoint(c)}`; + this.state = S_PI_BODY; + } + this.xmlDeclPossible = false; + } + sXMLDeclNameStart() { + const c = this.skipSpaces(); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + // It is valid to go to S_XML_DECL_ENDING from this state. + this.state = S_XML_DECL_ENDING; + return; + } + if (c !== EOC) { + this.state = S_XML_DECL_NAME; + this.name = String.fromCodePoint(c); + } + } + sXMLDeclName() { + const c = this.captureTo(XML_DECL_NAME_TERMINATOR); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + this.state = S_XML_DECL_ENDING; + this.name += this.text; + this.text = ""; + this.fail("XML declaration is incomplete."); + return; + } + if (!(isS(c) || c === EQUAL)) { + return; + } + this.name += this.text; + this.text = ""; + if (!this.xmlDeclExpects.includes(this.name)) { + switch (this.name.length) { + case 0: + this.fail("did not expect any more name/value pairs."); + break; + case 1: + this.fail(`expected the name ${this.xmlDeclExpects[0]}.`); + break; + default: + this.fail(`expected one of ${this.xmlDeclExpects.join(", ")}`); + } + } + this.state = c === EQUAL ? S_XML_DECL_VALUE_START : S_XML_DECL_EQ; + } + sXMLDeclEq() { + const c = this.getCodeNorm(); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + this.state = S_XML_DECL_ENDING; + this.fail("XML declaration is incomplete."); + return; + } + if (isS(c)) { + return; + } + if (c !== EQUAL) { + this.fail("value required."); + } + this.state = S_XML_DECL_VALUE_START; + } + sXMLDeclValueStart() { + const c = this.getCodeNorm(); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + this.state = S_XML_DECL_ENDING; + this.fail("XML declaration is incomplete."); + return; + } + if (isS(c)) { + return; + } + if (!isQuote(c)) { + this.fail("value must be quoted."); + this.q = SPACE; + } + else { + this.q = c; + } + this.state = S_XML_DECL_VALUE; + } + sXMLDeclValue() { + const c = this.captureTo([this.q, QUESTION]); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + this.state = S_XML_DECL_ENDING; + this.text = ""; + this.fail("XML declaration is incomplete."); + return; + } + if (c === EOC) { + return; + } + const value = this.text; + this.text = ""; + switch (this.name) { + case "version": { + this.xmlDeclExpects = ["encoding", "standalone"]; + const version = value; + this.xmlDecl.version = version; + // This is the test specified by XML 1.0 but it is fine for XML 1.1. + if (!/^1\.[0-9]+$/.test(version)) { + this.fail("version number must match /^1\\.[0-9]+$/."); + } + // When forceXMLVersion is set, the XML declaration is ignored. + else if (!this.opt.forceXMLVersion) { + this.setXMLVersion(version); + } + break; + } + case "encoding": + if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(value)) { + this.fail("encoding value must match \ +/^[A-Za-z0-9][A-Za-z0-9._-]*$/."); + } + this.xmlDeclExpects = ["standalone"]; + this.xmlDecl.encoding = value; + break; + case "standalone": + if (value !== "yes" && value !== "no") { + this.fail("standalone value must match \"yes\" or \"no\"."); + } + this.xmlDeclExpects = []; + this.xmlDecl.standalone = value; + break; + default: + // We don't need to raise an error here since we've already raised one + // when checking what name was expected. + } + this.name = ""; + this.state = S_XML_DECL_SEPARATOR; + } + sXMLDeclSeparator() { + const c = this.getCodeNorm(); + // The question mark character is not valid inside any of the XML + // declaration name/value pairs. + if (c === QUESTION) { + // It is valid to go to S_XML_DECL_ENDING from this state. + this.state = S_XML_DECL_ENDING; + return; + } + if (!isS(c)) { + this.fail("whitespace required."); + this.unget(); + } + this.state = S_XML_DECL_NAME_START; + } + sXMLDeclEnding() { + var _a; + const c = this.getCodeNorm(); + if (c === GREATER) { + if (this.piTarget !== "xml") { + this.fail("processing instructions are not allowed before root."); + } + else if (this.name !== "version" && + this.xmlDeclExpects.includes("version")) { + this.fail("XML declaration must contain a version."); + } + // eslint-disable-next-line no-unused-expressions + (_a = this.xmldeclHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.xmlDecl); + this.name = ""; + this.piTarget = this.text = ""; + this.state = S_TEXT; + } + else { + // We got here because the previous character was a ?, but the question + // mark character is not valid inside any of the XML declaration + // name/value pairs. + this.fail("The character ? is disallowed anywhere in XML declarations."); + } + this.xmlDeclPossible = false; + } + sOpenTag() { + var _a; + const c = this.captureNameChars(); + if (c === EOC) { + return; + } + const tag = this.tag = { + name: this.name, + attributes: Object.create(null), + }; + this.name = ""; + if (this.xmlnsOpt) { + this.topNS = tag.ns = Object.create(null); + } + // eslint-disable-next-line no-unused-expressions + (_a = this.openTagStartHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag); + this.sawRoot = true; + if (!this.fragmentOpt && this.closedRoot) { + this.fail("documents may contain only one root."); + } + switch (c) { + case GREATER: + this.openTag(); + break; + case FORWARD_SLASH: + this.state = S_OPEN_TAG_SLASH; + break; + default: + if (!isS(c)) { + this.fail("disallowed character in tag name."); + } + this.state = S_ATTRIB; + } + } + sOpenTagSlash() { + if (this.getCode() === GREATER) { + this.openSelfClosingTag(); + } + else { + this.fail("forward-slash in opening tag not followed by >."); + this.state = S_ATTRIB; + } + } + sAttrib() { + const c = this.skipSpaces(); + if (c === EOC) { + return; + } + if (isNameStartChar(c)) { + this.unget(); + this.state = S_ATTRIB_NAME; + } + else if (c === GREATER) { + this.openTag(); + } + else if (c === FORWARD_SLASH) { + this.state = S_OPEN_TAG_SLASH; + } + else { + this.fail("disallowed character in attribute name."); + } + } + sAttribName() { + const c = this.captureNameChars(); + if (c === EQUAL) { + this.state = S_ATTRIB_VALUE; + } + else if (isS(c)) { + this.state = S_ATTRIB_NAME_SAW_WHITE; + } + else if (c === GREATER) { + this.fail("attribute without value."); + this.pushAttrib(this.name, this.name); + this.name = this.text = ""; + this.openTag(); + } + else if (c !== EOC) { + this.fail("disallowed character in attribute name."); + } + } + sAttribNameSawWhite() { + const c = this.skipSpaces(); + switch (c) { + case EOC: + return; + case EQUAL: + this.state = S_ATTRIB_VALUE; + break; + default: + this.fail("attribute without value."); + // Should we do this??? + // this.tag.attributes[this.name] = ""; + this.text = ""; + this.name = ""; + if (c === GREATER) { + this.openTag(); + } + else if (isNameStartChar(c)) { + this.unget(); + this.state = S_ATTRIB_NAME; + } + else { + this.fail("disallowed character in attribute name."); + this.state = S_ATTRIB; + } + } + } + sAttribValue() { + const c = this.getCodeNorm(); + if (isQuote(c)) { + this.q = c; + this.state = S_ATTRIB_VALUE_QUOTED; + } + else if (!isS(c)) { + this.fail("unquoted attribute value."); + this.state = S_ATTRIB_VALUE_UNQUOTED; + this.unget(); + } + } + sAttribValueQuoted() { + // We deliberately do not use captureTo here. The specialized code we use + // here is faster than using captureTo. + const { q, chunk } = this; + let { i: start } = this; + // eslint-disable-next-line no-constant-condition + while (true) { + switch (this.getCode()) { + case q: + this.pushAttrib(this.name, this.text + chunk.slice(start, this.prevI)); + this.name = this.text = ""; + this.q = null; + this.state = S_ATTRIB_VALUE_CLOSED; + return; + case AMP: + this.text += chunk.slice(start, this.prevI); + this.state = S_ENTITY; + this.entityReturnState = S_ATTRIB_VALUE_QUOTED; + return; + case NL: + case NL_LIKE: + case TAB: + this.text += `${chunk.slice(start, this.prevI)} `; + start = this.i; + break; + case LESS: + this.text += chunk.slice(start, this.prevI); + this.fail("disallowed character."); + return; + case EOC: + this.text += chunk.slice(start); + return; + default: + } + } + } + sAttribValueClosed() { + const c = this.getCodeNorm(); + if (isS(c)) { + this.state = S_ATTRIB; + } + else if (c === GREATER) { + this.openTag(); + } + else if (c === FORWARD_SLASH) { + this.state = S_OPEN_TAG_SLASH; + } + else if (isNameStartChar(c)) { + this.fail("no whitespace between attributes."); + this.unget(); + this.state = S_ATTRIB_NAME; + } + else { + this.fail("disallowed character in attribute name."); + } + } + sAttribValueUnquoted() { + // We don't do anything regarding EOL or space handling for unquoted + // attributes. We already have failed by the time we get here, and the + // contract that saxes upholds states that upon failure, it is not safe to + // rely on the data passed to event handlers (other than + // ``onerror``). Passing "bad" data is not a problem. + const c = this.captureTo(ATTRIB_VALUE_UNQUOTED_TERMINATOR); + switch (c) { + case AMP: + this.state = S_ENTITY; + this.entityReturnState = S_ATTRIB_VALUE_UNQUOTED; + break; + case LESS: + this.fail("disallowed character."); + break; + case EOC: + break; + default: + if (this.text.includes("]]>")) { + this.fail("the string \"]]>\" is disallowed in char data."); + } + this.pushAttrib(this.name, this.text); + this.name = this.text = ""; + if (c === GREATER) { + this.openTag(); + } + else { + this.state = S_ATTRIB; + } + } + } + sCloseTag() { + const c = this.captureNameChars(); + if (c === GREATER) { + this.closeTag(); + } + else if (isS(c)) { + this.state = S_CLOSE_TAG_SAW_WHITE; + } + else if (c !== EOC) { + this.fail("disallowed character in closing tag."); + } + } + sCloseTagSawWhite() { + switch (this.skipSpaces()) { + case GREATER: + this.closeTag(); + break; + case EOC: + break; + default: + this.fail("disallowed character in closing tag."); + } + } + // END OF STATE ENGINE METHODS + handleTextInRoot() { + // This is essentially a specialized version of captureTo which is optimized + // for performing the ]]> check. A previous version of this code, checked + // ``this.text`` for the presence of ]]>. It simplified the code but was + // very costly when character data contained a lot of entities to be parsed. + // + // Since we are using a specialized loop, we also keep track of the presence + // of ]]> in text data. The sequence ]]> is forbidden to appear as-is. + // + let { i: start, forbiddenState } = this; + const { chunk, textHandler: handler } = this; + // eslint-disable-next-line no-labels, no-restricted-syntax + scanLoop: + // eslint-disable-next-line no-constant-condition + while (true) { + switch (this.getCode()) { + case LESS: { + this.state = S_OPEN_WAKA; + if (handler !== undefined) { + const { text } = this; + const slice = chunk.slice(start, this.prevI); + if (text.length !== 0) { + handler(text + slice); + this.text = ""; + } + else if (slice.length !== 0) { + handler(slice); + } + } + forbiddenState = FORBIDDEN_START; + // eslint-disable-next-line no-labels + break scanLoop; + } + case AMP: + this.state = S_ENTITY; + this.entityReturnState = S_TEXT; + if (handler !== undefined) { + this.text += chunk.slice(start, this.prevI); + } + forbiddenState = FORBIDDEN_START; + // eslint-disable-next-line no-labels + break scanLoop; + case CLOSE_BRACKET: + switch (forbiddenState) { + case FORBIDDEN_START: + forbiddenState = FORBIDDEN_BRACKET; + break; + case FORBIDDEN_BRACKET: + forbiddenState = FORBIDDEN_BRACKET_BRACKET; + break; + case FORBIDDEN_BRACKET_BRACKET: + break; + default: + throw new Error("impossible state"); + } + break; + case GREATER: + if (forbiddenState === FORBIDDEN_BRACKET_BRACKET) { + this.fail("the string \"]]>\" is disallowed in char data."); + } + forbiddenState = FORBIDDEN_START; + break; + case NL_LIKE: + if (handler !== undefined) { + this.text += `${chunk.slice(start, this.prevI)}\n`; + } + start = this.i; + forbiddenState = FORBIDDEN_START; + break; + case EOC: + if (handler !== undefined) { + this.text += chunk.slice(start); + } + // eslint-disable-next-line no-labels + break scanLoop; + default: + forbiddenState = FORBIDDEN_START; + } + } + this.forbiddenState = forbiddenState; + } + handleTextOutsideRoot() { + // This is essentially a specialized version of captureTo which is optimized + // for a specialized task. We keep track of the presence of non-space + // characters in the text since these are errors when appearing outside the + // document root element. + let { i: start } = this; + const { chunk, textHandler: handler } = this; + let nonSpace = false; + // eslint-disable-next-line no-labels, no-restricted-syntax + outRootLoop: + // eslint-disable-next-line no-constant-condition + while (true) { + const code = this.getCode(); + switch (code) { + case LESS: { + this.state = S_OPEN_WAKA; + if (handler !== undefined) { + const { text } = this; + const slice = chunk.slice(start, this.prevI); + if (text.length !== 0) { + handler(text + slice); + this.text = ""; + } + else if (slice.length !== 0) { + handler(slice); + } + } + // eslint-disable-next-line no-labels + break outRootLoop; + } + case AMP: + this.state = S_ENTITY; + this.entityReturnState = S_TEXT; + if (handler !== undefined) { + this.text += chunk.slice(start, this.prevI); + } + nonSpace = true; + // eslint-disable-next-line no-labels + break outRootLoop; + case NL_LIKE: + if (handler !== undefined) { + this.text += `${chunk.slice(start, this.prevI)}\n`; + } + start = this.i; + break; + case EOC: + if (handler !== undefined) { + this.text += chunk.slice(start); + } + // eslint-disable-next-line no-labels + break outRootLoop; + default: + if (!isS(code)) { + nonSpace = true; + } + } + } + if (!nonSpace) { + return; + } + // We use the reportedTextBeforeRoot and reportedTextAfterRoot flags + // to avoid reporting errors for every single character that is out of + // place. + if (!this.sawRoot && !this.reportedTextBeforeRoot) { + this.fail("text data outside of root node."); + this.reportedTextBeforeRoot = true; + } + if (this.closedRoot && !this.reportedTextAfterRoot) { + this.fail("text data outside of root node."); + this.reportedTextAfterRoot = true; + } + } + pushAttribNS(name, value) { + var _a; + const { prefix, local } = this.qname(name); + const attr = { name, prefix, local, value }; + this.attribList.push(attr); + // eslint-disable-next-line no-unused-expressions + (_a = this.attributeHandler) === null || _a === void 0 ? void 0 : _a.call(this, attr); + if (prefix === "xmlns") { + const trimmed = value.trim(); + if (this.currentXMLVersion === "1.0" && trimmed === "") { + this.fail("invalid attempt to undefine prefix in XML 1.0"); + } + this.topNS[local] = trimmed; + nsPairCheck(this, local, trimmed); + } + else if (name === "xmlns") { + const trimmed = value.trim(); + this.topNS[""] = trimmed; + nsPairCheck(this, "", trimmed); + } + } + pushAttribPlain(name, value) { + var _a; + const attr = { name, value }; + this.attribList.push(attr); + // eslint-disable-next-line no-unused-expressions + (_a = this.attributeHandler) === null || _a === void 0 ? void 0 : _a.call(this, attr); + } + /** + * End parsing. This performs final well-formedness checks and resets the + * parser to a clean state. + * + * @returns this + */ + end() { + var _a, _b; + if (!this.sawRoot) { + this.fail("document must contain a root element."); + } + const { tags } = this; + while (tags.length > 0) { + const tag = tags.pop(); + this.fail(`unclosed tag: ${tag.name}`); + } + if ((this.state !== S_BEGIN) && (this.state !== S_TEXT)) { + this.fail("unexpected end."); + } + const { text } = this; + if (text.length !== 0) { + // eslint-disable-next-line no-unused-expressions + (_a = this.textHandler) === null || _a === void 0 ? void 0 : _a.call(this, text); + this.text = ""; + } + this._closed = true; + // eslint-disable-next-line no-unused-expressions + (_b = this.endHandler) === null || _b === void 0 ? void 0 : _b.call(this); + this._init(); + return this; + } + /** + * Resolve a namespace prefix. + * + * @param prefix The prefix to resolve. + * + * @returns The namespace URI or ``undefined`` if the prefix is not defined. + */ + resolve(prefix) { + var _a, _b; + let uri = this.topNS[prefix]; + if (uri !== undefined) { + return uri; + } + const { tags } = this; + for (let index = tags.length - 1; index >= 0; index--) { + uri = tags[index].ns[prefix]; + if (uri !== undefined) { + return uri; + } + } + uri = this.ns[prefix]; + if (uri !== undefined) { + return uri; + } + return (_b = (_a = this.opt).resolvePrefix) === null || _b === void 0 ? void 0 : _b.call(_a, prefix); + } + /** + * Parse a qname into its prefix and local name parts. + * + * @param name The name to parse + * + * @returns + */ + qname(name) { + // This is faster than using name.split(":"). + const colon = name.indexOf(":"); + if (colon === -1) { + return { prefix: "", local: name }; + } + const local = name.slice(colon + 1); + const prefix = name.slice(0, colon); + if (prefix === "" || local === "" || local.includes(":")) { + this.fail(`malformed name: ${name}.`); + } + return { prefix, local }; + } + processAttribsNS() { + var _a; + const { attribList } = this; + const tag = this.tag; + { + // add namespace info to tag + const { prefix, local } = this.qname(tag.name); + tag.prefix = prefix; + tag.local = local; + const uri = tag.uri = (_a = this.resolve(prefix)) !== null && _a !== void 0 ? _a : ""; + if (prefix !== "") { + if (prefix === "xmlns") { + this.fail("tags may not have \"xmlns\" as prefix."); + } + if (uri === "") { + this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`); + tag.uri = prefix; + } + } + } + if (attribList.length === 0) { + return; + } + const { attributes } = tag; + const seen = new Set(); + // Note: do not apply default ns to attributes: + // http://www.w3.org/TR/REC-xml-names/#defaulting + for (const attr of attribList) { + const { name, prefix, local } = attr; + let uri; + let eqname; + if (prefix === "") { + uri = name === "xmlns" ? XMLNS_NAMESPACE : ""; + eqname = name; + } + else { + uri = this.resolve(prefix); + // if there's any attributes with an undefined namespace, + // then fail on them now. + if (uri === undefined) { + this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`); + uri = prefix; + } + eqname = `{${uri}}${local}`; + } + if (seen.has(eqname)) { + this.fail(`duplicate attribute: ${eqname}.`); + } + seen.add(eqname); + attr.uri = uri; + attributes[name] = attr; + } + this.attribList = []; + } + processAttribsPlain() { + const { attribList } = this; + // eslint-disable-next-line prefer-destructuring + const attributes = this.tag.attributes; + for (const { name, value } of attribList) { + if (attributes[name] !== undefined) { + this.fail(`duplicate attribute: ${name}.`); + } + attributes[name] = value; + } + this.attribList = []; + } + /** + * Handle a complete open tag. This parser code calls this once it has seen + * the whole tag. This method checks for well-formeness and then emits + * ``onopentag``. + */ + openTag() { + var _a; + this.processAttribs(); + const { tags } = this; + const tag = this.tag; + tag.isSelfClosing = false; + // There cannot be any pending text here due to the onopentagstart that was + // necessarily emitted before we get here. So we do not check text. + // eslint-disable-next-line no-unused-expressions + (_a = this.openTagHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag); + tags.push(tag); + this.state = S_TEXT; + this.name = ""; + } + /** + * Handle a complete self-closing tag. This parser code calls this once it has + * seen the whole tag. This method checks for well-formeness and then emits + * ``onopentag`` and ``onclosetag``. + */ + openSelfClosingTag() { + var _a, _b, _c; + this.processAttribs(); + const { tags } = this; + const tag = this.tag; + tag.isSelfClosing = true; + // There cannot be any pending text here due to the onopentagstart that was + // necessarily emitted before we get here. So we do not check text. + // eslint-disable-next-line no-unused-expressions + (_a = this.openTagHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag); + // eslint-disable-next-line no-unused-expressions + (_b = this.closeTagHandler) === null || _b === void 0 ? void 0 : _b.call(this, tag); + const top = this.tag = (_c = tags[tags.length - 1]) !== null && _c !== void 0 ? _c : null; + if (top === null) { + this.closedRoot = true; + } + this.state = S_TEXT; + this.name = ""; + } + /** + * Handle a complete close tag. This parser code calls this once it has seen + * the whole tag. This method checks for well-formeness and then emits + * ``onclosetag``. + */ + closeTag() { + const { tags, name } = this; + // Our state after this will be S_TEXT, no matter what, and we can clear + // tagName now. + this.state = S_TEXT; + this.name = ""; + if (name === "") { + this.fail("weird empty close tag."); + this.text += "</>"; + return; + } + const handler = this.closeTagHandler; + let l = tags.length; + while (l-- > 0) { + const tag = this.tag = tags.pop(); + this.topNS = tag.ns; + // eslint-disable-next-line no-unused-expressions + handler === null || handler === void 0 ? void 0 : handler(tag); + if (tag.name === name) { + break; + } + this.fail("unexpected close tag."); + } + if (l === 0) { + this.closedRoot = true; + } + else if (l < 0) { + this.fail(`unmatched closing tag: ${name}.`); + this.text += `</${name}>`; + } + } + /** + * Resolves an entity. Makes any necessary well-formedness checks. + * + * @param entity The entity to resolve. + * + * @returns The parsed entity. + */ + parseEntity(entity) { + // startsWith would be significantly slower for this test. + // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with + if (entity[0] !== "#") { + const defined = this.ENTITIES[entity]; + if (defined !== undefined) { + return defined; + } + this.fail(this.isName(entity) ? "undefined entity." : + "disallowed character in entity name."); + return `&${entity};`; + } + let num = NaN; + if (entity[1] === "x" && /^#x[0-9a-f]+$/i.test(entity)) { + num = parseInt(entity.slice(2), 16); + } + else if (/^#[0-9]+$/.test(entity)) { + num = parseInt(entity.slice(1), 10); + } + // The character reference is required to match the CHAR production. + if (!this.isChar(num)) { + this.fail("malformed character entity."); + return `&${entity};`; + } + return String.fromCodePoint(num); + } +} +exports.SaxesParser = SaxesParser; +//# sourceMappingURL=saxes.js.map
\ No newline at end of file diff --git a/school/node_modules/saxes/saxes.js.map b/school/node_modules/saxes/saxes.js.map new file mode 100644 index 0000000..deb2820 --- /dev/null +++ b/school/node_modules/saxes/saxes.js.map @@ -0,0 +1 @@ +{"version":3,"file":"saxes.js","sourceRoot":"","sources":["../../src/saxes.ts"],"names":[],"mappings":"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"}
\ No newline at end of file |