@claudeye/linux-arm64 1.0.6-beta.1 → 1.0.6-beta.3

package/assets/standalone/node_modules/next/dist/server/stream-utils/node-web-streams-helper.js

@@ -11,7 +11,9 @@ Object.defineProperty(exports, "__esModule", {
     continueStaticPrerender: null,
     createBufferedTransformStream: null,
     createDocumentClosingStream: null,
+    createInstantTestScriptInsertionTransformStream: null,
     createRootLayoutValidatorStream: null,
+    createRuntimePrefetchTransformStream: null,
     renderToInitialFizzStream: null,
     streamFromBuffer: null,
     streamFromString: null,
@@ -50,9 +52,15 @@ _export(exports, {
     createDocumentClosingStream: function() {
         return createDocumentClosingStream;
     },
+    createInstantTestScriptInsertionTransformStream: function() {
+        return createInstantTestScriptInsertionTransformStream;
+    },
     createRootLayoutValidatorStream: function() {
         return createRootLayoutValidatorStream;
     },
+    createRuntimePrefetchTransformStream: function() {
+        return createRuntimePrefetchTransformStream;
+    },
     renderToInitialFizzStream: function() {
         return renderToInitialFizzStream;
     },
@@ -79,7 +87,6 @@ const _scheduler = require("../../lib/scheduler");
 const _encodedtags = require("./encoded-tags");
 const _uint8arrayhelpers = require("./uint8array-helpers");
 const _constants1 = require("../../shared/lib/errors/constants");
-const _outputexportprefetchencoding = require("../../shared/lib/segment-cache/output-export-prefetch-encoding");
 const _approuterheaders = require("../../client/components/app-router-headers");
 const _cachebustingsearchparam = require("../../shared/lib/router/utils/cache-busting-search-param");
 function voidCatch() {
@@ -246,31 +253,6 @@ function createBufferedTransformStream(options = {}) {
         }
     });
 }
-function createPrefetchCommentStream(isBuildTimePrerendering, buildId) {
-    // Insert an extra comment at the beginning of the HTML document. This must
-    // come after the DOCTYPE, which is inserted by React.
-    //
-    // The first chunk sent by React will contain the doctype. After that, we can
-    // pass through the rest of the chunks as-is.
-    let didTransformFirstChunk = false;
-    return new TransformStream({
-        transform (chunk, controller) {
-            if (isBuildTimePrerendering && !didTransformFirstChunk) {
-                didTransformFirstChunk = true;
-                const decoder = new TextDecoder('utf-8', {
-                    fatal: true
-                });
-                const chunkStr = decoder.decode(chunk, {
-                    stream: true
-                });
-                const updatedChunkStr = (0, _outputexportprefetchencoding.insertBuildIdComment)(chunkStr, buildId);
-                controller.enqueue(encoder.encode(updatedChunkStr));
-                return;
-            }
-            controller.enqueue(chunk);
-        }
-    });
-}
 function renderToInitialFizzStream({ ReactDOMServer, element, streamOptions }) {
     return (0, _tracer.getTracer)().trace(_constants.AppRenderSpan.renderToReadableStream, async ()=>ReactDOMServer.renderToReadableStream(element, streamOptions));
 }
@@ -460,6 +442,63 @@ function createClientResumeScriptInsertionTransformStream() {
         }
     });
 }
