SyntaxError class
TypeError class
typeof operator
+ This section uses the terminology and typographic conventions from the JavaScript + specification.
-Some objects support being copied and closed in one operation. This is called - transferring the object, and is used in particular to transfer ownership of unsharable or - expensive resources across document and worker boundaries, including across documents of different - origins.
+The following Transferable types exist:
Cloneable objects support being cloned across event + loops. That is, they support being cloned across document and worker boundaries, including + across documents of different origins. Not all objects are + cloneable objects and not all aspects of objects that are cloneable + objects are necessarily preserved when cloned.
-ArrayBuffer
- CanvasProxy (defined in this specification)
- MessagePort (defined in this specification)
- ImageBitmap (defined in this specification)
- IDL-defined cloneable objects are cloneable objects defined through IDL that have + the following internal method:
-The following IDL block formalizes this:
- -typedef (ArrayBuffer - or CanvasProxy - or MessagePort - or ImageBitmap) Transferable;- -
To transfer a Transferable object to a new owner, the user agent must
- run the steps defined for the type of object in question. The steps will return a new object of
- the same type, and will permanently neuter the
- original object. (This is an irreversible and non-idempotent operation; once an object has been
- transferred, it cannot be transferred, or indeed used, again.)
To transfer an
- ArrayBuffer object old to a new owner
- owner, a user agent must create a new ArrayBuffer object pointing at the same underlying data as
- old, thus obtaining new, must neuter the old object, and must finally
- return new.
Rules for how to transfer a
- CanvasProxy object and how to transfer a
- MessagePort object are given in the relevant sections of this specification.
When a user agent is required to obtain a structured clone of a value, optionally
- with a transfer map, it must run the following algorithm, which either returns a separate
- value, or throws an exception. If a transfer map is provided, it consists of an association
- list of Transferable objects to placeholder objects.
[[Clone]] ( targetRealm, memory )
+ -IDL-defined clonable objects must define the [[Clone]] internal method such that + it either throws or returns a clone of this, created in targetRealm. It is up to + IDL-defined cloneable objects to define what cloning means for them.
-Let input be the value being cloned.
Objects defined in the JavaScript specification are handled by the StructuredClone + abstract operation directly.
-Let transfer map be the transfer map passed to the algorithm, if any, or - the empty list otherwise.
Let memory be an association list of pairs of objects, initially empty. This is - used to handle duplicate references. In each pair of objects, one is called the source object and the other the destination object.
Transferable objects support being transferred across event loops. Transferring is effectively recreating the object while sharing a + reference to the underlying data and then detaching the object being transferred. This is useful + to transfer ownership of expensive resources. Not all objects are transferable + objects and not all aspects of objects that are transferable objects are + necessarily preserved when transferred.
-For each mapping in transfer map, add a mapping from the
- Transferable object (the source object) to the placeholder object (the destination
- object) to memory.
Transferring is an irreversible and non-idempotent operation. Once an object has + been transferred, it cannot be transferred, or indeed used, again.
-Let output be the value resulting from calling the internal structured - cloning algorithm with input as the "input" argument, and - memory as the "memory" argument.
IDL-defined transferable objects are transferable objects defined through IDL that + have a [[Detached]] internal slot and the following internal method:
-Return output.
[[Transfer]] ( targetRealm )
-The internal structured cloning algorithm is always called with two arguments, - input and memory, and its behaviour is as follows:
+IDL-defined transferable objects must define the [[Transfer]] internal method such + that it either throws or returns a clone of this, created in targetRealm, with + this's underlying data shared with the return value, and this's + [[Detached]] internal slot value set to true. It is up to IDL-defined transferable + objects to define what transfering means for them.
-Objects defined in the JavaScript specification are handled by the + StructuredCloneWithTransfer abstract operation directly. (Technically, by + IsTransferable and TransferHelper.)
-If input is the source object of a pair of objects in memory, then - return the destination object in that pair of objects and abort these steps.
If input is a primitive value, then return that value and abort these - steps.
Let memory be an empty map.
-Let deep clone be none.
The purpose of the memory map, both here and in the + StructuredClone abstract operation, is to avoid cloning objects twice. This ends up + preserving cycles and the identity of duplicate objects in graphs.
+For each object transferable in transferList: -
The input value is an object. Jump to the appropriate step below:
+If IsTransferable(transferable) is false, then throw a
+ DataCloneError exception.
Let placeholder be a user-agent-defined placeholder object.
Boolean objectCreate an entry in memory with key transferable and value + placeholder.
Let output be a newly constructed Boolean object with the same value as - input.
Let clone be the result of ? + StructuredClone(input, targetRealm, + memory).
Number objectLet outputTransferList be a new empty List.
Let output be a newly constructed Number object with the same value as - input.
For each object transferable in transferList: -
String objectLet placeholderResult be the value of the entry in memory whose + key is transferable.
Let output be a newly constructed String object with the same value as - input.
Let transferResult be ? TransferHelper(transferable, + targetRealm).
Date objectWithin clone, replace references to placeholderResult with + transferResult, such that everything holding a reference to + placeholderResult, now holds a reference to transferResult.
-Let output be a newly constructed Date object with the same
- value as input.
This is a rather unusual low-level operation for which no primitives are + defined by ECMAScript.
+RegExp objectAdd transferResult as the last element of + outputTransferList.
Return { [[Clone]]: clone, [[TransferList]]: outputTransferList + }.
Let output be a newly constructed RegExp object with the same
- pattern and flags as input.
Originally the StructuredCloneWithTransfer abstract operation was
+ known as the "structured clone" algorithm. The StructuredClone abstract operation was
+ known as the "internal structured clone" algorithm. Transferring objects, now handled by the
+ StructuredCloneWithTransfer abstract operation, were formerly handled by parts of the
+ algorithm of the postMessage() method on the
+ Window object and the postMessage()
+ method on the MessagePort object.
The value of the lastIndex property is not copied.
If memory was not supplied, let memory be an empty map.
Blob objectIf memory contains an entry with key input, then return that entry's + value.
If input is closed, throw a
- DataCloneError exception and abort the overall structured clone
- algorithm. Otherwise, let output be a newly constructed object of the same class as
- input, corresponding to the same underlying data.
If Type(input) is Undefined, Null, Boolean, + String, or Number, then return input.
FileList objectIf Type(input) is Symbol, then throw a
+ DataCloneError exception.
Let output be a newly constructed FileList object containing a
- list of newly constructed File objects corresponding to the same underlying data
- as those in input, maintaining their relative order.
Let deepClone be "none".
ImageData objectIf input has a [[BooleanData]] internal slot, then let output be a + new Boolean object in targetRealm whose [[BooleanData]] internal slot value is the + [[BooleanData]] internal slot value of input.
Let output be a newly constructed ImageData object whose width and height
- have values equal to the corresponding attributes on input, and whose data attribute has the value obtained from invoking the
- internal structured cloning algorithm recursively with the value of the data attribute on input as the new
- "input" argument and memory as the new "memory"
- argument.
Otherwise, if input has a [[NumberData]] internal slot, then let + output be a new Number object in targetRealm whose [[NumberData]] internal + slot value is the [[NumberData]] internal slot value of input.
ImageBitmap objectOtherwise, if input has a [[StringData]] internal slot, then let + output be a new String object in targetRealm whose [[StringData]] internal + slot value is the [[StringData]] internal slot value of input.
If input has been neutered, throw a DataCloneError
- exception and abort the overall structured clone algorithm. Otherwise, let
- output be a newly constructed ImageBitmap object whose
- bitmap data is a copy of
- input's bitmap data, and
- whose origin-clean flag is set to the same
- value as input's origin-clean
- flag.
Otherwise, if input has a [[DateValue]] internal slot, then let + output be a new Date object in targetRealm whose [[DateValue]] internal + slot value is the [[DateValue]] internal slot value of input.
ArrayBuffer objectOtherwise, if input has a [[RegExpMatcher]] internal slot, then let + output be a new RegExp object in targetRealm whose [[RegExpMatcher]] + internal slot value is the [[RegExpMatcher]] internal slot value of input, whose + [[OriginalSource]] internal slot value is the [[OriginalSource]] internal slot value of + input, and whose whose [[OriginalFlags]] internal slot value is the [[OriginalFlags]] + internal slot value of input.
If input has been neutered, throw a DataCloneError
- exception and abort the overall structured clone algorithm. Otherwise, let
- output be a newly constructed ArrayBuffer
- object whose contents are a copy of input's contents, with the same length.
Otherwise, if input has an [[ArrayBufferData]] internal slot, then:
-If IsDetachedBuffer(input) is true, then throw a
+ DataCloneError exception.
Let outputArrayBuffer be the %ArrayBuffer% intrinsic object in + targetRealm. -
Let output be a newly constructed object of the same class as input, - with its [[DataView]] internal property present, its [[ViewedArrayBuffer]] internal property - set to the value obtained from invoking the internal structured cloning algorithm - recursively with the value of the internal property on input as the new - "input" argument and memory as the new "memory" argument, and - with the [[ByteLength]] and [[ByteOffset]] internal properties set to the same value as their - counterparts on input.
+Let output be ? CloneArrayBuffer(input, 0, + outputArrayBuffer).
Otherwise, if input has a [[ViewedArrayBuffer]] internal slot, then:
- +Let buffer be the value of input's [[ViewedArrayBuffer]] internal + slot.
Array objectLet bufferClone be ? StructuredClone(buffer, + targetRealm, memory).
If input has a [[DataView]] internal slot, then let output be a + new DataView object in targetRealm whose [[DataView]] internal slot value is true, + whose [[ViewedArrayBuffer]] internal slot value is bufferClone, whose [[ByteLength]] + internal slot value is the [[ByteLength]] internal slot value of input, and whose + [[ByteOffset]] internal slot value is the [[ByteOffset]] internal slot value of + input.
Let output be a newly constructed empty Array
- object whose length is equal to the length of
- input, and set deep clone to own.
Otherwise:
-This means that the length of sparse arrays is preserved.
+Assert: input has a [[TypedArrayName]] internal slot.
Let constructor be the intrinsic object listed in column one of The + TypedArray Constructors table for the value of input's + [[TypedArrayName]] internal slot in targetRealm.
Object objectLet byteOffset be input's [[ByteOffset]] internal slot + value.
Let output be a newly constructed empty Object object, and set deep clone to own.
Let length be input's [[ArrayLength]] internal slot + value.
Map objectLet output be ? TypedArrayCreate(constructor, + « bufferClone, byteOffset, length »). +
Let output be a newly constructed empty Map
- object, and set deep clone to map.
Otherwise, if input has [[MapData]] internal slot, then:
-Set objectLet output be a new Map object in targetRealm whose [[MapData]] + internal slot value is a new empty List.
Let output be a newly constructed empty Set
- object, and set deep clone to set.
Set deepClone to "map".
Otherwise, if input has [[SetData]] internal slot, then:
-Let output be a clone of the object as defined by the other - specification.
Let output be a new Set object in targetRealm whose [[SetData]] + internal slot value is a new empty List.
Error, Function)Set deepClone to "set".
Throw a DataCloneError exception and abort the overall structured
- clone algorithm.
Otherwise, if input is an Array exotic object, then:
+ - +Let inputLen be OrdinaryGetOwnProperty(input,
+ "length").[[Value]].
For the purposes of the algorithm above, an object is a particular type of object - class if its [[Class]] internal property is equal to class.
+Let outputProto be the %ArrayPrototype% intrinsic object in + targetRealm.
For example, "input is an Object
- object" if input's [[Class]] internal property is equal to the string "Object".
Let output be ArrayCreate(inputLen, + outputProto).
Set deepClone to "own".
Add a mapping from input (the source object) to output (the - destination object) to memory.
Otherwise, if IsCallable(input) is true, then throw a
+ DataCloneError exception.
Otherwise, if input has an [[ErrorData]] internal slot, then throw a
+ DataCloneError exception.
Otherwise, if input has a [[Clone]] internal method, then let + output be ? input.[[Clone]](targetRealm).
Otherwise, if input is an exotic object, then throw a
+ DataCloneError exception.
If deep clone is set to map, then run these substeps. These substeps use - the terminology and typographic conventions used in the JavaScript specification's definition of - Maps.
+Otherwise:
+Let source be a new empty List. +
Create an entry in memory whose key is input and value is + output.
If deepClone is "map", then:
For each Record {[[Key]], [[Value]]} entry that is an element of - original, run the following substeps:
+Let inputList the value of input's [[MapData]] internal + slot.
Let copiedList be a new empty List. -
Let new entry be the Record {[[Key]]: entry.[[Key]], [[Value]]: - entry.[[Value]]}.
Repeat for each Record {[[Key]], [[Value]]} entry that is an + element of inputList,
-If new entry.[[Key]] is not empty, append new entry as - the last element of source.
Let copiedEntry be a new Record { + [[Key]]: entry.[[Key]], + [[Value]]: entry.[[Value]] }.
If copiedEntry.[[Key]] is not empty, append copiedEntry as the + last element of copiedList.
Let target be the List that is the value of output's [[MapData]] - internal slot.
Let outputList be the value of output's [[MapData]] internal + slot.
For each Record {[[Key]], [[Value]]} entry that is an element of - source, run the following substeps:
+For each Record {[[Key]], [[Value]]} entry that is an element of + copiedList,
Let outputKey be ? StructuredClone(entry.[[Key]], + targetRealm, memory).
Let key have the value obtained from invoking the internal structured - cloning algorithm recursively with entry.[[Key]] as the new - "input" argument and memory as the new "memory" - argument.
Let outputValue be ? + StructuredClone(entry.[[Value]], targetRealm, + memory).
Let value have the value obtained from invoking the internal - structured cloning algorithm recursively with entry.[[Value]] as the new - "input" argument and memory as the new "memory" - argument.
Add { [[Key]]: outputKey, [[Value]]: outputValue } as the last + element of outputList.
Let new entry be the Record {[[Key]]: key, [[Value]]: - value}.
Set deepClone to "own".
Append new entry as the last element of target.
If deepClone is "set", then:
Let copiedList be a copy of the value of input's [[SetData]] + internal slot.
Let outputList be the value of output's [[SetData]] internal + slot.
Set deep clone to own.
For each entry that is an element of copiedList that is not + empty,
-Let outputEntry be ? StructuredClone(entry, + targetResult, memory).
Add outputEntry as the last element of outputList.
Set deepClone to "own".
If deep clone is set to set, then run these substeps. These substeps use - the terminology and typographic conventions used in the JavaScript specification's definition of - Sets.
+If deepClone is "own", then for each key in ?
+ input.[[OwnPropertyKeys]]():
If Type(key) is String, then:
-Let source be a copy of the List that is the value of input's - [[SetData]] internal slot.
Let target be the List that is the value of output's [[SetData]] - internal slot.
Let inputValue be ? input.[[Get]](key, + input).
Let outputValue be ? + StructuredClone(inputValue, targetRealm, + memory).
For each entry that is an element of source that is not empty, - run the following substeps:
+Perform ? CreateDataProperty(output, key, + outputValue).
Return output.
Let new entry have the value obtained from invoking the internal - structured cloning algorithm recursively with entry as the new - "input" argument and memory as the new "memory" - argument.
In general implementations will need to use some kind of serialization and + marshalling to implement the creation of objects in targetRealm, as + targetRealm could be in a different event loop and not easily accessible + to the code that invokes StructuredCloneWithTransfer or + StructuredClone.
-Append new entry as the last element of target.
Assert: Type(O) is Object.
If O has an [[ArrayBufferData]] internal slot, then:
-Set deep clone to own.
If IsDetachedBuffer(O) is true, then return false.
Return true.
If deep clone is set to own, then, for each enumerable own property in - input, run the following steps:
+Otherwise, if O has a [[Detached]] internal slot, then:
If O's [[Detached]] internal slot value is true, then return + false.
Let name be the name of the property.
Return true.
Return false.
Let source value be the result of calling the [[Get]] internal method of - input with the argument name. If the [[Get]] internal method of a - property involved executing script, and that script threw an uncaught exception, then abort the - overall structured clone algorithm, with that exception being passed through to - the caller.
Let cloned value be the result of invoking the internal structured - cloning algorithm recursively with source value as the "input" - argument and memory as the "memory" argument. If this results in an - exception, then abort the overall structured clone algorithm, with that exception - being passed through to the caller.
If input has an [[ArrayBufferData]] internal slot, then:
-Add a new property to output having the name name, and having - the value cloned value, using - CreateDataProperty(output, name, cloned value).
Let output be a new ArrayBuffer object in targetRealm whose + [[ArrayBufferByteLength]] internal slot value is the [[ArrayBufferByteLength]] internal slot + value of input, and whose [[ArrayBufferData]] internal slot value is the + [[ArrayBufferData]] internal slot value of input.
Perform ! DetachArrayBuffer(input).
Return output.
The order of the properties in the input and output objects must be the - same, and any properties whose [[Get]] internal method involves running script must be processed - in that same order.
+Return ? input.[[Transfer]](targetRealm).
This does not walk the prototype chain.
+Blob and FileList objectsProperty descriptors, setters, getters, and analogous features are not copied in - this process. For example, the property in the input could be marked as read-only, but in the - output it would just have the default state (typically read-write, though that could depend on - the scripting environment).
+This monkey patch will be removed in due course. See w3c/FileAPI issue 32.
-Properties of Array objects are not treated any differently than those of other - Objects. In particular, this means that non-index properties of arrays are copied as well.
+Blob objects are cloneable objects.
Each Blob object's [[Clone]] internal method, given
+ targetRealm and ignoring memory, must run these steps:
Return output.
If this is closed, then throw a
+ DataCloneError exception.
Return a new instance of this in targetRealm, corresponding to the + same underlying data.
This algorithm preserves cycles and preserves the identity of duplicate objects in - graphs.
+FileList objects are cloneable objects.
Each FileList object's [[Clone]] internal method, given
+ targetRealm and memory, must run these steps:
Let output be a new FileList object in
+ targetRealm.
For each file in this, add ?
+ StructuredClone(file, targetRealm, memory) to the
+ end of the list of File objects of output.
Return output.
This is only observable for blob: URLs as
- parsing them involves the structured clone
- algorithm.
An element implementing the HTMLHyperlinkElementUtils mixin has an associated reinitialise url algorithm, which runs these steps:
[Exposed=(Window,Worker)]
interface CanvasProxy {
void setContext(RenderingContext context);
-};
-// CanvasProxy implements Transferable;
+};
Throws an InvalidStateError exception if the CanvasProxy has been
- transferred.
A CanvasProxy object can be neutered (like any Transferable object),
- meaning it can no longer be transferred, and
- can be disabled, meaning it can no longer be bound
- to rendering contexts. When first created, a CanvasProxy object must be neither.
Each CanvasProxy object has a [[Detached]] internal slot (like any
+ transferable object).
Each CanvasProxy object can be disabled, meaning it can no longer be bound to
+ rendering contexts. When first created, a CanvasProxy object must not be disabled.
A CanvasProxy is created with a link to a canvas element. A
CanvasProxy object that has not been CanvasProxy {
data-x="concept-CanvasProxy-disabled">disabled, throw an InvalidStateError
exception and abort these steps.
If the CanvasProxy object has not been neutered, then neuter it.
Set CanvasProxy object's [[Detached]] internal slot value to
+ true.
If context's context bitmap mode is fixed, then throw an @@ -59748,13 +59848,19 @@ interface CanvasProxy { -
To transfer a
- CanvasProxy object old to a new owner owner,
- a user agent must create a new CanvasProxy object linked to the same
- canvas element as old, thus obtaining new,
- must neuter and disable the old object, and must
- finally return new.
Each CanvasProxy object's [[Transfer]]
+ internal method, given a targetRealm, must run these steps:
Let new be a new CanvasProxy object in targetRealm,
+ linked to the same canvas element as this.
Set this's [[Detached]] internal slot value to true.
Disable this.
Return new.
Throws an InvalidStateError exception if the imagedata
- object's data has been neutered.
The ImageData() constructors and the createImageData() methods are used to
instantiate new ImageData objects.
ImageData objects are cloneable objects.
Each ImageData object's [[Clone]] internal method, given
+ targetRealm and memory, must run these steps:
Let output be a new ImageData object in targetRealm
+ whose width and
+ height have values equal to the corresponding
+ attributes on this.
Let inputData be the value of this's data attribute.
Set output's data attribute value to ?
+ StructuredClone(inputData, targetRealm,
+ memory).
Return output.
When the ImageData() constructor is invoked with two
numeric arguments sw and sh, it must return a new
ImageData object representing a transparent black rectangle with a width equal to
@@ -65093,9 +65220,8 @@ partial dictionary MouseEventInit {
If the imagedata argument's data attribute has been neutered, throw an InvalidStateError
- exception and abort these steps.
InvalidStateError exception and abort these steps.
If IsPlatformObjectSameOrigin(W) is true, then return ! +
If IsPlatformObjectSameOrigin(W) is true, then return OrdinaryGetOwnProperty(W, P).
Rejects the promise with a
SecurityError exception if the script is not allowed to access the image data of
@@ -90169,22 +90301,37 @@ interface ImageBitmapFactories {
true and may be changed to false by the steps of createImageBitmap().
To transfer an ImageBitmap
- object old to a new owner owner, a user agent must run the following
- steps:
ImageBitMap objects are cloneable objects and transferable
+ objects.
Each ImageBitmap object's [[Clone]] internal method, given
+ targetRealm and ignoring memory, must run these steps:
Create a new ImageBitmap object pointing at the same underlying bitmap data as old, thus obtaining
- new;
If this's [[Detached]] internal slot is true, then throw a
+ DataCloneError exception.
Return a new ImageBitmap object in targetRealm whose bitmap data is a copy of this's bitmap data, and whose origin-clean flag is set to the same value as
+ this's origin-clean flag.
Each ImageBitmap object's [[Transfer]] internal method, given
+ targetRealm, must run these steps:
Let new be a new ImageBitmap object in targetRealm,
+ pointing at the same underlying bitmap data
+ as this.
Set new's bitmap's origin-clean flag to the same values as - old's bitmap's origin-clean - flag;
Neuter the old - object;
Set this's [[Detached]] internal slot value to true.
Return new.
If either the sw or sh arguments are specified
but zero, return a promise rejected with an IndexSizeError exception and abort these steps.
If the image object's data
- attribute has been neutered, return a promise rejected with an
- InvalidStateError exception and abort these steps.
If the image object's data attribute
+ value's [[Detached]] internal slot value is true, return a promise rejected with
+ an InvalidStateError exception and abort these steps.
Create a new ImageBitmap object.
IndexSizeError exception and abort
these steps.
- If image is neutered, return a +
If image's [[Detached]] internal slot value is true, return a
promise rejected with an InvalidStateError exception and abort these
steps.
When a script invokes the postMessage(message, targetOrigin, transfer) method (with two or three arguments) on a
- Window object, the user agent must follow these steps:
When a script invokes the postMessage(message, targetOrigin,
+ transfer) method on a Window object, the user agent must
+ follow these steps:
SyntaxError exception and abort the overall set of steps.
- Let new ports be an empty array.
Let targetRealm be this Window object's JavaScript
+ realm.
Let transfer map be an empty association list of
- Transferable objects to placeholder objects.
Let cloneRecord be StructuredCloneWithTransfer(message, + transfer, targetRealm). Rethrow any exceptions.
Let message clone be cloneRecord.[[Clone]].
If the method was invoked with a third argument transfer, run these - substeps:
- -If any object is listed in transfer more than once, or any of the
- Transferable objects listed in transfer are marked as neutered, then throw a
- DataCloneError exception and abort these steps.
For each object x in transfer in turn, add a
- mapping from x to a new unique placeholder object created for x to transfer map, and if x is a
- MessagePort object, also append the placeholder object to the new
- ports array.
Let message clone be the result of obtaining a structured - clone of the message argument, with transfer map - as the transfer map. If this throws an exception, then throw that exception and abort - these steps.
If the method was invoked with a third argument transfer, run these - substeps:
- -Let new owner be the environment settings object of the
- Window object on which the method was invoked.
For each object x in transfer in turn, obtain - a new object y by transferring the object x to new - owner, and replace the placeholder object that was created for the object x by the new object y wherever the placeholder exists - (i.e. in message clone and in new ports).
Make new ports into a read - only array.
Let new ports be a new read only
+ array consisting of all MessagePort objects in
+ cloneRecord.[[TransferList]], if any, maintaining their relative order.
Return from the postMessage() method, but
in parallel continue running these steps.
[Exposed=(Window,Worker)] interface MessagePort : EventTarget { - void postMessage(any message, optional sequence<Transferable> transfer); + void postMessage(any message, optional sequence<object> transfer = []); void start(); void close(); // event handlers attribute EventHandler onmessage; }; -// MessagePort implements Transferable;+-->};
The has been shipped flag is set to true when a port, its twin, or
- the object it was cloned from, is or has been transferred. When a MessagePort's has been shipped flag
- is true, its port message queue acts as a first-class task source,
- unaffected to any unshipped port message queue.
MessagePort's
+ has been shipped flag is true, its port message queue acts as a
+ first-class task source, unaffected to any unshipped port message
+ queue.
When the user agent is to create a new MessagePort object with a
particular environment settings object as its owner, it must instantiate
@@ -93185,27 +93291,31 @@ interface MessagePort : EventTarget {
When the user agent is to clone a port original port, with the
- clone being owned by owner, it must run the following steps, which return a
- new MessagePort object. These steps must be run atomically.
MessagePort objects are transferable
+ objects.
Each MessagePort object's [[Transfer]] internal method, given a
+ targetRealm, must run these steps:
Set original port's has been shipped flag to - true.
Set this's has been shipped flag to true.
Create a new MessagePort object whose owner is owner, and let new port be that object.
Let new be a new
+ MessagePort object in targetRealm whose owner is targetRealm's [[GlobalObject]]'s
+ relevant settings object.
Set new port's has been shipped flag to true.
Set new's has been shipped flag to true.
Move all the tasks that are to fire message events in the port message queue of original port to the port message queue of new
- port, if any, leaving the new port's port message queue
- in its initial disabled state, and, if the new port's owner specifies a responsible event loop that is
- a browsing context event loop, associating the moved tasks with the responsible document specified by new port's owner.
If the original port is entangled with another port, then run these - substeps:
+If this is entangled with another port, then run these substeps:
Let remote port be the port with which this is entangled.
Let the remote port be the port with which the original port is entangled.
Set remote port's has been shipped flag to - true.
Entangle the remote port and new - port objects. The original port object will be disentangled by this - process.
Set remote port's has been shipped flag to true.
Entangle remote port and new. this will be + disentangled by this process.
Return new port. It is the clone.
Set this's [[Detached]] internal slot value to true.
Return new. It is the clone.
To transfer a
- MessagePort object old to a new owner owner,
- a user agent must clone the old object with
- the clone being owned by owner, thus obtaining new, must
- neuter the old port, and
- must finally return new.
The postMessage() method, when
@@ -93263,121 +93360,42 @@ interface MessagePort : EventTarget {
is entangled, if any.
Let doomed be false.
-Let doomed be false. It is set to true if a condition is detected that - will make this message cause the port to be unusable; specifically, if the message contains target port as one of the objects being transferred. (This condition cannot necessarily be detected when the method is called.)
- +It is set to true if a condition is detected that will make this message cause + the port to be unusable; specifically, if the message contains target port as one of + the objects being transferred. (This condition cannot necessarily be detected when the method is + called.)
If any of the objects in transfer are the source port, then throw a
+ DataCloneError exception and abort these steps.
Let new ports be an empty array.
- - +If any of the objects in transfer are the target port, if any, then + let doomed be true, and optionally report to a developer console that the target port + was posted to itself, causing the communication channel to be lost.
Let targetRealm be target port's owner's Realm, if there is a target port and doomed is else, and + otherwise some arbitrary Realm.
-Let transfer map be an empty association list of
- Transferable objects to placeholder objects.
targetRealm is used when cloning and transfering objects below. If + there is no target port, or if the target port is one of the objects being + transferred, the transferable objects given in the second argument, if any, are still + transferred, but since they are then discarded, it doesn't matter where they are transferred + to.)
If the method was invoked with a second argument transfer, run these - substeps:
- -If any object is listed in transfer more than once, or any of the
- Transferable objects listed in transfer are marked as neutered, then throw a
- DataCloneError exception and abort these steps.
If any of the objects in transfer are the source
- port, then throw a DataCloneError exception and abort these steps.
Let cloneRecord be StructuredCloneWithTransfer(message, + transfer, targetRealm). Rethrow any exceptions.
Let message clone be cloneRecord.[[Clone]].
If any of the objects in transfer are the target - port, if any, then let doomed be true, and optionally report to a - developer console that the target port was posted to itself, causing the communication channel - to be lost.
- - - -For each object x in transfer in turn, add a
- mapping from x to a new unique placeholder object created for x to transfer map, and if x is a
- MessagePort object, also append the placeholder object to the new
- ports array.
Let message clone be the result of obtaining a structured - clone of the message argument, with transfer map - as the transfer map. If this throws an exception, then throw that exception and abort - these steps.
- -If the method was invoked with a second argument transfer, run these - substeps:
- -Let new owner be the owner of
- target port, if there is a target port and doomed is false, or else some arbitrary owner. (This new
- owner is used when transferring objects below. If there is no target
- port, or if the target port is one of the objects being transferred, the Transferable
- objects given in the second argument, if any, are still transferred, but since they are then discarded, it doesn't matter where they
- are transferred to.)
For each object x in transfer in turn, obtain a - new object y by transferring the object x to new - owner, and replace the placeholder object that was created for the object x by the new object y wherever the placeholder exists - (i.e. in message clone and in new ports).
- -Make new ports into a read only - array.
- -Let new ports be a new read only
+ array consisting of all MessagePort objects in
+ cloneRecord.[[TransferList]], if any, maintaining their relative order.
If there is no target port (i.e. if source port is not entangled), or if doomed is true, then abort these steps.
Let source channel be source's channel name.
-Let cloned message be a structured clone of the message argument. If this throws an exception, then rethrow that exception and - abort these steps.
Let targetRealm be a user-agent defined Realm.
Let cloned message be StructuredClone(message, + targetRealm). Rethrow any exceptions.
Let targetRealm be BroadcastChannel object's relevant
+ settings object's Realm.
Create an event that uses the MessageEvent interface, with the event type
message, which does not bubble, is not cancelable, and has
no default action. The data attribute must be
- initialised to a structured clone of cloned message, and the origin attribute must be initialised
- to the Unicode serialisation of the
- origin specified by source settings. This event is not trusted.
origin
+ attribute must be initialised to the Unicode
+ serialisation of the origin specified by source settings. This
+ event is not trusted.Dispatch the event at the
BroadcastChannel object.
[Global=(Worker,DedicatedWorker),Exposed=DedicatedWorker] /*sealed*/ interface DedicatedWorkerGlobalScope : WorkerGlobalScope { - void postMessage(any message, optional sequence<Transferable> transfer); + void postMessage(any message, optional sequence<object> transfer = []); attribute EventHandler onmessage; };@@ -94947,7 +94970,7 @@ interface AbstractWorker { interface Worker : EventTarget { void terminate(); - void postMessage(any message, optional sequence<Transferable> transfer); + void postMessage(any message, optional sequence<object> transfer = []); attribute EventHandler onmessage; }; @@ -117011,6 +117034,7 @@ INSERT INTERFACES HERE Alexis Deveria, Alice Boxhall, Allan Clements, + Allen Wirfs-Brock, Ami Fischman, Amos Jeffries, Anders Carlsson,