├── CONTRIBUTING.md
├── DESIGN.md
├── LICENSE
├── README.md
└── text-encode-transform.js


/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to contribute
 2 | 
 3 | We'd love to accept your patches and contributions to this project. If your
 4 | patch fixes bugs or changes behaviour, please include a test for the change.
 5 | 
 6 | Code style broadly follows the [Google JavaScript Style
 7 | Guide](https://google.github.io/styleguide/javascriptguide.xml). Javascript
 8 | dialect is ES6. Lines are 80 columns, indents are 2 spaces. Use single-quotes
 9 | for strings.
10 | 
11 | ## Contributor License Agreement
12 | 
13 | Contributions to this project must be accompanied by a Contributor License
14 | Agreement. You (or your employer) retain the copyright to your contribution,
15 | this simply gives us permission to use and redistribute your contributions as
16 | part of the project. Head over to <https://cla.developers.google.com/> to see
17 | your current agreements on file or to sign a new one.
18 | 
19 | You generally only need to submit a CLA once, so if you've already submitted one
20 | (even if it was for a different project), you probably don't need to do it
21 | again.
22 | 
23 | ## Code reviews
24 | 
25 | All submissions, including submissions by project members, require review. We
26 | use GitHub pull requests for this purpose. Consult [GitHub Help] for more
27 | information on using pull requests.
28 | 
29 | [GitHub Help]: https://help.github.com/articles/about-pull-requests/
30 | 


--------------------------------------------------------------------------------
/DESIGN.md:
--------------------------------------------------------------------------------
  1 | # Text Encoder Streaming Polyfill
  2 | ricea@chromium.org - last updated 31 October 2018
  3 | 
  4 | The existing TextEncoder and TextDecoder APIs provide conversions between bytes
  5 | and strings for Javascript in the browser. The Streams API is an API for
  6 | processing streams of data in the browser. It is proposed to create new
  7 | TextEncoderStream and TextDecoderStream APIs so that text encoding and decoding
  8 | can be done with the Streams API.
  9 | 
 10 | ## Motivation
 11 | 
 12 | Integration between the Streams API and the Encoding API is useful, however it
 13 | is not implemented in browsers yet. This polyfill provides a bridge to allow
 14 | using the new APIs in the meantime.
 15 | 
 16 | ## Requirements & Scope
 17 | 
 18 | ### Requirements
 19 |  - The polyfill must work in browsers that have implementations of the
 20 |    prerequisite APIs.
 21 |  - The polyfill should implement the expected API with the expected semantics.
 22 |  - The polyfill should provide acceptable performance.
 23 |  - The polyfill should be convenient to use.
 24 |  - The polyfill should function within Workers as well as document
 25 |    environments.
 26 |  - The polyfill should be close enough to the intended standard to function
 27 |    identically in non-pathological cases.
 28 | 
 29 | ### Non-requirements
 30 |  - The polyfill doesn't need to support environments that do not have the
 31 |    TextEncoder and TextDecoder APIs.
 32 |  - The polyfill doesn't need to support environments that do not support
 33 |    ReadableStream and WritableStream.
 34 |  - The polyfill doesn't need to provide the maximum possible performance.
 35 |  - The polyfill doesn't need to support versions of JavaScript prior to ES6.
 36 |  - The polyfill doesn't need to have perfect fidelity to the standard.
 37 | 
 38 | ## Assumptions
 39 | 
 40 | - All the browsers that meet the other requirements will support ES6.
 41 | - The polyfill can be modified as standardisation proceeds.
 42 | 
 43 | ## Detailed Design
 44 | 
 45 | ### Interface
 46 | 
 47 | The polyfill will be used by importing it into the page using a `<script>` tag
 48 | prior to using the functionality. In Worker environments it will be imported
 49 | using `importScripts()`.
 50 | 
 51 | The interface provided is similar to [TextEncoder and TextDecoder as specified
 52 | in the Encoding Standard](https://encoding.spec.whatwg.org/#api), but instead of
 53 | `encode()` and `decode()` methods, `readable` and `writable` getters permit it
 54 | to function as a [transform stream](https://streams.spec.whatwg.org/#ts-model)
 55 | and be used with the [Streams pipeThrough
 56 | API](https://streams.spec.whatwg.org/#rs-pipe-through).
 57 | 
 58 | ### Technology
 59 | 
 60 | The polyfill builds upon [The Web
 61 | Platform](http://tess.oconnor.cx/2009/05/what-the-web-platform-is) and is
 62 | implemented in [JavaScript](http://www.ecma-international.org/ecma-262/6.0/).
 63 | 
 64 | ### Implementation
 65 | 
 66 | New classes TextEncoderStream and TextDecoderStream are created. Almost all
 67 | functionality is delegated: `readable` and `writable` getters are delegated to a
 68 | TransformStream that is created in the constructor, and the other getters are
 69 | delegated to an underlying TextEncoder or TextDecoder that is also created in
 70 | the constructor.
 71 | 
 72 | The TransformStream and TextEncoder or Decoder are stored on the objects using
 73 | symbols for encapsulation.
 74 | 
 75 | ### Scalability
 76 | 
 77 | The time taken to transform text to bytes and vice-versa is proportional to the
 78 | number of bytes. The memory used is proportional to the size of the largest
 79 | chunk, which is roughly constant for any given use case.
 80 | 
 81 | ### Monitoring
 82 | 
 83 | There will be no explicit monitoring.
 84 | 
 85 | ### Redundancy & Reliability
 86 | 
 87 | The polyfill applies the same redundancy practices as the web platform as a
 88 | whole. Generally, it is up to developers or frameworks to provide redundancy,
 89 | and this API is agnostic to the approach taken.
 90 | 
 91 | The TextDecoder API provides various options for error handling, and these are
 92 | inherited by this API.
 93 | 
 94 | ### Security
 95 | 
 96 | No security implications.
 97 | 
 98 | ### Privacy
 99 | 
100 | No privacy implications.
101 | 
102 | ## Open Questions & Risks
103 | 
104 | None known.
105 | 
106 | ## Tasks & Estimates
107 | 
108 | 1. Write one short JavaScript file. Estimate: 1 hour.
109 | 2. Write some tests. Estimate: 1 hour.
110 | 3. Test the JavaScript against the tests. Estimate: 20 minutes.
111 | 
112 | ## Future Improvements
113 | 
114 |  - Performance may be improved if there is demand.
115 |  - A build system for integration with JavaScript bundling systems and minifiers
116 |    may be added.
117 | 
118 | ## Similar Projects
119 | 
120 | None known.
121 | 
122 | ## Other Solutions Considered
123 | 
124 |  - Supporting ES5 would have been possible, but would have made the code harder
125 |    to understand.
126 |  - A previous implementation wrapped the existing TextEncoder and TextDecoder
127 |    APIs. This was considerably simpler and easier to understand, but was
128 |    inefficient.
129 |  - For strict compliance, the `readable` and `writable` getters should verify
130 |    that `this` is of the correct type before attaching a TransformStream to
131 |    it. However, in the context of a polyfill this would interfere with
132 |    extensibility and so the check is intentionally omitted.
133 |  - Similarly, no attempt is made to defend against changes to the global object
134 |    made by other code on the same page.
135 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Text Encode Transformations
 2 | 
 3 | ## Overview
 4 | 
 5 | This is a polyfill for the transform streams TextEncoderStream and
 6 | TextDecoderStream. It is based on the TextEncoderStream and TextDecoderStream
 7 | interfaces from the Encoding Standard:
 8 | 
 9 | https://encoding.spec.whatwg.org/#interface-textdecoderstream
10 | 
11 | It is intended for experimentation with the standard.
12 | 
13 | ## Requirements
14 | 
15 | You need implementations of TextEncoder, TextDecoder, ReadableStream,
16 | WritableStream and TransformStream, either natively or via polyfill.
17 | 
18 | ## How to use
19 | 
20 | Include the polyfill in the page:
21 | 
22 | ```javascript
23 | <script src="text-encode-transform.js">
24 | ```
25 | 
26 | It can also be used in a Worker environment:
27 | 
28 | ```javascript
29 | importScripts('text-encode-transform.js');
30 | ```
31 | 
32 | Then you can use it in a pipe like this:
33 | 
34 | ```javascript
35 | byteSource
36 |   .pipeThrough(new TextDecoderStream())
37 |   .pipeTo(textDestination);
38 | ```
39 | 
40 | Any arguments that the TextDecoder constructor normally accepts will also work
41 | when used as a stream transform.
42 | 
43 | TextEncoderStream works the same way:
44 | 
45 | ```javascript
46 | textSource
47 |   .pipeThrough(new TextEncoderStream())
48 |   .pipeTo(byteDestination);
49 | ```
50 | 
51 | ## Tests
52 | 
53 | Tests have moved to the main web-platform-tests repository at
54 | https://github.com/web-platform-tests/wpt/tree/master/encoding/streams.
55 | 
56 | ### See also
57 | 
58 |  - [Encoding Living Standard][]
59 |  - [Streams Living Standard][]
60 | 
61 | [Encoding Living Standard]: https://encoding.spec.whatwg.org/
62 | [Streams Living Standard]: https://streams.spec.whatwg.org/
63 | 
64 | ### Disclaimer
65 | 
66 | This is not an official Google product.
67 | 


--------------------------------------------------------------------------------
/text-encode-transform.js:
--------------------------------------------------------------------------------
  1 | // Copyright 2016 Google Inc.
  2 | //
  3 | // Licensed under the Apache License, Version 2.0 (the "License");
  4 | // you may not use this file except in compliance with the License.
  5 | // You may obtain a copy of the License at
  6 | //
  7 | //     http://www.apache.org/licenses/LICENSE-2.0
  8 | //
  9 | // Unless required by applicable law or agreed to in writing, software
 10 | // distributed under the License is distributed on an "AS IS" BASIS,
 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | // See the License for the specific language governing permissions and
 13 | // limitations under the License.
 14 | 
 15 | // Polyfill for TextEncoderStream and TextDecoderStream
 16 | 
 17 | (function() {
 18 |   'use strict';
 19 | 
 20 |   if (typeof self.TextEncoderStream === 'function' &&
 21 |       typeof self.TextDecoderStream === 'function') {
 22 |     // The constructors exist. Assume that they work and don't replace them.
 23 |     return;
 24 |   }
 25 | 
 26 |   if (typeof self.TextEncoder !== 'function') {
 27 |     throw new ReferenceError('TextEncoder implementation required');
 28 |   }
 29 | 
 30 |   if (typeof self.TextDecoder !== 'function') {
 31 |     throw new ReferenceError('TextDecoder implementation required');
 32 |   }
 33 | 
 34 |   // These symbols end up being different for every realm, so mixing objects
 35 |   // created in one realm with methods created in another fails.
 36 |   const codec = Symbol('codec');
 37 |   const transform = Symbol('transform');
 38 | 
 39 |   class TextEncoderStream {
 40 |     constructor() {
 41 |       this[codec] = new TextEncoder();
 42 |       this[transform] =
 43 |           new TransformStream(new TextEncodeTransformer(this[codec]));
 44 |     }
 45 |   }
 46 | 
 47 |   class TextDecoderStream {
 48 |     constructor(label = undefined, options = undefined) {
 49 |       this[codec] = new TextDecoder(label, options);
 50 |       this[transform] = new TransformStream(
 51 |           new TextDecodeTransformer(this[codec]));
 52 |     }
 53 |   }
 54 | 
 55 |   // ECMAScript class syntax will create getters that are non-enumerable, but we
 56 |   // need them to be enumerable in WebIDL-style, so we add them manually.
 57 |   // "readable" and "writable" are always delegated to the TransformStream
 58 |   // object. Properties specified in |properties| are delegated to the
 59 |   // underlying TextEncoder or TextDecoder.
 60 |   function addDelegatingProperties(prototype, properties) {
 61 |     for (const transformProperty of ['readable', 'writable']) {
 62 |       addGetter(prototype, transformProperty, function() {
 63 |         return this[transform][transformProperty];
 64 |       });
 65 |     }
 66 | 
 67 |     for (const codecProperty of properties) {
 68 |       addGetter(prototype, codecProperty, function() {
 69 |         return this[codec][codecProperty];
 70 |       });
 71 |     }
 72 |   }
 73 | 
 74 |   function addGetter(prototype, property, getter) {
 75 |     Object.defineProperty(prototype, property,
 76 |                           {
 77 |                             configurable: true,
 78 |                             enumerable: true,
 79 |                             get: getter
 80 |                           });
 81 |   }
 82 | 
 83 |   addDelegatingProperties(TextEncoderStream.prototype, ['encoding']);
 84 |   addDelegatingProperties(TextDecoderStream.prototype,
 85 |                           ['encoding', 'fatal', 'ignoreBOM']);
 86 | 
 87 |   class TextEncodeTransformer {
 88 |     constructor() {
 89 |       this._encoder = new TextEncoder();
 90 |       this._carry = undefined;
 91 |     }
 92 | 
 93 |     transform(chunk, controller) {
 94 |       chunk = String(chunk);
 95 |       if (this._carry !== undefined) {
 96 |         chunk = this._carry + chunk;
 97 |         this._carry = undefined;
 98 |       }
 99 |       const terminalCodeUnit = chunk.charCodeAt(chunk.length - 1);
100 |       if (terminalCodeUnit >= 0xD800 && terminalCodeUnit < 0xDC00) {
101 |         this._carry = chunk.substring(chunk.length - 1);
102 |         chunk = chunk.substring(0, chunk.length - 1);
103 |       }
104 |       const encoded = this._encoder.encode(chunk);
105 |       if (encoded.length > 0) {
106 |         controller.enqueue(encoded);
107 |       }
108 |     }
109 | 
110 |     flush(controller) {
111 |       if (this._carry !== undefined) {
112 |         controller.enqueue(this._encoder.encode(this._carry));
113 |         this._carry = undefined;
114 |       }
115 |     }
116 |   }
117 | 
118 |   class TextDecodeTransformer {
119 |     constructor(decoder) {
120 |       this._decoder = new TextDecoder(decoder.encoding, {
121 |         fatal: decoder.fatal,
122 |         ignoreBOM: decoder.ignoreBOM
123 |       });
124 |     }
125 | 
126 |     transform(chunk, controller) {
127 |       const decoded = this._decoder.decode(chunk, {stream: true});
128 |       if (decoded != '') {
129 |         controller.enqueue(decoded);
130 |       }
131 |     }
132 | 
133 |     flush(controller) {
134 |       // If {fatal: false} is in options (the default), then the final call to
135 |       // decode() can produce extra output (usually the unicode replacement
136 |       // character 0xFFFD). When fatal is true, this call is just used for its
137 |       // side-effect of throwing a TypeError exception if the input is
138 |       // incomplete.
139 |       var output = this._decoder.decode();
140 |       if (output !== '') {
141 |         controller.enqueue(output);
142 |       }
143 |     }
144 |   }
145 | 
146 |   function exportAs(name, value) {
147 |     // Make it stringify as [object <name>] rather than [object Object].
148 |     value.prototype[Symbol.toStringTag] = name;
149 |     Object.defineProperty(self, name,
150 |                           {
151 |                             configurable: true,
152 |                             enumerable: false,
153 |                             writable: true,
154 |                             value
155 |                           });
156 |   }
157 | 
158 |   exportAs('TextEncoderStream', TextEncoderStream);
159 |   exportAs('TextDecoderStream', TextDecoderStream);
160 | })();
161 | 


--------------------------------------------------------------------------------