+function createInstantTestScriptInsertionTransformStream(requestId) {
+    // Kick off a fetch for the static RSC payload. This is the hydration
+    // source for the locked static shell — same as the __NEXT_CLIENT_RESUME
+    // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER
+    // so the server returns static-only data.
+    //
+    // The fetch promise is stored as self.__next_instant_test, which doubles
+    // as the feature flag (truthy = instant test mode). The client processes
+    // this as a fallback prerender payload for hydration.
+    const segmentPath = '/_full';
+    const cacheBustingHeader = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
+    const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
+    // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket
+    // and debug channel initialization don't crash. The static shell
+    // bypasses renderToFizzStream which normally injects this via
+    // bootstrapScriptContent.
+    const requestIdScript = requestId !== null ? `self.__next_r=${JSON.stringify(requestId)};` : '';
+    const INSTANT_TEST_SCRIPT = `<script>${requestIdScript}self.__next_instant_test=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}':'${segmentPath}','${_approuterheaders.NEXT_INSTANT_PREFETCH_HEADER}':'1'}})</script>`;
+    let didAlreadyInsert = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didAlreadyInsert) {
+                // Already inserted the script into the head. Pass through.
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the opening <head tag (may have attributes like <head class="...">)
+            const headOpenIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HEAD);
+            if (headOpenIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Find the closing > of the <head ...> tag
+            const headCloseAngle = chunk.indexOf(62, headOpenIndex + _encodedtags.ENCODED_TAGS.OPENING.HEAD.length);
+            if (headCloseAngle === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const encodedInsertion = encoder.encode(INSTANT_TEST_SCRIPT);
+            const insertionPoint = headCloseAngle + 1;
+            // e.g.
+            // chunk = <!DOCTYPE html><html><head><meta charset="utf-8">...
+            // insertion = <script>self.__next_instant_test=fetch(...)</script>
+            // output = <!DOCTYPE html><html><head> [ <script>...</script> ] <meta charset="utf-8">...
+            const insertedHeadContent = new Uint8Array(chunk.length + encodedInsertion.length);
+            insertedHeadContent.set(chunk.slice(0, insertionPoint));
+            insertedHeadContent.set(encodedInsertion, insertionPoint);
+            insertedHeadContent.set(chunk.slice(insertionPoint), insertionPoint + encodedInsertion.length);
+            controller.enqueue(insertedHeadContent);
+            didAlreadyInsert = true;
+        },
+        flush (controller) {
+            // Append closing tags so the browser can parse the full document.
+            controller.enqueue(_encodedtags.ENCODED_TAGS.CLOSED.BODY_AND_HTML);
+        }
+    });
+}
 // Suffix after main body content - scripts before </body>,
 // but wait for the major chunks to be enqueued.
 function createDeferredSuffixStream(suffix) {
@@ -625,6 +664,35 @@ function createStripDocumentClosingTagsTransform() {
         }
     });
 }
+function createHtmlDataDplIdTransformStream(dplId) {
+    let didTransform = false;
+    return new TransformStream({
+        transform (chunk, controller) {
+            if (didTransform) {
+                controller.enqueue(chunk);
+                return;
+            }
+            const htmlTagIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HTML);
+            if (htmlTagIndex === -1) {
+                controller.enqueue(chunk);
+                return;
+            }
+            // Insert the data-dpl-id attribute right after "<html "
+            const insertionPoint = htmlTagIndex + _encodedtags.ENCODED_TAGS.OPENING.HTML.length;
+            const attribute = ` data-dpl-id="${dplId}"`;
+            const encodedAttribute = encoder.encode(attribute);
+            const modifiedChunk = new Uint8Array(chunk.length + encodedAttribute.length);
+            // Copy everything before the insertion point
+            modifiedChunk.set(chunk.subarray(0, insertionPoint));
+            // Insert the attribute
+            modifiedChunk.set(encodedAttribute, insertionPoint);
+            // Copy everything after
+            modifiedChunk.set(chunk.subarray(insertionPoint), insertionPoint + encodedAttribute.length);
+            controller.enqueue(modifiedChunk);
+            didTransform = true;
+        }
+    });
+}
 function createRootLayoutValidatorStream() {
     let foundHtml = false;
     let foundBody = false;
@@ -662,7 +730,7 @@ function chainTransformers(readable, transformers) {
     }
     return stream;
 }
-async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, isBuildTimePrerendering, buildId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
+async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, deploymentId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(CLOSE_TAG, 1)[0] : null;
     if (isStaticGeneration) {
@@ -676,8 +744,8 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
     return chainTransformers(renderStream, [
         // Buffer everything to avoid flushing too frequently
         createBufferedTransformStream(),
-        // Add build id comment to start of the HTML document (in export mode)
-        createPrefetchCommentStream(isBuildTimePrerendering, buildId),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
         // Transform metadata
         createMetadataTransformStream(getServerInsertedMetadata),
         // Insert suffix content
@@ -694,44 +762,157 @@ async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isS
         createHeadInsertionTransformStream(getServerInsertedHTML)
     ]);
 }
-async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream()).pipeThrough(createStripDocumentClosingTagsTransform())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata));
+async function continueDynamicPrerender(prerenderStream, { getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        createStripDocumentClosingTagsTransform(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata)
+    ]);
 }
-async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+async function continueStaticPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Add build id comment to start of the HTML document (in export mode)
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
-async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, isBuildTimePrerendering, buildId }) {
+async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
     // Same as `continueStaticPrerender`, but also inserts an additional script
     // to instruct the client to start fetching the hydration data as early
     // as possible.
-    return prerenderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Add build id comment to start of the HTML document (in export mode)
-    .pipeThrough(createPrefetchCommentStream(isBuildTimePrerendering, buildId))// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Insert the client resume script into the head
-    .pipeThrough(createClientResumeScriptInsertionTransformStream())// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, true))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+    return chainTransformers(prerenderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Insert the client resume script into the head
+        createClientResumeScriptInsertionTransformStream(),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, true),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
-async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata }) {
-    return renderStream// Buffer everything to avoid flushing too frequently
-    .pipeThrough(createBufferedTransformStream())// Insert generated tags to head
-    .pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))// Transform metadata
-    .pipeThrough(createMetadataTransformStream(getServerInsertedMetadata))// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
-    .pipeThrough(createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk))// Close tags should always be deferred to the end
-    .pipeThrough(createMoveSuffixStream());
+async function continueDynamicHTMLResume(renderStream, { delayDataUntilFirstHtmlChunk, inlinedDataStream, getServerInsertedHTML, getServerInsertedMetadata, deploymentId }) {
+    return chainTransformers(renderStream, [
+        // Buffer everything to avoid flushing too frequently
+        createBufferedTransformStream(),
+        // Insert data-dpl-id attribute on the html tag
+        deploymentId ? createHtmlDataDplIdTransformStream(deploymentId) : null,
+        // Insert generated tags to head
+        createHeadInsertionTransformStream(getServerInsertedHTML),
+        // Transform metadata
+        createMetadataTransformStream(getServerInsertedMetadata),
+        // Insert the inlined data (Flight data, form state, etc.) stream into the HTML
+        createFlightDataInjectionTransformStream(inlinedDataStream, delayDataUntilFirstHtmlChunk),
+        // Close tags should always be deferred to the end
+        createMoveSuffixStream()
+    ]);
 }
 function createDocumentClosingStream() {
     return streamFromString(CLOSE_TAG);
 }
+function createRuntimePrefetchTransformStream(sentinel, isPartial, staleTime) {
+    const enc = new TextEncoder();
+    // Search for: [<sentinel>]
+    // Replace with: [<isPartial>,<staleTime>]
+    const search = enc.encode(`[${sentinel}]`);
+    const first = search[0];
+    const replace = enc.encode(`[${isPartial},${staleTime}]`);
+    const searchLen = search.length;
+    let currentChunk = null;
+    let found = false;
+    function processChunk(controller, nextChunk) {
+        if (found) {
+            if (nextChunk) {
+                controller.enqueue(nextChunk);
+            }
+            return;
+        }
+        if (currentChunk) {
+            // We can't search past the index that can contain a full match
+            let exclusiveUpperBound = currentChunk.length - (searchLen - 1);
+            if (nextChunk) {
+                // If we have any overflow bytes we can search up to the chunk's final byte
+                exclusiveUpperBound += Math.min(nextChunk.length, searchLen - 1);
+            }
+            if (exclusiveUpperBound < 1) {
+                // we can't match the current chunk.
+                controller.enqueue(currentChunk);
+                currentChunk = nextChunk // advance so we don't process this chunk again
+                ;
+                return;
+            }
+            let currentIndex = currentChunk.indexOf(first);
+            // check the current candidate match if it is within the bounds of our search space for the currentChunk
+            candidateLoop: while(-1 < currentIndex && currentIndex < exclusiveUpperBound){
+                // We already know index 0 matches because we used indexOf to find the candidateIndex so we start at index 1
+                let matchIndex = 1;
+                while(matchIndex < searchLen){
+                    const candidateIndex = currentIndex + matchIndex;
+                    const candidateValue = candidateIndex < currentChunk.length ? currentChunk[candidateIndex] : nextChunk[candidateIndex - currentChunk.length];
+                    if (candidateValue !== search[matchIndex]) {
+                        // No match, reset and continue the search from the next position
+                        currentIndex = currentChunk.indexOf(first, currentIndex + 1);
+                        continue candidateLoop;
+                    }
+                    matchIndex++;
+                }
+                // We found a complete match. currentIndex is our starting point to replace the value.
+                found = true;
+                // enqueue everything up to the match
+                controller.enqueue(currentChunk.subarray(0, currentIndex));
+                // enqueue the replacement value
+                controller.enqueue(replace);
+                // If there are bytes in the currentChunk after the match enqueue them
+                if (currentIndex + searchLen < currentChunk.length) {
+                    controller.enqueue(currentChunk.slice(currentIndex + searchLen));
+                }
+                // If we have a next chunk we enqueue it now
+                if (nextChunk) {
+                    // if replacement spills over to the next chunk we first exclude the replaced bytes
+                    const overflowBytes = currentIndex + searchLen - currentChunk.length;
+                    const truncatedChunk = overflowBytes > 0 ? nextChunk.subarray(overflowBytes) : nextChunk;
+                    controller.enqueue(truncatedChunk);
+                }
+                // We are now in found mode and don't need to track currentChunk anymore
+                currentChunk = null;
+                return;
+            }
+            // No match found in this chunk, emit it and wait for the next one
+            controller.enqueue(currentChunk);
+        }
+        // Advance to the next chunk
+        currentChunk = nextChunk;
+    }
+    return new TransformStream({
+        transform (chunk, controller) {
+            processChunk(controller, chunk);
+        },
+        flush (controller) {
+            processChunk(controller, null);
+        }
+    });
+}
 
 //# sourceMappingURL=node-web-streams-helper.js.map

package/assets/standalone/node_modules/next/dist/server/stream-utils/uint8array-helpers.js

@@ -29,6 +29,11 @@ _export(exports, {
 function indexOfUint8Array(a, b) {
     if (b.length === 0) return 0;
     if (a.length === 0 || b.length > a.length) return -1;
+    // Use Node's native implementation when available.
+    if (typeof Buffer !== 'undefined') {
+        const haystack = Buffer.isBuffer(a) ? a : Buffer.from(a.buffer, a.byteOffset, a.byteLength);
+        return haystack.indexOf(b);
+    }
     // start iterating through `a`
     for(let i = 0; i <= a.length - b.length; i++){
         let completeMatch = true;
@@ -58,8 +63,8 @@ function removeFromUint8Array(a, b) {
     if (tagIndex === 0) return a.subarray(b.length);
     if (tagIndex > -1) {
         const removed = new Uint8Array(a.length - b.length);
-        removed.set(a.slice(0, tagIndex));
-        removed.set(a.slice(tagIndex + b.length), tagIndex);
+        removed.set(a.subarray(0, tagIndex));
+        removed.set(a.subarray(tagIndex + b.length), tagIndex);
         return removed;
     } else {
         return a;

package/assets/standalone/node_modules/next/dist/server/typescript/constant.js

@@ -65,6 +65,7 @@ const LEGACY_CONFIG_EXPORT = 'config';
 const DISALLOWED_SERVER_REACT_APIS = [
     'useState',
     'useEffect',
+    'useEffectEvent',
     'useLayoutEffect',
     'useDeferredValue',
     'useImperativeHandle',

package/assets/standalone/node_modules/next/dist/server/typescript/rules/config.js

@@ -109,15 +109,26 @@ const API_DOCS = {
         description: '`maxDuration` allows you to set max default execution time for your function. If it is not specified, the default value is dependent on your deployment platform and plan.',
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#maxduration'
     },
-    unstable_prefetch: {
+    unstable_instant: {
         description: `Specifies the default prefetching behavior for this segment. This configuration is currently under development and will change.`,
         link: '(docs coming soon)',
-        type: 'object',
+        type: 'object | false',
         // TODO: ideally, we'd validate the config object somehow, but this is difficult to do
         // with the way this plugin is currently structured.
         // For now, since we don't provide an `options` here, we won't do any validation in
         // `getSemanticDiagnosticsForExportVariableStatement` below, and only provide hover a tooltip + autocomplete.
-        insertText: 'unstable_prefetch = { mode: "static" };'
+        insertText: 'unstable_instant = { prefetch: "static" };'
+    },
+    unstable_dynamicStaleTime: {
+        description: `Controls how long the client-side router cache retains dynamic page data (in seconds). Pages only — not allowed in layouts. Cannot be combined with \`unstable_instant\`.`,
+        link: '(docs coming soon)',
+        type: 'number',
+        isValid: (value)=>{
+            return Number(value.replace(/_/g, '')) >= 0;
+        },
+        getHint: (value)=>{
+            return `Set the dynamic stale time to \`${value}\` seconds.`;
+        }
     }
 };
 function visitEntryConfig(fileName, position, callback) {

package/assets/standalone/node_modules/next/dist/server/use-cache/cache-life.js

@@ -79,11 +79,13 @@ function cacheLife(profile) {
     switch(workUnitStore == null ? void 0 : workUnitStore.type){
         case 'prerender':
         case 'prerender-client':
+        case 'validation-client':
         case 'prerender-runtime':
         case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         case 'unstable-cache':
+        case 'generate-static-params':
         case undefined:
             throw Object.defineProperty(new Error('`cacheLife()` can only be called inside a "use cache" function.'), "__NEXT_ERROR_CODE", {
                 value: "E818",

package/assets/standalone/node_modules/next/dist/server/use-cache/cache-tag.js

@@ -22,11 +22,13 @@ function cacheTag(...tags) {
     switch(workUnitStore == null ? void 0 : workUnitStore.type){
         case 'prerender':
         case 'prerender-client':
+        case 'validation-client':
         case 'prerender-runtime':
         case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         case 'unstable-cache':
+        case 'generate-static-params':
         case undefined:
             throw Object.defineProperty(new Error('`cacheTag()` can only be called inside a "use cache" function.'), "__NEXT_ERROR_CODE", {
                 value: "E819",