File System ( PR #9 ) PR Preview — Last Updated 22 June 2023 Participate: GitHub whatwg/fs ( new issue , open issues ) Chat on Matrix Commits: GitHub whatwg/fs/commits Go to the living standard @whatfilesystem Tests: web-platform-tests fs/ ( ongoing work ) This is a pull request preview of the standard This document contains the contents of the standard as modified by pull request #9 , and should only be used as a preview. Do not attempt to implement this version of the standard. Do not reference this version as authoritative in any way. Instead, see https://fs.spec.whatwg.org/ for the living standard. Abstract File System defines infrastructure for file systems as well as their API. Table of Contents 1 Introduction 2 Files and Directories 2.1 Concepts 2.2 The FileSystemHandle interface 2.2.1 The isSameEntry() method 2.3 The FileSystemFileHandle interface 2.3.1 The getFile() method 2.3.2 The createWritable() method 2.3.3 The createSyncAccessHandle() method 2.4 The FileSystemDirectoryHandle interface 2.4.1 Directory iteration 2.4.2 The getFileHandle() method 2.4.3 The getDirectoryHandle() method 2.4.4 The removeEntry() method 2.4.5 The resolve() method 2.5 The FileSystemWritableFileStream interface 2.5.1 The write() method 2.5.2 The seek() method 2.5.3 The truncate() method 2.6 The FileSystemSyncAccessHandle interface 2.6.1 The read() method 2.6.2 The write() method 2.6.3 The truncate() method 2.6.4 The getSize() method 2.6.5 The flush() method 2.6.6 The close() method 3 Accessing the Bucket File System Acknowledgments Intellectual property rights Index Terms defined by this specification Terms defined by reference References Normative References IDL Index 1. Introduction This section is non-normative. This document defines fundamental infrastructure for file system APIs. In addition, it defines an API that makes it possible for websites to get access to a file system directory without having to first prompt the user for access. This enables use cases where a website wants to save data to disk before a user has picked a location to save to, without forcing the website to use a completely different storage mechanism with a different API for such files. The entry point for this is the navigator.storage.getDirectory() method. 2. Files and Directories 2.1. Concepts A file system entry is either a file entry or a directory entry . Each file system entry has an associated query access algorithm, which takes " read " or " readwrite " mode and returns a file system access result . Unless specified otherwise it returns a file system access result with a permission state of " denied " and with an error name of the empty string. Each file system entry has an associated request access algorithm, which takes " read " or " readwrite " mode and returns a file system access result . Unless specified otherwise it returns a file system access result with a permission state of " denied " and with an error name of the empty string. A file system access result is a struct encapsulating the result of querying or requesting access to the file system. It has the following items : permission state A PermissionState error name A string which must be the empty string if permission state is " granted "; otherwise an name listed in the DOMException names table . It is expected that in most cases when permission state is not " granted ", this should be " NotAllowedError ". Dependent specifications may consider this API a powerful feature . However, unlike other powerful features whose permission request algorithm may throw, file system entry 's query access and request access algorithms must run in parallel on the file system queue and are therefore not allowed to throw. Instead, the caller is expected to queue a storage task to reject , as appropriate, should these algorithms return an error name other than the empty string. Note: Implementations that only implement this specification and not dependent specifications do not need to bother implementing file system entry 's query access and request access . Make access check algorithms associated with a FileSystemHandle. Each file system entry has an associated name (a string ). A valid file name is a string that is not an empty string, is not equal to "." or "..", and does not contain '/' or any other character used as path separator on the underlying platform. Note: This means that '\' is not allowed in names on Windows, but might be allowed on other operating systems. Additionally underlying file systems might have further restrictions on what names are or aren’t allowed, so a string merely being a valid file name is not a guarantee that creating a file or directory with that name will succeed. We should consider having further normative restrictions on file names that will never be allowed using this API, rather than leaving it entirely up to underlying file systems. A file entry additionally consists of binary data (a byte sequence ), a modification timestamp (a number representing the number of milliseconds since the Unix Epoch ), a lock (a string that may exclusively be " open ", " taken-exclusive " or " taken-shared ") and a shared lock count (a number representing the number shared locks that are taken at a given point in time). A user agent has an associated file system queue which is the result of starting a new parallel queue . This queue is to be used for all file sytem operations. To take a lock with a value of " exclusive " or " shared " on a given file entry file : Let lock be the file ’s lock . Let count be the file ’s shared lock count . If value is " exclusive ": If lock is " open ": Set lock to " taken-exclusive ". Return " success ". If value is " shared ": If lock is " open ": Set lock to " taken-shared ". Set count to 1. Return " success ". Otherwise, if lock is " taken-shared ": Increase count by 1. Return " success ". Return " failure ". Note: These steps have to be run on the file system queue . To release a lock on a given file entry file : Let lock be the file ’s associated lock . Let count be the file ’s shared lock count . If lock is " taken-shared ": Decrease count by 1. If count is 0, set lock to " open ". Otherwise, set lock to " open ". Note: These steps have to be run on the file system queue . Note: Locks help prevent concurrent modifications to a file. A FileSystemWritableFileStream requires a shared lock, while a FileSystemSyncAccessHandle requires an exclusive one. A directory entry additionally consists of a set of children , which are themselves file system entries . Each member is either a file entry or a directory entry . A file system entry entry should be contained in the children of at most one directory entry , and that directory entry is also known as entry ’s parent . A file system entry 's parent is null if no such directory entry exists. Note: Two different file system entries can represent the same file or directory on disk, in which case it is possible for both entries to have a different parent, or for one entry to have a parent while the other entry does not have a parent. File system entries can (but don’t have to) be backed by files on the host operating system’s local file system, so it is possible for the binary data , modification timestamp , and children of entries to be modified by applications outside of this specification. Exactly how external changes are reflected in the data structures defined by this specification, as well as how changes made to the data structures defined here are reflected externally is left up to individual user-agent implementations. A file system entry a is the same entry as a file system entry b if a is equal to b , or if a and b are backed by the same file or directory on the local file system. To resolve a file system locator child relative to a directory locator root : Let result be a new promise . Enqueue the following steps to the file system queue : If child ’s locator 's root is not root ’s locator 's root , resolve result with null, and abort these steps. Let childPath be child ’s locator 's path . Let rootPath be root ’s locator 's path . If childPath is the same path as rootPath , resolve result with « », and abort these steps. If rootPath ’s size is greater than childPath ’s size , resolve result with null, and abort these steps. For each index of rootPath ’s indices : If rootPath .\[[ index ]] is not childPath .\[[ index ]], then resolve result with null, and abort these steps. Let relativePath be « ». For each index of the range from rootPath ’s size to rootPath ’s size , exclusive, append childPath .\[[ index ]] to relativePath . Resolve result with relativePath . Return result . A file system locator represents a potential location of a file system entry . A file system locator is either a file locator or a directory locator . Each file system locator has an associated path (a file system path ), a kind (a FileSystemHandleKind ), and a root (a file system root ). Consider giving each locator a storage bucket . A file locator is a file system locator whose kind is " file ". A directory locator is a file system locator whose kind is " directory ". A file system root is an opaque string whose value is implementation-defined . For a file system locator locator whichs locates to a file entry entry that conceptually exists at the path data/drafts/example.txt relative to the root directory of a bucket file system , locator ’s kind has to be " file ", locator ’s path has to be « " data ", " drafts ", " example.txt " », and locator ’s root might include relevant identifying information such as the storage bucket and the disk drive. A file system locator a is the same locator as a file system locator b if a ’s kind is b ’s kind , a ’s root is b ’s root , and a ’s path is the same path as b ’s path . The locate an entry algorithm given a file system locator locator runs an implementation-defined series of steps adhering to these constraints: If locator is a file locator , they return a file entry or null. If locator is a directory locator , they return a directory entry or null. If these steps return a non-null entry , then: Getting the locator with entry returns locator , provided no intermediate file system operations were run. entry ’s name is the last item of locator ’s path . The get the locator algorithm given file system entry entry runs an implementation-defined series of steps adhering to these constraints: If entry is a file entry , they return a file locator . If entry is a directory entry , they return a directory locator . If these steps return locator , then: Locating an entry with locator returns entry , provided no intermediate file system operations were run. entry ’s name is the last item of locator ’s path . A file system path is a list of one or more strings . This may be a virtual path that is mapped to real location on disk or in memory, may correspond directly to a path on the local file system, or may not correspond to any file on disk at all. The actual physical location of the corresponding file system entry is implementation-defined . Let path be the list « " data ", " drafts ", " example.txt " ». There is no expectation that a file named example.txt exists anywhere on disk. A file system path a is the same path as a file system path b if a ’s size is the same as b ’s size and for each index of a ’s indices a .\[[ index ]] is b .\[[ index ]]. The contents of a file system locator , including its path , are not expected to be shared in their entirety with the website process. The file system path might contain components which are not known to the website unless the file system locator is later resolved relative to a parent directory locator . 2.2. The FileSystemHandle interface { , , }; [] { ; ; ); }; A FileSystemHandle object is associated with a locator (a file system locator ). Note: Multiple FileSystemHandle objects can have the same file system locator . A FileSystemHandle is in a bucket file system if the first item of its locator 's path is the empty string. Note: This is a bit magical, but it works since only the root directory of a bucket file system can have a path which contains an empty string. See getDirectory() . All other item s of a path will be a valid file name . Consider improving this situation by giving each locator a storage bucket . FileSystemHandle objects are serializable objects . Their serialization steps , given value , serialized and forStorage are: Set serialized .[[Origin]] to value ’s relevant settings object 's origin . Set serialized .[[Locator]] to value ’s locator . Their deserialization steps , given serialized and value are: If serialized .[[Origin]] is not same origin with value ’s relevant settings object 's origin , then throw a " DataCloneError " DOMException . Set value ’s locator to serialized .[[Locator]]. handle . kind Returns " file " if handle is a FileSystemFileHandle , or " directory " if handle is a FileSystemDirectoryHandle . This can be used to distinguish files from directories when iterating over the contents of a directory. handle . name Returns the last path component of handle ’s locator 's path . The kind getter steps are to return this 's locator 's kind . The name getter steps are to return the last item (a string ) of this 's locator 's path . 2.2.1. The isSameEntry() method same = await handle1 . isSameEntry ( handle2 ) Returns true if handle1 and handle2 represent the same file or directory. The isSameEntry( other ) method steps are: Let realm be this 's relevant Realm . Let p be a new promise in realm . Enqueue the following steps to the file system queue : If this 's locator is the same locator as other ’s locator , resolve p with true. Otherwise resolve p with false. Return p . 2.3. The FileSystemFileHandle interface { ; }; [] { (); = {}); [] (); }; Note: A FileSystemFileHandle 's associated locator 's kind is " file ". To create a child FileSystemFileHandle given a directory locator parentLocator and a string name in a Realm realm : Let handle be a new FileSystemFileHandle in realm . Let childType be " file ". Let childRoot be a copy of parentLocator ’s root . Let childPath be the result of cloning parentLocator ’s path and appending name . Set handle ’s locator to a file system locator whose kind is childType , root is childRoot , and path is childPath . Return handle . To create a new FileSystemFileHandle given a file system root root and a file system path path in a Realm realm : Let handle be a new FileSystemFileHandle in realm . Set handle ’s locator to a file system locator whose kind is " file ", root is root , and path is path . Return handle . FileSystemFileHandle objects are serializable objects . Their serialization steps and deserialization steps are the same as those for FileSystemHandle . 2.3.1. The getFile() method file = await fileHandle . getFile() Returns a File representing the state on disk of the file entry locatable by handle ’s locator . If the file on disk changes or is removed after this method is called, the returned File object will likely be no longer readable. The getFile() method steps are: Let result be a new promise . Let locator be this 's locator . Let global be this 's relevant global object . Enqueue the following steps to the file system queue : Let entry be the result of locating an entry given locator . Let accessResult be the result of running entry ’s query access given " read ". Queue a storage task with global to run these steps: If accessResult ’s permission state is not " granted ", reject result with a DOMException of accessResult ’s error name and abort these steps. If entry is null, reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a file entry . Let f be a new File . Set f ’s snapshot state to the current state of entry . Set f ’s underlying byte sequence to a copy of entry ’s binary data . Set f ’s name to entry ’s name . Set f ’s lastModified to entry ’s modification timestamp . Set f ’s type to an implementation-defined value, based on for example entry ’s name or its file extension. The reading and snapshotting behavior needs to be better specified in the [FILE-API] spec, for now this is kind of hand-wavy. Resolve result with f . Return result . 2.3.2. The createWritable() method stream = await fileHandle . createWritable() stream = await fileHandle . createWritable ({ keepExistingData : true/false }) Returns a FileSystemWritableFileStream that can be used to write to the file. Any changes made through stream won’t be reflected in the file entry locatable by fileHandle ’s locator until the stream has been closed. User agents try to ensure that no partial writes happen, i.e. the file will either contain its old contents or it will contain whatever data was written through stream up until the stream has been closed. This is typically implemented by writing data to a temporary file, and only replacing the file entry locatable by fileHandle ’s locator with the temporary file when the writable filestream is closed. If keepExistingData is false or not specified, the temporary file starts out empty, otherwise the existing file is first copied to this temporary file. Creating a FileSystemWritableFileStream takes a shared lock on the file entry locatable with fileHandle ’s locator . This prevents the creation of FileSystemSyncAccessHandles for the entry, until the stream is closed. See WICG/file-system-access issue #67 for discussion around and desire for a "inPlace" mode for createWritable (where changes will be written to the actual underlying file as they are written to the writer, for example to support in-place modification of large files or things like databases). This is not currently implemented in Chrome. Implementing this is currently blocked on figuring out how to combine the desire to run malware checks with the desire to let websites make fast in-place modifications to existing large files. In-place writes are available for files in a bucket file system via the FileSystemSyncAccessHandle interface. The createWritable( options ) method steps are: Let result be a new promise . Let locator be this 's locator . Let realm be this 's relevant Realm . Let global be this 's relevant global object . Enqueue the following steps to the file system queue : Let entry be the result of locating an entry given locator . Let accessResult be the result of running entry ’s request access given " readwrite ". If accessResult ’s permission state is not " granted ", queue a storage task with global to reject result with a DOMException of accessResult ’s error name and abort these steps. If entry is null , queue a storage task with global to reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a file entry . Let lockResult be the result of taking a lock with " shared " on entry . Queue a storage task with global to run these steps: If lockResult is " failure ", reject result with a " NoModificationAllowedError " DOMException and abort these steps. Let stream be the result of creating a new FileSystemWritableFileStream for entry in realm . If options [" keepExistingData "] is true: Set stream ’s [[buffer]] to a copy of entry ’s binary data . Resolve result with stream . Return result . 2.3.3. The createSyncAccessHandle() method handle = await fileHandle . createSyncAccessHandle () Returns a FileSystemSyncAccessHandle that can be used to read from/write to the file. Changes made through handle might be immediately reflected in the file entry locatable by fileHandle ’s locator . To ensure the changes are reflected in this file, the handle can be flushed. Creating a FileSystemSyncAccessHandle takes an exclusive lock on the file entry locatable with fileHandle ’s locator . This prevents the creation of further FileSystemSyncAccessHandles or FileSystemWritableFileStreams for the entry, until the access handle is closed. The returned FileSystemSyncAccessHandle offers synchronous methods. This allows for higher performance on contexts where asynchronous operations come with high overhead, e.g., WebAssembly. For the time being, this method will only succeed when the fileHandle is in a bucket file system . The createSyncAccessHandle() method steps are: Let result be a new promise . Let locator be this 's locator . Let realm be this 's relevant Realm . Let global be this 's relevant global object . Let isInABucketFileSystem be true if this is in a bucket file system ; otherwise false. Enqueue the following steps to the file system queue : Let entry be the result of locating an entry given locator . Let accessResult be the result of running entry ’s request access given " readwrite ". If accessResult ’s permission state is not " granted ", queue a storage task with global to reject result with a DOMException of accessResult ’s error name and abort these steps. If isInABucketFileSystem is false, queue a storage task with global to reject result with an " InvalidStateError " DOMException and abort these steps. If entry is null , queue a storage task with global to reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a file entry . Let lockResult be the result of taking a lock with " exclusive " on entry . Queue a storage task with global to run these steps: If lockResult is " failure ", reject result with a " NoModificationAllowedError " DOMException and abort these steps. Let handle be the result of creating a new FileSystemSyncAccessHandle for entry in realm . Resolve result with handle . Return result . 2.4. The FileSystemDirectoryHandle interface { ; }; { ; }; { ; }; [] { >; = {}); = {}); = {}); ); }; Note: A FileSystemDirectoryHandle 's associated locator 's kind is " directory ". To create a child FileSystemDirectoryHandle given a directory locator parentLocator and a string name in a Realm realm : Let handle be a new FileSystemDirectoryHandle in realm . Let childType be " directory ". Let childRoot be a copy of parentLocator ’s root . Let childPath be the result of cloning parentLocator ’s path and appending name . Set handle ’s locator to a file system locator whose kind is childType , root is childRoot , and path is childPath . Return handle . To create a new FileSystemDirectoryHandle given a file system root root and a file system path path in a Realm realm : Let handle be a new FileSystemDirectoryHandle in realm . Set handle ’s locator to a file system locator whose kind is " directory ", root is root , and path is path . Return handle . FileSystemDirectoryHandle objects are serializable objects . Their serialization steps and deserialization steps are the same as those for FileSystemHandle . 2.4.1. Directory iteration for await (let [ name , handle ] of directoryHandle ) {} for await (let [ name , handle ] of directoryHandle . entries()) {} for await (let handle of directoryHandle . values()) {} for await (let name of directoryHandle . keys()) {} Iterates over all entries whose parent is the directory entry locatable by directoryHandle ’s locator . Entries that are created or deleted while the iteration is in progress might or might not be included. No guarantees are given either way. In the future we might want to add arguments to the async iterable declaration to support for example recursive iteration. The asynchronous iterator initialization steps for a FileSystemDirectoryHandle handle and its async iterator iterator are: Set iterator ’s past results to an empty set . To get the next iteration result for a FileSystemDirectoryHandle handle and its async iterator iterator : Let promise be a new promise . Enqueue the following steps to the file system queue : Let directory be the result of locating an entry given handle ’s locator . Let accessResult be the result of running directory ’s query access given " read ". Queue a storage task with handle ’s relevant global object to run these steps: If accessResult ’s permission state is not " granted ", reject promise with a DOMException of accessResult ’s error name and abort these steps.: If directory is null , reject result with a " NotFoundError " DOMException and abort these steps. Assert : directory is a directory entry . Let child be a file system entry in directory ’s children , such that child ’s name is not contained in iterator ’s past results , or null if no such entry exists. Note: This is intentionally very vague about the iteration order. Different platforms and file systems provide different guarantees about iteration order, and we want it to be possible to efficiently implement this on all platforms. As such no guarantees are given about the exact order in which elements are returned. If child is null , resolve promise with undefined and abort these steps. Append child ’s name to iterator ’s past results . If child is a file entry : Let result be the result of creating a child FileSystemFileHandle with handle ’s locator and child ’s name in handle ’s relevant Realm . Otherwise: Let result be the result of creating a child FileSystemDirectoryHandle with handle ’s locator and child ’s name in handle ’s relevant Realm . Resolve promise with ( child ’s name , result ). Return promise . 2.4.2. The getFileHandle() method fileHandle = await directoryHandle . getFileHandle ( name ) fileHandle = await directoryHandle . getFileHandle ( name , { create : false }) Returns a handle for a file named name in the directory entry locatable by directoryHandle ’s locator . If no such file exists, this rejects. fileHandle = await directoryHandle . getFileHandle ( name , { create : true }) Returns a handle for a file named name in the directory entry locatable by directoryHandle ’s locator . If no such file exists, this creates a new file. If no file with named name can be created this rejects. Creation can fail because there already is a directory with the same name, because the name uses characters that aren’t supported in file names on the underlying file system, or because the user agent for security reasons decided not to allow creation of the file. This operation requires write permission, even if the file being returned already exists. If this handle doesn’t already have write permission, this could result in a prompt being shown to the user. To get an existing file without needing write permission, call this method with { create : false } . The getFileHandle( name , options ) method steps are: Let result be a new promise . Let realm be this 's relevant Realm . Let locator be this 's locator . Let global be this 's relevant global object . Enqueue the following steps to the file system queue : If name is not a valid file name , queue a storage task with global to reject result with a TypeError and abort these steps. Let entry be the result of locating an entry given locator . If options [" create "] is true: Let accessResult be the result of running entry ’s request access given " readwrite ". Otherwise: Let accessResult be the result of running entry ’s query access given " read ". Queue a storage task with global to run these steps: If accessResult ’s permission state is not " granted ", reject result with a DOMException of accessResult ’s error name and abort these steps. If entry is null , reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a directory entry . For each child of entry ’s children : If child ’s name equals name : If child is a directory entry : Reject result with a " TypeMismatchError " DOMException and abort these steps. Resolve result with the result of creating a child FileSystemFileHandle with locator and child ’s name in realm and abort these steps. If options [" create "] is false: Reject result with a " NotFoundError " DOMException and abort these steps. Let child be a new file entry whose query access and request access algorithms are those of entry . Set child ’s name to name . Set child ’s binary data to an empty byte sequence . Set child ’s modification timestamp to the current time. Append child to entry ’s children . If creating child in the underlying file system throws an exception, reject result with that exception and abort these steps. Better specify what possible exceptions this could throw. Resolve result with the result of creating a child FileSystemFileHandle with locator and child ’s name in realm . Return result . 2.4.3. The getDirectoryHandle() method subdirHandle = await directoryHandle . getDirectoryHandle ( name ) subdirHandle = await directoryHandle . getDirectoryHandle ( name , { create : false }) Returns a handle for a directory named name in the directory entry locatable by directoryHandle ’s locator . If no such directory exists, this rejects. subdirHandle = await directoryHandle . getDirectoryHandle ( name , { create : true }) Returns a handle for a directory named name in the directory entry locatable by directoryHandle ’s locator . If no such directory exists, this creates a new directory. If creating the directory failed, this rejects. Creation can fail because there already is a file with the same name, or because the name uses characters that aren’t supported in file names on the underlying file system. This operation requires write permission, even if the directory being returned already exists. If this handle doesn’t already have write permission, this could result in a prompt being shown to the user. To get an existing directory without needing write permission, call this method with { create : false } . The getDirectoryHandle( name , options ) method steps are: Let result be a new promise . Let realm be this 's relevant Realm . Let locator be this 's locator . Let global be this 's relevant global object . Enqueue the following steps to the file system queue : If name is not a valid file name , queue a storage task with global to reject result with a TypeError and abort these steps. Let entry be the result of locating an entry given locator . If options [" create "] is true: Let accessResult be the result of running entry ’s request access given " readwrite ". Otherwise: Let accessResult be the result of running entry ’s query access given " read ". Queue a storage task with global to run these steps: If accessResult ’s permission state is not " granted ", reject result with a DOMException of accessResult ’s error name and abort these steps. If entry is null , reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a directory entry . For each child of entry ’s children : If child ’s name equals name : If child is a file entry : Reject result with a " TypeMismatchError " DOMException and abort these steps. Resolve result with the result of creating a child FileSystemDirectoryHandle with locator and child ’s name in realm and abort these steps. If options [" create "] is false: Reject result with a " NotFoundError " DOMException and abort these steps. Let child be a new directory entry whose query access and request access algorithms are those of entry . Set child ’s name to name . Set child ’s children to an empty set . Append child to entry ’s children . If creating child in the underlying file system throws an exception, reject result with that exception and abort these steps. Better specify what possible exceptions this could throw. Resolve result with the result of creating a child FileSystemDirectoryHandle with locator and child ’s name in realm . Return result . 2.4.4. The removeEntry() method await directoryHandle . removeEntry ( name ) await directoryHandle . removeEntry ( name , { recursive : false }) If the directory entry locatable by directoryHandle ’s locator contains a file named name , or an empty directory named name , this will attempt to delete that file or directory. Attempting to delete a file or directory that does not exist is considered success, while attempting to delete a non-empty directory will result in a promise rejection. await directoryHandle . removeEntry ( name , { recursive : true }) Removes the file system entry named name in the directory entry locatable by directoryHandle ’s locator . If that entry is a directory, its contents will also be deleted recursively. Attempting to delete a file or directory that does not exist is considered success. The removeEntry( name , options ) method steps are: Let result be a new promise . Let locator be this 's locator . Let global be this 's relevant global object . Enqueue the following steps to the file system queue : If name is not a valid file name , queue a storage task with global to reject result with a TypeError and abort these steps. Let entry be the result of locating an entry given locator . Let accessResult be the result of running entry ’s request access given " readwrite ". Queue a storage task with global to run these steps: If accessResult ’s permission state is not " granted ", reject result with a DOMException of accessResult ’s error name and abort these steps. If entry is null , reject result with a " NotFoundError " DOMException and abort these steps. Assert : entry is a directory entry . For each child of entry ’s children : If child ’s name equals name : If child is a directory entry : If child ’s children is not empty and options [" recursive "] is false: Reject result with an " InvalidModificationError " DOMException and abort these steps. Remove child from entry ’s children . If removing child in the underlying file system throws an exception, reject result with that exception and abort these steps. Note: If recursive is true, the removal can fail non-atomically. Some files or directories might have been removed while other files or directories still exist. Better specify what possible exceptions this could throw. Resolve result with undefined . Reject result with a " NotFoundError " DOMException . Return result . 2.4.5. The resolve() method path = await directory . resolve ( child ) If child is equal to directory , path will be an empty array. If child is a direct child of directory , path will be an array containing child ’s name. If child is a descendant of directory , path will be an array containing the names of all the intermediate directories and child ’s name as last element. For example if directory represents /home/user/project and child represents /home/user/project/foo/bar , this will return ['foo', 'bar'] . Otherwise ( directory and child are not related), path will be null. assert relative_path entry entry assert The resolve( possibleDescendant ) method steps are to return the result of resolving possibleDescendant ’s locator relative to this 's locator . 2.5. The FileSystemWritableFileStream interface { , , , }; { ; ; ; (; }; ; [] { ); ); ); }; A FileSystemWritableFileStream has an associated [[file]] (a file entry ). A FileSystemWritableFileStream has an associated [[buffer]] (a byte sequence ). It is initially empty. Note: This buffer can get arbitrarily large, so it is expected that implementations will not keep this in memory, but instead use a temporary file for this. All access to [[buffer]] is done in promise returning methods and algorithms, so even though operations on it seem sync, implementations can implement them async. A FileSystemWritableFileStream has an associated [[seekOffset]] (a number). It is initially 0. A FileSystemWritableFileStream object is a WritableStream object with additional convenience methods, which operates on a single file on disk. Upon creation, an underlying sink will have been created and the stream will be usable. All operations executed on the stream are queuable and producers will be able to respond to backpressure. The underlying sink’s write method, and therefore WritableStreamDefaultWriter’s write() method, will accept byte-like data or WriteParams as input. The FileSystemWritableFileStream has a file position cursor initialized at byte offset 0 from the top of the file. When using write() or by using WritableStream capabilities through the WritableStreamDefaultWriter’s write() method, this position will be advanced based on the number of bytes written through the stream object. Similarly, when piping a ReadableStream into a FileSystemWritableFileStream object, this position is updated with the number of bytes that passed through the stream. getWriter() returns an instance of WritableStreamDefaultWriter . To create a new FileSystemWritableFileStream given a file entry file in a Realm realm : Let stream be a new FileSystemWritableFileStream in realm . Set stream ’s [[file]] to file . Let writeAlgorithm be an algorithm which takes a chunk argument and returns the result of running the write a chunk algorithm with stream and chunk . Let closeAlgorithm be these steps: Let closeResult be a new promise . Enqueue the following steps to the file system queue : Let accessResult be the result of running file ’s query access given " readwrite ". Queue a storage task with file ’s relevant global object to run these steps: If accessResult ’s permission state is not " granted ", reject closeResult with a DOMException of accessResult ’s error name and abort these steps. Run implementation-defined malware scans and safe browsing checks. If these checks fail, reject closeResult with an " AbortError " DOMException and abort these steps. Set stream ’s [[file]] 's binary data to stream ’s [[buffer]] . If that throws an exception, reject closeResult with that exception and abort these steps. Note: It is expected that this atomically updates the contents of the file on disk being written to. Enqueue the following steps to the file system queue : Release the lock on stream ’s [[file]] . Queue a storage task with file ’s relevant global object to resolve closeResult with undefined . Return closeResult . Let abortAlgorithm be these steps: Enqueue this step to the file system queue : Release the lock on stream ’s [[file]] . Let highWaterMark be 1. Let sizeAlgorithm be an algorithm that returns 1 . Set up stream with writeAlgorithm set to writeAlgorithm , closeAlgorithm set to closeAlgorithm , abortAlgorithm set to abortAlgorithm , highWaterMark set to highWaterMark , and sizeAlgorithm set to sizeAlgorithm . Return stream . The write a chunk algorithm, given a FileSystemWritableFileStream stream and chunk , runs these steps: Let input be the result of converting chunk to a FileSystemWriteChunkType . If this throws an exception, then return a promise rejected with that exception. Let p be a new promise . Enqueue the following steps to the file system queue : Let accessResult be the result of running stream ’s [[file]] 's query access given " readwrite ". Queue a storage task with stream ’s relevant global object to run these steps: If accessResult ’s permission state is not " granted ", reject p with a DOMException of accessResult ’s error name and abort these steps. Let command be input [" type "] if input is a dictionary ; otherwise " write ". If command is " write ": If input is undefined or input is a dictionary and input [" data "] does not exist , reject p with a TypeError and abort these steps. Let data be input [" data "] if input is a dictionary ; otherwise input . Let writePosition be stream ’s [[seekOffset]] . If input is a dictionary and input [" position "] exists , set writePosition to input [" position "]. Let oldSize be stream ’s [[buffer]] 's length . If data is a BufferSource , let dataBytes be a copy of data . Otherwise, if data is a Blob : Let dataBytes be the result of performing the read operation on data . If this throws an exception, reject p with that exception and abort these steps. Otherwise: Assert : data is a USVString . Let dataBytes be the result of UTF-8 encoding data . If writePosition is larger than oldSize , append writePosition - oldSize 0x00 (NUL) bytes to the end of stream ’s [[buffer]] . Note: Implementations are expected to behave as if the skipped over file contents are indeed filled with NUL bytes. That doesn’t mean these bytes have to actually be written to disk and take up disk space. Instead most file systems support so called sparse files, where these NUL bytes don’t take up actual disk space. Let head be a byte sequence containing the first writePosition bytes of stream ’s [[buffer]] . Let tail be an empty byte sequence . If writePosition + data ’s length is smaller than oldSize : Let tail be a byte sequence containing the last oldSize - ( writePosition + data ’s length ) bytes of stream ’s [[buffer]] . Set stream ’s [[buffer]] to the concatenation of head , data and tail . If the operations modifying stream ’s [[buffer]] in the previous steps failed due to exceeding the storage quota , reject p with a " QuotaExceededError " DOMException and abort these steps, leaving stream ’s [[buffer]] unmodified. Note: Storage quota only applies to files stored in a bucket file system . However this operation could still fail for other files, for example if the disk being written to runs out of disk space. Set stream ’s [[seekOffset]] to writePosition + data ’s length . Resolve p . Otherwise, if command is " seek ": Assert : chunk is a dictionary . If chunk [" position "] does not exist , reject p with a TypeError and abort these steps. Set stream ’s [[seekOffset]] to chunk [" position "]. Resolve p . Otherwise, if command is " truncate ": Assert : chunk is a dictionary . If chunk [" size "] does not exist , reject p with a TypeError and abort these steps. Let newSize be chunk [" size "]. Let oldSize be stream ’s [[buffer]] 's length . If newSize is larger than oldSize : Set stream ’s [[buffer]] to a byte sequence formed by concating stream ’s [[buffer]] with a byte sequence containing newSize - oldSize 0x00 bytes. If the operation in the previous step failed due to exceeding the storage quota , reject p with a " QuotaExceededError " DOMException and abort these steps, leaving stream ’s [[buffer]] unmodified. Note: Storage quota only applies to files stored in a bucket file system . However this operation could still fail for other files, for example if the disk being written to runs out of disk space. Otherwise, if newSize is smaller than oldSize : Set stream ’s [[buffer]] to a byte sequence containing the first newSize bytes in stream ’s [[buffer]] . If stream ’s [[seekOffset]] is bigger than newSize , set stream ’s [[seekOffset]] to newSize . Resolve p . Return p . 2.5.1. The write() method await stream . write ( data ) await stream . write ({ type : " write ", data : data }) Writes the content of data into the file associated with stream at the current file cursor offset. No changes are written to the actual file on disk until the stream has been closed. Changes are typically written to a temporary file instead. await stream . write ({ type : " write ", position : position , data : data }) Writes the content of data into the file associated with stream at position bytes from the top of the file. Also updates the current file cursor offset to the end of the written data. No changes are written to the actual file on disk until the stream has been closed. Changes are typically written to a temporary file instead. await stream . write ({ type : " seek ", position : position }) Updates the current file cursor offset the position bytes from the top of the file. await stream . write ({ type : " truncate ", size : size }) Resizes the file associated with stream to be size bytes long. If size is larger than the current file size this pads the file with null bytes, otherwise it truncates the file. The file cursor is updated when truncate is called. If the cursor is smaller than size , it remains unchanged. If the cursor is larger than size , it is set to size to ensure that subsequent writes do not error. No changes are written to the actual file until on disk until the stream has been closed. Changes are typically written to a temporary file instead. The write( data ) method steps are: Let writer be the result of getting a writer for this . Let result be the result of writing a chunk to writer given data . Release writer . Return result . 2.5.2. The seek() method await stream . seek ( position ) Updates the current file cursor offset the position bytes from the top of the file. The seek( position ) method steps are: Let writer be the result of getting a writer for this . Let result be the result of writing a chunk to writer given «[ " type " → " seek ", " position " → position ]». Release writer . Return result . 2.5.3. The truncate() method await stream . truncate ( size ) Resizes the file associated with stream to be size bytes long. If size is larger than the current file size this pads the file with null bytes, otherwise it truncates the file. The file cursor is updated when truncate is called. If the cursor is smaller than size , it remains unchanged. If the cursor is larger than size , it is set to size to ensure that subsequent writes do not error. No changes are written to the actual file until on disk until the stream has been closed. Changes are typically written to a temporary file instead. The truncate( size ) method steps are: Let writer be the result of getting a writer for this . Let result be the result of writing a chunk to writer given «[ " type " → " truncate ", " size " → size ]». Release writer . Return result . 2.6. The FileSystemSyncAccessHandle interface { [; }; [] { , = {}); , = {}); ); (); (); (); }; A FileSystemSyncAccessHandle has an associated [[file]] (a file entry ). A FileSystemSyncAccessHandle has an associated [[state]] , a string that may exclusively be " open " or " closed ". A FileSystemSyncAccessHandle is an object that is capable of reading from/writing to, as well as obtaining and changing the size of, a single file. A FileSystemSyncAccessHandle offers synchronous methods. This allows for higher performance on contexts where asynchronous operations come with high overhead, e.g., WebAssembly. A FileSystemSyncAccessHandle has a file position cursor initialized at byte offset 0 from the top of the file. To create a new FileSystemSyncAccessHandle given a file entry file in a Realm realm : Let handle be a new FileSystemSyncAccessHandle in realm . Set handle ’s [[file]] to file . Set handle ’s [[state]] to " open ". Return handle . 2.6.1. The read() method handle . read ( buffer ) handle . read ( buffer , { at }) Reads the contents of the file associated with handle into buffer , optionally at a given offset. The file cursor is updated when read() is called to point to the byte after the last byte read. Specify how Access Handles should react when reading from a file that has been modified externally. The read( buffer , FileSystemReadWriteOptions : options ) method steps are: If this 's [[state]] is " closed ", throw an " InvalidStateError " DOMException . Let bufferSize be buffer ’s byte length . Let fileContents be this 's [[file]] 's binary data . Let fileSize be fileContents ’s length . Let readStart be options [" at "] if options [" at "] exists ; otherwise this 's file position cursor . If the underlying file system does not support reading from a file offset of readStart , throw a TypeError . If readStart is larger than fileSize : Set this 's file position cursor to fileSize . Return 0. Let readEnd be readStart + ( bufferSize − 1). If readEnd is larger than fileSize , set readEnd to fileSize . Let bytes be a byte sequence containing the bytes from readStart to readEnd of fileContents . Let result be bytes ’s length . If the operations reading from fileContents in the previous steps failed: If there were partial reads and the number of bytes that were read into bytes is known, set result to the number of read bytes. Otherwise set result to 0. Let arrayBuffer be buffer ’s underlying buffer . Write bytes into arrayBuffer . Set this 's file position cursor to readStart + result . Return result . 2.6.2. The write() method handle . write ( buffer ) handle . write ( buffer , { at }) Writes the content of buffer into the file associated with handle , optionally at a given offset, and returns the number of written bytes. Checking the returned number of written bytes allows callers to detect and handle errors and partial writes. The file cursor is updated when write is called to point to the byte after the last byte written. The write( buffer , FileSystemReadWriteOptions : options ) method steps are: If this 's [[state]] is " closed ", throw an " InvalidStateError " DOMException . Let writePosition be options [" at "] if options [" at "] exists ; otherwise this 's file position cursor . If the underlying file system does not support writing to a file offset of writePosition , throw a TypeError . Let fileContents be a copy of this 's [[file]] 's binary data . Let oldSize be fileContents ’s length . Let bufferSize be buffer ’s byte length . If writePosition is larger than oldSize , append writePosition − oldSize 0x00 (NUL) bytes to the end of fileContents . Note: Implementations are expected to behave as if the skipped over file contents are indeed filled with NUL bytes. That doesn’t mean these bytes have to actually be written to disk and take up disk space. Instead most file systems support so called sparse files, where these NUL bytes don’t take up actual disk space. Let head be a byte sequence containing the first writePosition bytes of fileContents . Let tail be an empty byte sequence . If writePosition + bufferSize is smaller than oldSize : Set tail to a byte sequence containing the last oldSize − ( writePosition + bufferSize ) bytes of fileContents . Let newSize be head ’s length + bufferSize + tail ’s length . If newSize − oldSize exceeds the available storage quota , throw a " QuotaExceededError " DOMException . Set this 's [[file]] 's binary data to the concatenation of head , the contents of buffer and tail . Note: The mechanism used to access buffer’s contents is left purposely vague. It is likely that implementations will choose to focus on performance by issuing direct write calls to the host operating system (instead of creating a copy of buffer), which prevents a detailed specification of the write order and the results of partial writes. If the operations modifying the this 's [[file]] 's binary data in the previous steps failed: If there were partial writes and the number of bytes that were written from buffer is known: Let bytesWritten be the number of bytes that were written from buffer . Set this 's file position cursor to writePosition + bytesWritten . Return bytesWritten . Otherwise throw an " InvalidStateError " DOMException . Set this 's file position cursor to writePosition + bufferSize . Return bufferSize . 2.6.3. The truncate() method handle . truncate ( newSize ) Resizes the file associated with handle to be newSize bytes long. If newSize is larger than the current file size this pads the file with null bytes; otherwise it truncates the file. The file cursor is updated when truncate is called. If the cursor is smaller than newSize , it remains unchanged. If the cursor is larger than newSize , it is set to newSize . The truncate( newSize ) method steps are: If this 's [[state]] is " closed ", throw an " InvalidStateError " DOMException . Let fileContents be a copy of this 's [[file]] 's binary data . Let oldSize be the length of this 's [[file]] 's binary data . If the underlying file system does not support setting a file’s size to newSize , throw a TypeError . If newSize is larger than oldSize : If newSize − oldSize exceeds the available storage quota , throw a " QuotaExceededError " DOMException . Set this 's [[file]] 's to a byte sequence formed by concatenating fileContents with a byte sequence containing newSize − oldSize 0x00 bytes. If the operations modifying the this 's [[file]] 's binary data in the previous steps failed, throw an " InvalidStateError " DOMException . Otherwise, if newSize is smaller than oldSize : Set this 's [[file]] 's to a byte sequence containing the first newSize bytes in fileContents . If the operations modifying the this 's [[file]] 's binary data in the previous steps failed, throw an " InvalidStateError " DOMException . If this 's file position cursor is greater than newSize , then set file position cursor to newSize . 2.6.4. The getSize() method handle . getSize() Returns the size of the file associated with handle in bytes. The getSize() method steps are: If this 's [[state]] is " closed ", throw an " InvalidStateError " DOMException . Return this 's [[file]] 's binary data 's length . 2.6.5. The flush() method handle . flush() Ensures that the contents of the file associated with handle contain all the modifications done through write() . The flush() method steps are: If this 's [[state]] is " closed ", throw an " InvalidStateError " DOMException . Attempt to transfer all cached modifications of the file’s content to the file system’s underlying storage device. Note: This is also known as flushing. This may be a no-op on some file systems, such as in-memory file systems, which do not have a "disk" to flush to. 2.6.6. The close() method handle . close() Closes the access handle or no-ops if the access handle is already closed. This disables any further operations on it and releases the lock on the [[file]] associated with handle . The close() method steps are: If this 's [[state]] is " closed ", return. Set this 's [[state]] to " closed ". Set lockReleased to false. Let file be this 's [[file]] . Enqueue the following steps to the file system queue : Release the lock on file . Set lockReleased to true. Pause until lockReleased is true. Note: This method does not guarantee that all file modifications will be immediately reflected in the underlying storage device. Call the flush() method first if you require this guarantee. 3. Accessing the Bucket File System The bucket file system is a storage endpoint whose identifier is "fileSystem" , types are « "local" » , and quota is null. Storage endpoints should be defined in [storage] itself, rather than being defined here. So merge this into the table there. Note: While user agents will typically implement this by persisting the contents of a bucket file system to disk, it is not intended that the contents are easily user accessible. Similarly there is no expectation that files or directories with names matching the names of children of a bucket file system exist. ] { (); }; directoryHandle = await navigator . storage . getDirectory() Returns the root directory of the bucket file system . The getDirectory() method steps are: Let environment be the current settings object . Let map be the result of running obtain a local storage bottle map with environment and "fileSystem" . If this returns failure, return a promise rejected with a " SecurityError " DOMException . If map ["root"] does not exist : Let dir be a new directory entry whose query access and request access algorithms always return a file system access result with a permission state of " granted " and with an error name of the empty string. Set dir ’s name to the empty string. Set dir ’s children to an empty set . Set map ["root"] to dir . Let root be an implementation-defined opaque string . Let path be « the empty string ». Let handle be the result of creating a new FileSystemDirectoryHandle . given root and path in the current realm . Note: root might include relevant identifying information such as the storage bucket . Assert: locating an entry given handle ’s locator returns a directory entry that is the same entry as map ["root"]. Return a promise resolved with handle . Acknowledgments Many thanks to Alex Danilo, Anne van Kesteren, Anoesj Sadraee, Austin Sullivan, Chase Phillips, Daseul Lee, Dru Knox, Edgar Chen, Emanuel Krivoy, Hazim Mohamed, Ingvar Stepanyan, Jari Jalkanen, Joshua Bell, Kagami Sascha Rosylight, Marcos Cáceres, Martin Thomson, Olivier Yiptong, Philip Jägenstedt, Randell Jesup, Richard Stotz, Ruth John, Sid Vishnoi, Sihui Liu, Stefan Sauer, Thomas Steiner, Victor Costan, and Youenn Fablet for being awesome! This standard is written by Marijn Kruisselbrink ( Google , mek@chromium.org ). Intellectual property rights This Living Standard includes material copied from W3C WICG’s File System Access , which is available under the W3C Software and Document License . Copyright © WHATWG (Apple, Google, Mozilla, Microsoft). This work is licensed under a Creative Commons Attribution 4.0 International License . To the extent portions of it are incorporated into source code, such portions in the source code are licensed under the BSD 3-Clause License instead. This is the Living Standard. Those interested in the patent-review version should view the Living Standard Review Draft . "use strict"; if ("serviceWorker" in navigator) { navigator.serviceWorker.register("/service-worker.js"); } Index Terms defined by this specification at , in § 2.6 binary data , in § 2.1 bucket file system , in § 3 [[buffer]] , in § 2.5 children , in § 2.1 close() , in § 2.6.6 create dict-member for FileSystemGetDirectoryOptions , in § 2.4 dict-member for FileSystemGetFileOptions , in § 2.4 create a new FileSystemSyncAccessHandle , in § 2.6 create a new FileSystemWritableFileStream , in § 2.5 createSyncAccessHandle() , in § 2.3.3 createWritable() , in § 2.3.2 createWritable(options) , in § 2.3.2 creating a child FileSystemDirectoryHandle , in § 2.4 creating a child FileSystemFileHandle , in § 2.3 creating a new FileSystemDirectoryHandle , in § 2.4 creating a new FileSystemFileHandle , in § 2.3 creating a new FileSystemSyncAccessHandle , in § 2.6 creating a new FileSystemWritableFileStream , in § 2.5 data , in § 2.5 "directory" , in § 2.2 directory entry , in § 2.1 directory locator , in § 2.1 error name , in § 2.1 "file" , in § 2.2 [[file]] dfn for FileSystemSyncAccessHandle , in § 2.6 dfn for FileSystemWritableFileStream , in § 2.5 file entry , in § 2.1 file locator , in § 2.1 file position cursor , in § 2.6 file system access result , in § 2.1 FileSystemCreateWritableOptions , in § 2.3 FileSystemDirectoryHandle , in § 2.4 file system entry , in § 2.1 FileSystemFileHandle , in § 2.3 FileSystemGetDirectoryOptions , in § 2.4 FileSystemGetFileOptions , in § 2.4 FileSystemHandle , in § 2.2 FileSystemHandleKind , in § 2.2 file system locator , in § 2.1 file system path , in § 2.1 file system queue , in § 2.1 FileSystemReadWriteOptions , in § 2.6 FileSystemRemoveOptions , in § 2.4 file system root , in § 2.1 FileSystemSyncAccessHandle , in § 2.6 FileSystemWritableFileStream , in § 2.5 FileSystemWriteChunkType , in § 2.5 flush() , in § 2.6.5 getDirectory() , in § 3 getDirectoryHandle(name) , in § 2.4.3 getDirectoryHandle(name, options) , in § 2.4.3 getFile() , in § 2.3.1 getFileHandle(name) , in § 2.4.2 getFileHandle(name, options) , in § 2.4.2 getSize() , in § 2.6.4 getting the locator , in § 2.1 is in a bucket file system , in § 2.2 isSameEntry(other) , in § 2.2.1 keepExistingData , in § 2.3 kind attribute for FileSystemHandle , in § 2.2 dfn for file system locator , in § 2.1 locating an entry , in § 2.1 locator , in § 2.2 lock , in § 2.1 modification timestamp , in § 2.1 name attribute for FileSystemHandle , in § 2.2 dfn for file system entry , in § 2.1 parent , in § 2.1 past results , in § 2.4.1 path , in § 2.1 permission state , in § 2.1 position , in § 2.5 query access , in § 2.1 read(buffer) , in § 2.6 read(buffer, FileSystemReadWriteOptions: options) , in § 2.6.1 read(buffer, options) , in § 2.6 recursive , in § 2.4 release , in § 2.1 removeEntry(name) , in § 2.4.4 removeEntry(name, options) , in § 2.4.4 request access , in § 2.1 resolve , in § 2.1 resolve(possibleDescendant) , in § 2.4.5 root , in § 2.1 "seek" , in § 2.5 [[seekOffset]] , in § 2.5 seek(position) , in § 2.5.2 shared lock count , in § 2.1 size , in § 2.5 [[state]] , in § 2.6 take , in § 2.1 the same entry as , in § 2.1 the same locator as , in § 2.1 the same path as , in § 2.1 "truncate" , in § 2.5 truncate(newSize) , in § 2.6.3 truncate(size) , in § 2.5.3 type , in § 2.5 valid file name , in § 2.1 "write" , in § 2.5 write a chunk , in § 2.5 write(buffer) , in § 2.6 write(buffer, FileSystemReadWriteOptions: options) , in § 2.6.2 write(buffer, options) , in § 2.6 WriteCommandType , in § 2.5 write(data) , in § 2.5.1 WriteParams , in § 2.5 Terms defined by reference [ECMASCRIPT] defines the following terms: TypeError current realm realm [ENCODING] defines the following terms: utf-8 encode [FILE-API] defines the following terms: Blob File lastModified name read operation snapshot state type unix epoch [HTML] defines the following terms: Serializable current settings object deserialization steps enqueue steps enqueue the following steps in parallel origin pause relevant global object relevant realm relevant settings object same origin serializable object serialization steps starting a new parallel queue [INFRA] defines the following terms: append (for list) append (for set) assert byte sequence clone contain exist for each implementation-defined indices is empty item (for list) item (for struct) length list remove set size string struct the range [PERMISSIONS] defines the following terms: PermissionState denied granted powerful feature [PERMISSIONS-REQUEST] defines the following terms: permission request algorithm [STORAGE] defines the following terms: StorageManager identifier obtain a local storage bottle map queue a storage task quota storage bucket storage endpoint storage quota types [STREAMS] defines the following terms: ReadableStream WritableStream WritableStreamDefaultWriter abortalgorithm closealgorithm getWriter() getting a writer highwatermark release set up sizealgorithm write() writealgorithm writing a chunk [WEBIDL] defines the following terms: AbortError AllowSharedBufferSource BufferSource DOMException DataCloneError EnforceRange Exposed InvalidModificationError InvalidStateError NoModificationAllowedError NotAllowedError NotFoundError Promise QuotaExceededError SecureContext SecurityError TypeMismatchError USVString a new promise a promise rejected with a promise resolved with asynchronous iterator initialization steps boolean byte length converted to an idl value dictionary domexception names table get a copy of the buffer source get the next iteration result name new reject resolve sequence this throw undefined underlying buffer unsigned long long write References Normative References [ECMASCRIPT] ECMAScript Language Specification . URL: https://tc39.es/ecma262/multipage/ [ENCODING] Anne van Kesteren. Encoding Standard . Living Standard. URL: https://encoding.spec.whatwg.org/ [FILE-API] Marijn Kruisselbrink. File API . URL: https://w3c.github.io/FileAPI/ [HTML] Anne van Kesteren; et al. HTML Standard . Living Standard. URL: https://html.spec.whatwg.org/multipage/ [INFRA] Anne van Kesteren; Domenic Denicola. Infra Standard . Living Standard. URL: https://infra.spec.whatwg.org/ [PERMISSIONS] Marcos Caceres; Mike Taylor. Permissions . URL: https://w3c.github.io/permissions/ [PERMISSIONS-REQUEST] Requesting Permissions . cg-draft. URL: https://wicg.github.io/permissions-request/ [STORAGE] Anne van Kesteren. Storage Standard . Living Standard. URL: https://storage.spec.whatwg.org/ [STREAMS] Adam Rice; et al. Streams Standard . Living Standard. URL: https://streams.spec.whatwg.org/ [WEBIDL] Edgar Chen; Timothy Gu. Web IDL Standard . Living Standard. URL: https://webidl.spec.whatwg.org/ IDL Index { , , }; [] { ; ; ); }; { ; }; [] { (); = {}); [] (); }; { ; }; { ; }; { ; }; [] { >; = {}); = {}); = {}); ); }; { , , , }; { ; ; ; (; }; ; [] { ); ); ); }; { [; }; [] { , = {}); , = {}); ); (); (); (); }; [] { (); }; /* Boilerplate: script-dfn-panel */ "use strict"; { const dfnsJson = window.dfnsJson || {}; function genDfnPanel({dfnID, url, dfnText, refSections, external}) { return mk.aside({ class: "dfn-panel", id: `infopanel-for-${dfnID}`, "data-for": dfnID, "aria-labelled-by":`infopaneltitle-for-${dfnID}`, }, mk.span({id:`infopaneltitle-for-${dfnID}`, style:"display:none"}, `Info about the '${dfnText}' ${external?"external":""} reference.`), mk.a({href:url}, url), mk.b({}, "Referenced in:"), mk.ul({}, ...refSections.map(section=> mk.li({}, ...section.refs.map((ref, refI)=> [ mk.a({ href: `#${ref.id}` }, (refI == 0) ? section.title : `(${refI + 1})` ), " ", ] ), ), ), ), ); } function genAllDfnPanels() { for(const panelData of Object.values(window.dfnpanelData)) { const dfnID = panelData.dfnID; const dfn = document.getElementById(dfnID); if(!dfn) { console.log(`Can't find dfn#${dfnID}.`, panelData); } else { const panel = genDfnPanel(panelData); append(document.body, panel); insertDfnPopupAction(dfn, panel) } } } document.addEventListener("DOMContentLoaded", ()=> { genAllDfnPanels(); // Add popup behavior to all dfns to show the corresponding dfn-panel. var dfns = queryAll('.dfn-paneled'); for(let dfn of dfns) { ; } document.body.addEventListener("click", (e) => { // If not handled already, just hide all dfn panels. hideAllDfnPanels(); }); }) function hideAllDfnPanels() { // Turn off any currently "on" or "activated" panels. queryAll(".dfn-panel.on, .dfn-panel.activated").forEach(el=> hideDfnPanel(el)); } function showDfnPanel(dfnPanel, dfn) { hideAllDfnPanels(); // Only display one at this time. dfn.setAttribute("aria-expanded", "true"); dfnPanel.classList.add("on"); dfnPanel.style.left = "5px"; dfnPanel.style.top = "0px"; const panelRect = dfnPanel.getBoundingClientRect(); const panelWidth = panelRect.right - panelRect.left; if (panelRect.right > document.body.scrollWidth) { // Panel's overflowing the screen. // Just drop it below the dfn and flip it rightward instead. // This still wont' fix things if the screen is *really* wide, // but fixing that's a lot harder without 'anchor()'. dfnPanel.style.top = "1.5em"; dfnPanel.style.left = "auto"; dfnPanel.style.right = "0px"; } } function pinDfnPanel(dfnPanel) { // Switch it to "activated" state, which pins it. dfnPanel.classList.add("activated"); dfnPanel.style.left = null; dfnPanel.style.top = null; } function hideDfnPanel(dfnPanel, dfn) { if(!dfn) { dfn = document.getElementById(dfnPanel.getAttribute("data-for")); } dfn.setAttribute("aria-expanded", "false") dfnPanel.classList.remove("on"); dfnPanel.classList.remove("activated"); } function toggleDfnPanel(dfnPanel, dfn) { if(dfnPanel.classList.contains("on")) { hideDfnPanel(dfnPanel, dfn); } else { showDfnPanel(dfnPanel, dfn); } } function insertDfnPopupAction(dfn, dfnPanel) { // Find dfn panel const panelWrapper = document.createElement('span'); panelWrapper.appendChild(dfnPanel); panelWrapper.style.position = "relative"; panelWrapper.style.height = "0px"; dfn.insertAdjacentElement("afterend", panelWrapper); dfn.setAttribute('role', 'button'); dfn.setAttribute('aria-expanded', 'false') dfn.tabIndex = 0; dfn.classList.add('has-dfn-panel'); dfn.addEventListener('click', (event) => { showDfnPanel(dfnPanel, dfn); event.stopPropagation(); }); dfn.addEventListener('keypress', (event) => { const kc = event.keyCode; // 32-> Space, 13-> Enter if(kc == 32 || kc == 13) { toggleDfnPanel(dfnPanel, dfn); event.stopPropagation(); event.preventDefault(); } }); dfnPanel.addEventListener('click', (event) => { if (event.target.nodeName == 'A') { pinDfnPanel(dfnPanel); } event.stopPropagation(); }); dfnPanel.addEventListener('keydown', (event) => { if(event.keyCode == 27) { // Escape key hideDfnPanel(dfnPanel, dfn); event.stopPropagation(); event.preventDefault(); } }) } } /* Boilerplate: script-dfn-panel */ "use strict"; { const dfnsJson = window.dfnsJson || {}; function genDfnPanel({dfnID, url, dfnText, refSections, external}) { return mk.aside({ class: "dfn-panel", id: `infopanel-for-${dfnID}`, "data-for": dfnID, "aria-labelled-by":`infopaneltitle-for-${dfnID}`, }, mk.span({id:`infopaneltitle-for-${dfnID}`, style:"display:none"}, `Info about the '${dfnText}' ${external?"external":""} reference.`), mk.a({href:url}, url), mk.b({}, "Referenced in:"), mk.ul({}, ...refSections.map(section=> mk.li({}, ...section.refs.map((ref, refI)=> [ mk.a({ href: `#${ref.id}` }, (refI == 0) ? section.title : `(${refI + 1})` ), " ", ] ), ), ), ), ); } function genAllDfnPanels() { for(const panelData of Object.values(window.dfnpanelData)) { const dfnID = panelData.dfnID; const dfn = document.getElementById(dfnID); if(!dfn) { console.log(`Can't find dfn#${dfnID}.`, panelData); } else { const panel = genDfnPanel(panelData); append(document.body, panel); insertDfnPopupAction(dfn, panel) } } } document.addEventListener("DOMContentLoaded", ()=> { genAllDfnPanels(); // Add popup behavior to all dfns to show the corresponding dfn-panel. var dfns = queryAll('.dfn-paneled'); for(let dfn of dfns) { ; } document.body.addEventListener("click", (e) => { // If not handled already, just hide all dfn panels. hideAllDfnPanels(); }); }) function hideAllDfnPanels() { // Turn off any currently "on" or "activated" panels. queryAll(".dfn-panel.on, .dfn-panel.activated").forEach(el=> hideDfnPanel(el)); } function showDfnPanel(dfnPanel, dfn) { hideAllDfnPanels(); // Only display one at this time. dfn.setAttribute("aria-expanded", "true"); dfnPanel.classList.add("on"); dfnPanel.style.left = "5px"; dfnPanel.style.top = "0px"; const panelRect = dfnPanel.getBoundingClientRect(); const panelWidth = panelRect.right - panelRect.left; if (panelRect.right > document.body.scrollWidth) { // Panel's overflowing the screen. // Just drop it below the dfn and flip it rightward instead. // This still wont' fix things if the screen is *really* wide, // but fixing that's a lot harder without 'anchor()'. dfnPanel.style.top = "1.5em"; dfnPanel.style.left = "auto"; dfnPanel.style.right = "0px"; } } function pinDfnPanel(dfnPanel) { // Switch it to "activated" state, which pins it. dfnPanel.classList.add("activated"); dfnPanel.style.left = null; dfnPanel.style.top = null; } function hideDfnPanel(dfnPanel, dfn) { if(!dfn) { dfn = document.getElementById(dfnPanel.getAttribute("data-for")); } dfn.setAttribute("aria-expanded", "false") dfnPanel.classList.remove("on"); dfnPanel.classList.remove("activated"); } function toggleDfnPanel(dfnPanel, dfn) { if(dfnPanel.classList.contains("on")) { hideDfnPanel(dfnPanel, dfn); } else { showDfnPanel(dfnPanel, dfn); } } function insertDfnPopupAction(dfn, dfnPanel) { // Find dfn panel const panelWrapper = document.createElement('span'); panelWrapper.appendChild(dfnPanel); panelWrapper.style.position = "relative"; panelWrapper.style.height = "0px"; dfn.insertAdjacentElement("afterend", panelWrapper); dfn.setAttribute('role', 'button'); dfn.setAttribute('aria-expanded', 'false') dfn.tabIndex = 0; dfn.classList.add('has-dfn-panel'); dfn.addEventListener('click', (event) => { showDfnPanel(dfnPanel, dfn); event.stopPropagation(); }); dfn.addEventListener('keypress', (event) => { const kc = event.keyCode; // 32-> Space, 13-> Enter if(kc == 32 || kc == 13) { toggleDfnPanel(dfnPanel, dfn); event.stopPropagation(); event.preventDefault(); } }); dfnPanel.addEventListener('click', (event) => { if (event.target.nodeName == 'A') { pinDfnPanel(dfnPanel); } event.stopPropagation(); }); dfnPanel.addEventListener('keydown', (event) => { if(event.keyCode == 27) { // Escape key hideDfnPanel(dfnPanel, dfn); event.stopPropagation(); event.preventDefault(); } }) } } /* Boilerplate: script-dfn-panel-json */ window.dfnpanelData = {}; window.dfnpanelData['14aa437a'] = {"dfnID": "14aa437a", "url": "https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-native-error-types-used-in-this-standard-typeerror", "dfnText": "TypeError", "refSections": [{"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2460"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2461"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2462"}, {"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2463"}, {"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2464"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2465"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2466"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-sec-native-error-types-used-in-this-standard-typeerror\u2467"}], "title": "2.6.3. The truncate() method"}], "external": true}; window.dfnpanelData['3aec4bbc'] = {"dfnID": "3aec4bbc", "url": "https://tc39.es/ecma262/#current-realm", "dfnText": "current realm", "refSections": [{"refs": [{"id": "ref-for-current-realm"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['32132694'] = {"dfnID": "32132694", "url": "https://tc39.es/ecma262/#realm", "dfnText": "realm", "refSections": [{"refs": [{"id": "ref-for-realm"}, {"id": "ref-for-realm\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-realm\u2461"}, {"id": "ref-for-realm\u2462"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-realm\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-realm\u2464"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['0303e8e5'] = {"dfnID": "0303e8e5", "url": "https://encoding.spec.whatwg.org/#utf-8-encode", "dfnText": "utf-8 encode", "refSections": [{"refs": [{"id": "ref-for-utf-8-encode"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['b7d73f5b'] = {"dfnID": "b7d73f5b", "url": "https://w3c.github.io/FileAPI/#dfn-Blob", "dfnText": "Blob", "refSections": [{"refs": [{"id": "ref-for-dfn-Blob"}, {"id": "ref-for-dfn-Blob\u2460"}, {"id": "ref-for-dfn-Blob\u2461"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['cd028611'] = {"dfnID": "cd028611", "url": "https://w3c.github.io/FileAPI/#dfn-file", "dfnText": "File", "refSections": [{"refs": [{"id": "ref-for-dfn-file"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-dfn-file\u2460"}, {"id": "ref-for-dfn-file\u2461"}, {"id": "ref-for-dfn-file\u2462"}], "title": "2.3.1. The getFile() method"}], "external": true}; window.dfnpanelData['f9970195'] = {"dfnID": "f9970195", "url": "https://w3c.github.io/FileAPI/#dfn-lastModified", "dfnText": "lastModified", "refSections": [{"refs": [{"id": "ref-for-dfn-lastModified"}], "title": "2.3.1. The getFile() method"}], "external": true}; window.dfnpanelData['1441e3bf'] = {"dfnID": "1441e3bf", "url": "https://w3c.github.io/FileAPI/#dfn-name", "dfnText": "name", "refSections": [{"refs": [{"id": "ref-for-dfn-name"}], "title": "2.3.1. The getFile() method"}], "external": true}; window.dfnpanelData['0a192674'] = {"dfnID": "0a192674", "url": "https://w3c.github.io/FileAPI/#readOperation", "dfnText": "read operation", "refSections": [{"refs": [{"id": "ref-for-readOperation"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['c53e5a8e'] = {"dfnID": "c53e5a8e", "url": "https://w3c.github.io/FileAPI/#snapshot-state", "dfnText": "snapshot state", "refSections": [{"refs": [{"id": "ref-for-snapshot-state"}], "title": "2.3.1. The getFile() method"}], "external": true}; window.dfnpanelData['e303c02d'] = {"dfnID": "e303c02d", "url": "https://w3c.github.io/FileAPI/#dfn-type", "dfnText": "type", "refSections": [{"refs": [{"id": "ref-for-dfn-type"}], "title": "2.3.1. The getFile() method"}], "external": true}; window.dfnpanelData['17625652'] = {"dfnID": "17625652", "url": "https://w3c.github.io/FileAPI/#UnixEpoch", "dfnText": "unix epoch", "refSections": [{"refs": [{"id": "ref-for-UnixEpoch"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['eb5c4be3'] = {"dfnID": "eb5c4be3", "url": "https://html.spec.whatwg.org/multipage/structured-data.html#serializable", "dfnText": "Serializable", "refSections": [{"refs": [{"id": "ref-for-serializable"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-serializable\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-serializable\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['12b8dfc0'] = {"dfnID": "12b8dfc0", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#current-settings-object", "dfnText": "current settings object", "refSections": [{"refs": [{"id": "ref-for-current-settings-object"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['888d7c65'] = {"dfnID": "888d7c65", "url": "https://html.spec.whatwg.org/multipage/structured-data.html#deserialization-steps", "dfnText": "deserialization steps", "refSections": [{"refs": [{"id": "ref-for-deserialization-steps"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-deserialization-steps\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-deserialization-steps\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['e4d92278'] = {"dfnID": "e4d92278", "url": "https://html.spec.whatwg.org/multipage/infrastructure.html#enqueue-the-following-steps", "dfnText": "enqueue steps", "refSections": [{"refs": [{"id": "ref-for-enqueue-the-following-steps"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2460"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2464"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2467"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2468"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u24ea"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u2460"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u2461"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2460\u2462"}], "title": "2.6.6. The close() method"}], "external": true}; window.dfnpanelData['102df61f'] = {"dfnID": "102df61f", "url": "https://html.spec.whatwg.org/multipage/infrastructure.html#enqueue-the-following-steps", "dfnText": "enqueue the following steps", "refSections": [{"refs": [{"id": "ref-for-enqueue-the-following-steps"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2460"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2464"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2467"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2468"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u24ea"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u2460"}, {"id": "ref-for-enqueue-the-following-steps\u2460\u2461"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-enqueue-the-following-steps\u2460\u2462"}], "title": "2.6.6. The close() method"}], "external": true}; window.dfnpanelData['a72449dd'] = {"dfnID": "a72449dd", "url": "https://html.spec.whatwg.org/multipage/infrastructure.html#in-parallel", "dfnText": "in parallel", "refSections": [{"refs": [{"id": "ref-for-in-parallel"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['43ac8374'] = {"dfnID": "43ac8374", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#concept-settings-object-origin", "dfnText": "origin", "refSections": [{"refs": [{"id": "ref-for-concept-settings-object-origin"}, {"id": "ref-for-concept-settings-object-origin\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['64301ea1'] = {"dfnID": "64301ea1", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#pause", "dfnText": "pause", "refSections": [{"refs": [{"id": "ref-for-pause"}], "title": "2.6.6. The close() method"}], "external": true}; window.dfnpanelData['e99bd18e'] = {"dfnID": "e99bd18e", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#concept-relevant-global", "dfnText": "relevant global object", "refSections": [{"refs": [{"id": "ref-for-concept-relevant-global"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2460"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2462"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2463"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2464"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2465"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-concept-relevant-global\u2466"}, {"id": "ref-for-concept-relevant-global\u2467"}, {"id": "ref-for-concept-relevant-global\u2468"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['5991ccfb'] = {"dfnID": "5991ccfb", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#concept-relevant-realm", "dfnText": "relevant realm", "refSections": [{"refs": [{"id": "ref-for-concept-relevant-realm"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-concept-relevant-realm\u2460"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-concept-relevant-realm\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-concept-relevant-realm\u2462"}, {"id": "ref-for-concept-relevant-realm\u2463"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-concept-relevant-realm\u2464"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-concept-relevant-realm\u2465"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": true}; window.dfnpanelData['9c4c1e66'] = {"dfnID": "9c4c1e66", "url": "https://html.spec.whatwg.org/multipage/webappapis.html#relevant-settings-object", "dfnText": "relevant settings object", "refSections": [{"refs": [{"id": "ref-for-relevant-settings-object"}, {"id": "ref-for-relevant-settings-object\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['7393da89'] = {"dfnID": "7393da89", "url": "https://html.spec.whatwg.org/multipage/browsers.html#same-origin", "dfnText": "same origin", "refSections": [{"refs": [{"id": "ref-for-same-origin"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['0a422d04'] = {"dfnID": "0a422d04", "url": "https://html.spec.whatwg.org/multipage/structured-data.html#serializable-objects", "dfnText": "serializable object", "refSections": [{"refs": [{"id": "ref-for-serializable-objects"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-serializable-objects\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-serializable-objects\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['f32dc6c1'] = {"dfnID": "f32dc6c1", "url": "https://html.spec.whatwg.org/multipage/structured-data.html#serialization-steps", "dfnText": "serialization steps", "refSections": [{"refs": [{"id": "ref-for-serialization-steps"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-serialization-steps\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-serialization-steps\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['8219d486'] = {"dfnID": "8219d486", "url": "https://html.spec.whatwg.org/multipage/infrastructure.html#starting-a-new-parallel-queue", "dfnText": "starting a new parallel queue", "refSections": [{"refs": [{"id": "ref-for-starting-a-new-parallel-queue"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['53275e46'] = {"dfnID": "53275e46", "url": "https://infra.spec.whatwg.org/#list-append", "dfnText": "append (for list)", "refSections": [{"refs": [{"id": "ref-for-list-append"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-list-append\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-list-append\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['a3b18719'] = {"dfnID": "a3b18719", "url": "https://infra.spec.whatwg.org/#set-append", "dfnText": "append (for set)", "refSections": [{"refs": [{"id": "ref-for-set-append"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-set-append\u2460"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-set-append\u2461"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": true}; window.dfnpanelData['77b4c09a'] = {"dfnID": "77b4c09a", "url": "https://infra.spec.whatwg.org/#assert", "dfnText": "assert", "refSections": [{"refs": [{"id": "ref-for-assert"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-assert\u2460"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-assert\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-assert\u2462"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-assert\u2463"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-assert\u2464"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-assert\u2465"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-assert\u2466"}, {"id": "ref-for-assert\u2467"}, {"id": "ref-for-assert\u2468"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['3de9e659'] = {"dfnID": "3de9e659", "url": "https://infra.spec.whatwg.org/#byte-sequence", "dfnText": "byte sequence", "refSections": [{"refs": [{"id": "ref-for-byte-sequence"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-byte-sequence\u2460"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-byte-sequence\u2461"}, {"id": "ref-for-byte-sequence\u2462"}, {"id": "ref-for-byte-sequence\u2463"}, {"id": "ref-for-byte-sequence\u2464"}, {"id": "ref-for-byte-sequence\u2465"}, {"id": "ref-for-byte-sequence\u2466"}, {"id": "ref-for-byte-sequence\u2467"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-byte-sequence\u2468"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-byte-sequence\u2460\u24ea"}, {"id": "ref-for-byte-sequence\u2460\u2460"}, {"id": "ref-for-byte-sequence\u2460\u2461"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-byte-sequence\u2460\u2462"}, {"id": "ref-for-byte-sequence\u2460\u2463"}, {"id": "ref-for-byte-sequence\u2460\u2464"}], "title": "2.6.3. The truncate() method"}], "external": true}; window.dfnpanelData['027e3e49'] = {"dfnID": "027e3e49", "url": "https://infra.spec.whatwg.org/#list-clone", "dfnText": "clone", "refSections": [{"refs": [{"id": "ref-for-list-clone"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-list-clone\u2460"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['ae8def21'] = {"dfnID": "ae8def21", "url": "https://infra.spec.whatwg.org/#list-contain", "dfnText": "contain", "refSections": [{"refs": [{"id": "ref-for-list-contain"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-list-contain\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['1243a891'] = {"dfnID": "1243a891", "url": "https://infra.spec.whatwg.org/#map-exists", "dfnText": "exist", "refSections": [{"refs": [{"id": "ref-for-map-exists"}, {"id": "ref-for-map-exists\u2460"}, {"id": "ref-for-map-exists\u2461"}, {"id": "ref-for-map-exists\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-map-exists\u2463"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-map-exists\u2464"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-map-exists\u2465"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['16d07e10'] = {"dfnID": "16d07e10", "url": "https://infra.spec.whatwg.org/#list-iterate", "dfnText": "for each", "refSections": [{"refs": [{"id": "ref-for-list-iterate"}, {"id": "ref-for-list-iterate\u2460"}, {"id": "ref-for-list-iterate\u2461"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-list-iterate\u2462"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-list-iterate\u2463"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-list-iterate\u2464"}], "title": "2.4.4. The removeEntry() method"}], "external": true}; window.dfnpanelData['860300d4'] = {"dfnID": "860300d4", "url": "https://infra.spec.whatwg.org/#implementation-defined", "dfnText": "implementation-defined", "refSections": [{"refs": [{"id": "ref-for-implementation-defined"}, {"id": "ref-for-implementation-defined\u2460"}, {"id": "ref-for-implementation-defined\u2461"}, {"id": "ref-for-implementation-defined\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-implementation-defined\u2463"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-implementation-defined\u2464"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-implementation-defined\u2465"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['fb8f82b0'] = {"dfnID": "fb8f82b0", "url": "https://infra.spec.whatwg.org/#list-get-the-indices", "dfnText": "indices", "refSections": [{"refs": [{"id": "ref-for-list-get-the-indices"}, {"id": "ref-for-list-get-the-indices\u2460"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['6b815fdd'] = {"dfnID": "6b815fdd", "url": "https://infra.spec.whatwg.org/#list-is-empty", "dfnText": "is empty", "refSections": [{"refs": [{"id": "ref-for-list-is-empty"}], "title": "2.4.4. The removeEntry() method"}], "external": true}; window.dfnpanelData['5afbefcd'] = {"dfnID": "5afbefcd", "url": "https://infra.spec.whatwg.org/#list-item", "dfnText": "item (for list)", "refSections": [{"refs": [{"id": "ref-for-list-item"}, {"id": "ref-for-list-item\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-list-item\u2461"}, {"id": "ref-for-list-item\u2462"}, {"id": "ref-for-list-item\u2463"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['c88f3887'] = {"dfnID": "c88f3887", "url": "https://infra.spec.whatwg.org/#struct-item", "dfnText": "item (for struct)", "refSections": [{"refs": [{"id": "ref-for-struct-item"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['36333997'] = {"dfnID": "36333997", "url": "https://infra.spec.whatwg.org/#byte-sequence-length", "dfnText": "length", "refSections": [{"refs": [{"id": "ref-for-byte-sequence-length"}, {"id": "ref-for-byte-sequence-length\u2460"}, {"id": "ref-for-byte-sequence-length\u2461"}, {"id": "ref-for-byte-sequence-length\u2462"}, {"id": "ref-for-byte-sequence-length\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-byte-sequence-length\u2464"}, {"id": "ref-for-byte-sequence-length\u2465"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-byte-sequence-length\u2466"}, {"id": "ref-for-byte-sequence-length\u2467"}, {"id": "ref-for-byte-sequence-length\u2468"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-byte-sequence-length\u2460\u24ea"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-byte-sequence-length\u2460\u2460"}], "title": "2.6.4. The getSize() method"}], "external": true}; window.dfnpanelData['649608b9'] = {"dfnID": "649608b9", "url": "https://infra.spec.whatwg.org/#list", "dfnText": "list", "refSections": [{"refs": [{"id": "ref-for-list"}, {"id": "ref-for-list\u2460"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['99c988d6'] = {"dfnID": "99c988d6", "url": "https://infra.spec.whatwg.org/#list-remove", "dfnText": "remove", "refSections": [{"refs": [{"id": "ref-for-list-remove"}], "title": "2.4.4. The removeEntry() method"}], "external": true}; window.dfnpanelData['15e48c39'] = {"dfnID": "15e48c39", "url": "https://infra.spec.whatwg.org/#ordered-set", "dfnText": "set", "refSections": [{"refs": [{"id": "ref-for-ordered-set"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-ordered-set\u2460"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-ordered-set\u2461"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-ordered-set\u2462"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['0204d188'] = {"dfnID": "0204d188", "url": "https://infra.spec.whatwg.org/#list-size", "dfnText": "size", "refSections": [{"refs": [{"id": "ref-for-list-size"}, {"id": "ref-for-list-size\u2460"}, {"id": "ref-for-list-size\u2461"}, {"id": "ref-for-list-size\u2462"}, {"id": "ref-for-list-size\u2463"}, {"id": "ref-for-list-size\u2464"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['0698d556'] = {"dfnID": "0698d556", "url": "https://infra.spec.whatwg.org/#string", "dfnText": "string", "refSections": [{"refs": [{"id": "ref-for-string"}, {"id": "ref-for-string\u2460"}, {"id": "ref-for-string\u2461"}, {"id": "ref-for-string\u2462"}, {"id": "ref-for-string\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-string\u2464"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-string\u2465"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['984221ca'] = {"dfnID": "984221ca", "url": "https://infra.spec.whatwg.org/#struct", "dfnText": "struct", "refSections": [{"refs": [{"id": "ref-for-struct"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['febebe0e'] = {"dfnID": "febebe0e", "url": "https://infra.spec.whatwg.org/#the-range", "dfnText": "the range", "refSections": [{"refs": [{"id": "ref-for-the-range"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['6c3bee60'] = {"dfnID": "6c3bee60", "url": "https://w3c.github.io/permissions/#dom-permissionstate", "dfnText": "PermissionState", "refSections": [{"refs": [{"id": "ref-for-dom-permissionstate"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['2cb28cb0'] = {"dfnID": "2cb28cb0", "url": "https://w3c.github.io/permissions/#dom-permissionstate-denied", "dfnText": "denied", "refSections": [{"refs": [{"id": "ref-for-dom-permissionstate-denied"}, {"id": "ref-for-dom-permissionstate-denied\u2460"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['c6ce3c60'] = {"dfnID": "c6ce3c60", "url": "https://w3c.github.io/permissions/#dom-permissionstate-granted", "dfnText": "granted", "refSections": [{"refs": [{"id": "ref-for-dom-permissionstate-granted"}, {"id": "ref-for-dom-permissionstate-granted\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2464"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2467"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2468"}, {"id": "ref-for-dom-permissionstate-granted\u2460\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-permissionstate-granted\u2460\u2460"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['6c2d7879'] = {"dfnID": "6c2d7879", "url": "https://w3c.github.io/permissions/#dfn-powerful-feature", "dfnText": "powerful feature", "refSections": [{"refs": [{"id": "ref-for-dfn-powerful-feature"}, {"id": "ref-for-dfn-powerful-feature\u2460"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['35725f70'] = {"dfnID": "35725f70", "url": "https://wicg.github.io/permissions-request/#permission-request-algorithm", "dfnText": "permission request algorithm", "refSections": [{"refs": [{"id": "ref-for-permission-request-algorithm"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['8649548f'] = {"dfnID": "8649548f", "url": "https://storage.spec.whatwg.org/#storagemanager", "dfnText": "StorageManager", "refSections": [{"refs": [{"id": "ref-for-storagemanager"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['7140f092'] = {"dfnID": "7140f092", "url": "https://storage.spec.whatwg.org/#storage-endpoint-identifier", "dfnText": "identifier", "refSections": [{"refs": [{"id": "ref-for-storage-endpoint-identifier"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['6bb9d790'] = {"dfnID": "6bb9d790", "url": "https://storage.spec.whatwg.org/#obtain-a-local-storage-bottle-map", "dfnText": "obtain a local storage bottle map", "refSections": [{"refs": [{"id": "ref-for-obtain-a-local-storage-bottle-map"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['d7bc2287'] = {"dfnID": "d7bc2287", "url": "https://storage.spec.whatwg.org/#queue-a-storage-task", "dfnText": "queue a storage task", "refSections": [{"refs": [{"id": "ref-for-queue-a-storage-task"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2460"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2461"}, {"id": "ref-for-queue-a-storage-task\u2462"}, {"id": "ref-for-queue-a-storage-task\u2463"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2464"}, {"id": "ref-for-queue-a-storage-task\u2465"}, {"id": "ref-for-queue-a-storage-task\u2466"}, {"id": "ref-for-queue-a-storage-task\u2467"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2468"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2460\u24ea"}, {"id": "ref-for-queue-a-storage-task\u2460\u2460"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2460\u2461"}, {"id": "ref-for-queue-a-storage-task\u2460\u2462"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2460\u2463"}, {"id": "ref-for-queue-a-storage-task\u2460\u2464"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-queue-a-storage-task\u2460\u2465"}, {"id": "ref-for-queue-a-storage-task\u2460\u2466"}, {"id": "ref-for-queue-a-storage-task\u2460\u2467"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['896f4663'] = {"dfnID": "896f4663", "url": "https://storage.spec.whatwg.org/#storage-endpoint-quota", "dfnText": "quota", "refSections": [{"refs": [{"id": "ref-for-storage-endpoint-quota"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['6148dd37'] = {"dfnID": "6148dd37", "url": "https://storage.spec.whatwg.org/#storage-bucket", "dfnText": "storage bucket", "refSections": [{"refs": [{"id": "ref-for-storage-bucket"}, {"id": "ref-for-storage-bucket\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-storage-bucket\u2461"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-storage-bucket\u2462"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['98c6a112'] = {"dfnID": "98c6a112", "url": "https://storage.spec.whatwg.org/#storage-endpoint", "dfnText": "storage endpoint", "refSections": [{"refs": [{"id": "ref-for-storage-endpoint"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['cac8dd86'] = {"dfnID": "cac8dd86", "url": "https://storage.spec.whatwg.org/#storage-quota", "dfnText": "storage quota", "refSections": [{"refs": [{"id": "ref-for-storage-quota"}, {"id": "ref-for-storage-quota\u2460"}, {"id": "ref-for-storage-quota\u2461"}, {"id": "ref-for-storage-quota\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-storage-quota\u2463"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-storage-quota\u2464"}], "title": "2.6.3. The truncate() method"}], "external": true}; window.dfnpanelData['d9de012d'] = {"dfnID": "d9de012d", "url": "https://storage.spec.whatwg.org/#storage-endpoint-types", "dfnText": "types", "refSections": [{"refs": [{"id": "ref-for-storage-endpoint-types"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['59ed4e57'] = {"dfnID": "59ed4e57", "url": "https://streams.spec.whatwg.org/#readablestream", "dfnText": "ReadableStream", "refSections": [{"refs": [{"id": "ref-for-readablestream"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['59dc45b5'] = {"dfnID": "59dc45b5", "url": "https://streams.spec.whatwg.org/#writablestream", "dfnText": "WritableStream", "refSections": [{"refs": [{"id": "ref-for-writablestream"}, {"id": "ref-for-writablestream\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['4f848e3e'] = {"dfnID": "4f848e3e", "url": "https://streams.spec.whatwg.org/#writablestreamdefaultwriter", "dfnText": "WritableStreamDefaultWriter", "refSections": [{"refs": [{"id": "ref-for-writablestreamdefaultwriter"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['22429d52'] = {"dfnID": "22429d52", "url": "https://streams.spec.whatwg.org/#writablestream-set-up-abortalgorithm", "dfnText": "abortalgorithm", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up-abortalgorithm"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['04dc6c33'] = {"dfnID": "04dc6c33", "url": "https://streams.spec.whatwg.org/#writablestream-set-up-closealgorithm", "dfnText": "closealgorithm", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up-closealgorithm"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['2231a61a'] = {"dfnID": "2231a61a", "url": "https://streams.spec.whatwg.org/#ws-get-writer", "dfnText": "getWriter()", "refSections": [{"refs": [{"id": "ref-for-ws-get-writer"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['f4acb816'] = {"dfnID": "f4acb816", "url": "https://streams.spec.whatwg.org/#writablestream-get-a-writer", "dfnText": "getting a writer", "refSections": [{"refs": [{"id": "ref-for-writablestream-get-a-writer"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-writablestream-get-a-writer\u2460"}], "title": "2.5.2. The seek() method"}, {"refs": [{"id": "ref-for-writablestream-get-a-writer\u2461"}], "title": "2.5.3. The truncate() method"}], "external": true}; window.dfnpanelData['5958fe2e'] = {"dfnID": "5958fe2e", "url": "https://streams.spec.whatwg.org/#writablestream-set-up-highwatermark", "dfnText": "highwatermark", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up-highwatermark"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['a307241e'] = {"dfnID": "a307241e", "url": "https://streams.spec.whatwg.org/#writablestreamdefaultwriter-release", "dfnText": "release", "refSections": [{"refs": [{"id": "ref-for-writablestreamdefaultwriter-release"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-writablestreamdefaultwriter-release\u2460"}], "title": "2.5.2. The seek() method"}, {"refs": [{"id": "ref-for-writablestreamdefaultwriter-release\u2461"}], "title": "2.5.3. The truncate() method"}], "external": true}; window.dfnpanelData['3dc81766'] = {"dfnID": "3dc81766", "url": "https://streams.spec.whatwg.org/#writablestream-set-up", "dfnText": "set up", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['5d7f2906'] = {"dfnID": "5d7f2906", "url": "https://streams.spec.whatwg.org/#writablestream-set-up-sizealgorithm", "dfnText": "sizealgorithm", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up-sizealgorithm"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['68d8cab8'] = {"dfnID": "68d8cab8", "url": "https://streams.spec.whatwg.org/#default-writer-write", "dfnText": "write()", "refSections": [{"refs": [{"id": "ref-for-default-writer-write"}, {"id": "ref-for-default-writer-write\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['d04a8309'] = {"dfnID": "d04a8309", "url": "https://streams.spec.whatwg.org/#writablestream-set-up-writealgorithm", "dfnText": "writealgorithm", "refSections": [{"refs": [{"id": "ref-for-writablestream-set-up-writealgorithm"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['1ee4bec2'] = {"dfnID": "1ee4bec2", "url": "https://streams.spec.whatwg.org/#writablestreamdefaultwriter-write-a-chunk", "dfnText": "writing a chunk", "refSections": [{"refs": [{"id": "ref-for-writablestreamdefaultwriter-write-a-chunk"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-writablestreamdefaultwriter-write-a-chunk\u2460"}], "title": "2.5.2. The seek() method"}, {"refs": [{"id": "ref-for-writablestreamdefaultwriter-write-a-chunk\u2461"}], "title": "2.5.3. The truncate() method"}], "external": true}; window.dfnpanelData['d25dfb2c'] = {"dfnID": "d25dfb2c", "url": "https://webidl.spec.whatwg.org/#aborterror", "dfnText": "AbortError", "refSections": [{"refs": [{"id": "ref-for-aborterror"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['5e4b6157'] = {"dfnID": "5e4b6157", "url": "https://webidl.spec.whatwg.org/#AllowSharedBufferSource", "dfnText": "AllowSharedBufferSource", "refSections": [{"refs": [{"id": "ref-for-AllowSharedBufferSource"}, {"id": "ref-for-AllowSharedBufferSource\u2460"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['3aff2fb3'] = {"dfnID": "3aff2fb3", "url": "https://webidl.spec.whatwg.org/#BufferSource", "dfnText": "BufferSource", "refSections": [{"refs": [{"id": "ref-for-BufferSource"}, {"id": "ref-for-BufferSource\u2460"}, {"id": "ref-for-BufferSource\u2461"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['dca2de17'] = {"dfnID": "dca2de17", "url": "https://webidl.spec.whatwg.org/#idl-DOMException", "dfnText": "DOMException", "refSections": [{"refs": [{"id": "ref-for-idl-DOMException"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-idl-DOMException\u2460"}, {"id": "ref-for-idl-DOMException\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462"}, {"id": "ref-for-idl-DOMException\u2463"}, {"id": "ref-for-idl-DOMException\u2464"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2465"}, {"id": "ref-for-idl-DOMException\u2466"}, {"id": "ref-for-idl-DOMException\u2467"}, {"id": "ref-for-idl-DOMException\u2468"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2460\u24ea"}, {"id": "ref-for-idl-DOMException\u2460\u2460"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-idl-DOMException\u2460\u2461"}, {"id": "ref-for-idl-DOMException\u2460\u2462"}, {"id": "ref-for-idl-DOMException\u2460\u2463"}, {"id": "ref-for-idl-DOMException\u2460\u2464"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2460\u2465"}, {"id": "ref-for-idl-DOMException\u2460\u2466"}, {"id": "ref-for-idl-DOMException\u2460\u2467"}, {"id": "ref-for-idl-DOMException\u2460\u2468"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2461\u24ea"}, {"id": "ref-for-idl-DOMException\u2461\u2460"}, {"id": "ref-for-idl-DOMException\u2461\u2461"}, {"id": "ref-for-idl-DOMException\u2461\u2462"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2461\u2463"}, {"id": "ref-for-idl-DOMException\u2461\u2464"}, {"id": "ref-for-idl-DOMException\u2461\u2465"}, {"id": "ref-for-idl-DOMException\u2461\u2466"}, {"id": "ref-for-idl-DOMException\u2461\u2467"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-idl-DOMException\u2461\u2468"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462\u24ea"}, {"id": "ref-for-idl-DOMException\u2462\u2460"}, {"id": "ref-for-idl-DOMException\u2462\u2461"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462\u2462"}, {"id": "ref-for-idl-DOMException\u2462\u2463"}, {"id": "ref-for-idl-DOMException\u2462\u2464"}, {"id": "ref-for-idl-DOMException\u2462\u2465"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462\u2466"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462\u2467"}], "title": "2.6.5. The flush() method"}, {"refs": [{"id": "ref-for-idl-DOMException\u2462\u2468"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['d54f5897'] = {"dfnID": "d54f5897", "url": "https://webidl.spec.whatwg.org/#datacloneerror", "dfnText": "DataCloneError", "refSections": [{"refs": [{"id": "ref-for-datacloneerror"}], "title": "2.2. The FileSystemHandle interface"}], "external": true}; window.dfnpanelData['c01cbda0'] = {"dfnID": "c01cbda0", "url": "https://webidl.spec.whatwg.org/#EnforceRange", "dfnText": "EnforceRange", "refSections": [{"refs": [{"id": "ref-for-EnforceRange"}, {"id": "ref-for-EnforceRange\u2460"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['889e932f'] = {"dfnID": "889e932f", "url": "https://webidl.spec.whatwg.org/#Exposed", "dfnText": "Exposed", "refSections": [{"refs": [{"id": "ref-for-Exposed"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-Exposed\u2460"}, {"id": "ref-for-Exposed\u2461"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-Exposed\u2462"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-Exposed\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-Exposed\u2464"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['cae6bf57'] = {"dfnID": "cae6bf57", "url": "https://webidl.spec.whatwg.org/#invalidmodificationerror", "dfnText": "InvalidModificationError", "refSections": [{"refs": [{"id": "ref-for-invalidmodificationerror"}], "title": "2.4.4. The removeEntry() method"}], "external": true}; window.dfnpanelData['797018a7'] = {"dfnID": "797018a7", "url": "https://webidl.spec.whatwg.org/#invalidstateerror", "dfnText": "InvalidStateError", "refSections": [{"refs": [{"id": "ref-for-invalidstateerror"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-invalidstateerror\u2460"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-invalidstateerror\u2461"}, {"id": "ref-for-invalidstateerror\u2462"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-invalidstateerror\u2463"}, {"id": "ref-for-invalidstateerror\u2464"}, {"id": "ref-for-invalidstateerror\u2465"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-invalidstateerror\u2466"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-invalidstateerror\u2467"}], "title": "2.6.5. The flush() method"}], "external": true}; window.dfnpanelData['45999d1c'] = {"dfnID": "45999d1c", "url": "https://webidl.spec.whatwg.org/#nomodificationallowederror", "dfnText": "NoModificationAllowedError", "refSections": [{"refs": [{"id": "ref-for-nomodificationallowederror"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-nomodificationallowederror\u2460"}], "title": "2.3.3. The createSyncAccessHandle() method"}], "external": true}; window.dfnpanelData['ba556545'] = {"dfnID": "ba556545", "url": "https://webidl.spec.whatwg.org/#notallowederror", "dfnText": "NotAllowedError", "refSections": [{"refs": [{"id": "ref-for-notallowederror"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['9eda9b58'] = {"dfnID": "9eda9b58", "url": "https://webidl.spec.whatwg.org/#notfounderror", "dfnText": "NotFoundError", "refSections": [{"refs": [{"id": "ref-for-notfounderror"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-notfounderror\u2460"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-notfounderror\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-notfounderror\u2462"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-notfounderror\u2463"}, {"id": "ref-for-notfounderror\u2464"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-notfounderror\u2465"}, {"id": "ref-for-notfounderror\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-notfounderror\u2467"}, {"id": "ref-for-notfounderror\u2468"}], "title": "2.4.4. The removeEntry() method"}], "external": true}; window.dfnpanelData['bdbd19d1'] = {"dfnID": "bdbd19d1", "url": "https://webidl.spec.whatwg.org/#idl-promise", "dfnText": "Promise", "refSections": [{"refs": [{"id": "ref-for-idl-promise"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-idl-promise\u2460"}, {"id": "ref-for-idl-promise\u2461"}, {"id": "ref-for-idl-promise\u2462"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-idl-promise\u2463"}, {"id": "ref-for-idl-promise\u2464"}, {"id": "ref-for-idl-promise\u2465"}, {"id": "ref-for-idl-promise\u2466"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-idl-promise\u2467"}, {"id": "ref-for-idl-promise\u2468"}, {"id": "ref-for-idl-promise\u2460\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-idl-promise\u2460\u2460"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['5e129c74'] = {"dfnID": "5e129c74", "url": "https://webidl.spec.whatwg.org/#quotaexceedederror", "dfnText": "QuotaExceededError", "refSections": [{"refs": [{"id": "ref-for-quotaexceedederror"}, {"id": "ref-for-quotaexceedederror\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-quotaexceedederror\u2461"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-quotaexceedederror\u2462"}], "title": "2.6.3. The truncate() method"}], "external": true}; window.dfnpanelData['b75bb3bd'] = {"dfnID": "b75bb3bd", "url": "https://webidl.spec.whatwg.org/#SecureContext", "dfnText": "SecureContext", "refSections": [{"refs": [{"id": "ref-for-SecureContext"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-SecureContext\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-SecureContext\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-SecureContext\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-SecureContext\u2463"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-SecureContext\u2464"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['c3e881ef'] = {"dfnID": "c3e881ef", "url": "https://webidl.spec.whatwg.org/#securityerror", "dfnText": "SecurityError", "refSections": [{"refs": [{"id": "ref-for-securityerror"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['5d1a2ad0'] = {"dfnID": "5d1a2ad0", "url": "https://webidl.spec.whatwg.org/#typemismatcherror", "dfnText": "TypeMismatchError", "refSections": [{"refs": [{"id": "ref-for-typemismatcherror"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-typemismatcherror\u2460"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": true}; window.dfnpanelData['b0d7f3c3'] = {"dfnID": "b0d7f3c3", "url": "https://webidl.spec.whatwg.org/#idl-USVString", "dfnText": "USVString", "refSections": [{"refs": [{"id": "ref-for-idl-USVString"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-idl-USVString\u2460"}, {"id": "ref-for-idl-USVString\u2461"}, {"id": "ref-for-idl-USVString\u2462"}, {"id": "ref-for-idl-USVString\u2463"}, {"id": "ref-for-idl-USVString\u2464"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-idl-USVString\u2465"}, {"id": "ref-for-idl-USVString\u2466"}, {"id": "ref-for-idl-USVString\u2467"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['dacde8b5'] = {"dfnID": "dacde8b5", "url": "https://webidl.spec.whatwg.org/#a-new-promise", "dfnText": "a new promise", "refSections": [{"refs": [{"id": "ref-for-a-new-promise"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-a-new-promise\u2460"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2464"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-a-new-promise\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2467"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-a-new-promise\u2468"}, {"id": "ref-for-a-new-promise\u2460\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['d0b4a948'] = {"dfnID": "d0b4a948", "url": "https://webidl.spec.whatwg.org/#a-promise-rejected-with", "dfnText": "a promise rejected with", "refSections": [{"refs": [{"id": "ref-for-a-promise-rejected-with"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-a-promise-rejected-with\u2460"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['8f5c2179'] = {"dfnID": "8f5c2179", "url": "https://webidl.spec.whatwg.org/#a-promise-resolved-with", "dfnText": "a promise resolved with", "refSections": [{"refs": [{"id": "ref-for-a-promise-resolved-with"}], "title": "3. Accessing the Bucket File System"}], "external": true}; window.dfnpanelData['9a7f3f6f'] = {"dfnID": "9a7f3f6f", "url": "https://webidl.spec.whatwg.org/#asynchronous-iterator-initialization-steps", "dfnText": "asynchronous iterator initialization steps", "refSections": [{"refs": [{"id": "ref-for-asynchronous-iterator-initialization-steps"}], "title": "2.4.1. Directory iteration"}], "external": true}; window.dfnpanelData['5372cca8'] = {"dfnID": "5372cca8", "url": "https://webidl.spec.whatwg.org/#idl-boolean", "dfnText": "boolean", "refSections": [{"refs": [{"id": "ref-for-idl-boolean"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-idl-boolean\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-idl-boolean\u2461"}, {"id": "ref-for-idl-boolean\u2462"}, {"id": "ref-for-idl-boolean\u2463"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['495737df'] = {"dfnID": "495737df", "url": "https://webidl.spec.whatwg.org/#buffersource-byte-length", "dfnText": "byte length", "refSections": [{"refs": [{"id": "ref-for-buffersource-byte-length"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-buffersource-byte-length\u2460"}], "title": "2.6.2. The write() method"}], "external": true}; window.dfnpanelData['cadf5fe9'] = {"dfnID": "cadf5fe9", "url": "https://webidl.spec.whatwg.org/#dfn-convert-ecmascript-to-idl-value", "dfnText": "converted to an idl value", "refSections": [{"refs": [{"id": "ref-for-dfn-convert-ecmascript-to-idl-value"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['bec98d30'] = {"dfnID": "bec98d30", "url": "https://webidl.spec.whatwg.org/#dfn-dictionary", "dfnText": "dictionary", "refSections": [{"refs": [{"id": "ref-for-dfn-dictionary"}, {"id": "ref-for-dfn-dictionary\u2460"}, {"id": "ref-for-dfn-dictionary\u2461"}, {"id": "ref-for-dfn-dictionary\u2462"}, {"id": "ref-for-dfn-dictionary\u2463"}, {"id": "ref-for-dfn-dictionary\u2464"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['df71f478'] = {"dfnID": "df71f478", "url": "https://webidl.spec.whatwg.org/#dfn-error-names-table", "dfnText": "domexception names table", "refSections": [{"refs": [{"id": "ref-for-dfn-error-names-table"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['92d13070'] = {"dfnID": "92d13070", "url": "https://webidl.spec.whatwg.org/#dfn-get-buffer-source-copy", "dfnText": "get a copy of the buffer source", "refSections": [{"refs": [{"id": "ref-for-dfn-get-buffer-source-copy"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['e7652812'] = {"dfnID": "e7652812", "url": "https://webidl.spec.whatwg.org/#dfn-get-the-next-iteration-result", "dfnText": "get the next iteration result", "refSections": [{"refs": [{"id": "ref-for-dfn-get-the-next-iteration-result"}], "title": "2.4.1. Directory iteration"}], "external": true}; window.dfnpanelData['44959ae4'] = {"dfnID": "44959ae4", "url": "https://webidl.spec.whatwg.org/#domexception-name", "dfnText": "name", "refSections": [{"refs": [{"id": "ref-for-domexception-name"}], "title": "2.1. Concepts"}], "external": true}; window.dfnpanelData['56f81a8e'] = {"dfnID": "56f81a8e", "url": "https://webidl.spec.whatwg.org/#new", "dfnText": "new", "refSections": [{"refs": [{"id": "ref-for-new"}, {"id": "ref-for-new\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-new\u2461"}, {"id": "ref-for-new\u2462"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-new\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-new\u2464"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['b262501e'] = {"dfnID": "b262501e", "url": "https://webidl.spec.whatwg.org/#reject", "dfnText": "reject", "refSections": [{"refs": [{"id": "ref-for-reject"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-reject\u2460"}, {"id": "ref-for-reject\u2461"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-reject\u2462"}, {"id": "ref-for-reject\u2463"}, {"id": "ref-for-reject\u2464"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-reject\u2465"}, {"id": "ref-for-reject\u2466"}, {"id": "ref-for-reject\u2467"}, {"id": "ref-for-reject\u2468"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-reject\u2460\u24ea"}, {"id": "ref-for-reject\u2460\u2460"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-reject\u2460\u2461"}, {"id": "ref-for-reject\u2460\u2462"}, {"id": "ref-for-reject\u2460\u2463"}, {"id": "ref-for-reject\u2460\u2464"}, {"id": "ref-for-reject\u2460\u2465"}, {"id": "ref-for-reject\u2460\u2466"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-reject\u2460\u2467"}, {"id": "ref-for-reject\u2460\u2468"}, {"id": "ref-for-reject\u2461\u24ea"}, {"id": "ref-for-reject\u2461\u2460"}, {"id": "ref-for-reject\u2461\u2461"}, {"id": "ref-for-reject\u2461\u2462"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-reject\u2461\u2463"}, {"id": "ref-for-reject\u2461\u2464"}, {"id": "ref-for-reject\u2461\u2465"}, {"id": "ref-for-reject\u2461\u2466"}, {"id": "ref-for-reject\u2461\u2467"}, {"id": "ref-for-reject\u2461\u2468"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-reject\u2462\u24ea"}, {"id": "ref-for-reject\u2462\u2460"}, {"id": "ref-for-reject\u2462\u2461"}, {"id": "ref-for-reject\u2462\u2462"}, {"id": "ref-for-reject\u2462\u2463"}, {"id": "ref-for-reject\u2462\u2464"}, {"id": "ref-for-reject\u2462\u2465"}, {"id": "ref-for-reject\u2462\u2466"}, {"id": "ref-for-reject\u2462\u2467"}, {"id": "ref-for-reject\u2462\u2468"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['3b90bdcd'] = {"dfnID": "3b90bdcd", "url": "https://webidl.spec.whatwg.org/#resolve", "dfnText": "resolve", "refSections": [{"refs": [{"id": "ref-for-resolve"}, {"id": "ref-for-resolve\u2460"}, {"id": "ref-for-resolve\u2461"}, {"id": "ref-for-resolve\u2462"}, {"id": "ref-for-resolve\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-resolve\u2464"}, {"id": "ref-for-resolve\u2465"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-resolve\u2466"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-resolve\u2467"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-resolve\u2468"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-resolve\u2460\u24ea"}, {"id": "ref-for-resolve\u2460\u2460"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-resolve\u2460\u2461"}, {"id": "ref-for-resolve\u2460\u2462"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-resolve\u2460\u2463"}, {"id": "ref-for-resolve\u2460\u2464"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-resolve\u2460\u2465"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-resolve\u2460\u2466"}, {"id": "ref-for-resolve\u2460\u2467"}, {"id": "ref-for-resolve\u2460\u2468"}, {"id": "ref-for-resolve\u2461\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": true}; window.dfnpanelData['9cce47fd'] = {"dfnID": "9cce47fd", "url": "https://webidl.spec.whatwg.org/#idl-sequence", "dfnText": "sequence", "refSections": [{"refs": [{"id": "ref-for-idl-sequence"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": true}; window.dfnpanelData['4013a022'] = {"dfnID": "4013a022", "url": "https://webidl.spec.whatwg.org/#this", "dfnText": "this", "refSections": [{"refs": [{"id": "ref-for-this"}, {"id": "ref-for-this\u2460"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-this\u2461"}, {"id": "ref-for-this\u2462"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-this\u2463"}, {"id": "ref-for-this\u2464"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-this\u2465"}, {"id": "ref-for-this\u2466"}, {"id": "ref-for-this\u2467"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-this\u2468"}, {"id": "ref-for-this\u2460\u24ea"}, {"id": "ref-for-this\u2460\u2460"}, {"id": "ref-for-this\u2460\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-this\u2460\u2462"}, {"id": "ref-for-this\u2460\u2463"}, {"id": "ref-for-this\u2460\u2464"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-this\u2460\u2465"}, {"id": "ref-for-this\u2460\u2466"}, {"id": "ref-for-this\u2460\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-this\u2460\u2468"}, {"id": "ref-for-this\u2461\u24ea"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-this\u2461\u2460"}], "title": "2.4.5. The resolve() method"}, {"refs": [{"id": "ref-for-this\u2461\u2461"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-this\u2461\u2462"}], "title": "2.5.2. The seek() method"}, {"refs": [{"id": "ref-for-this\u2461\u2463"}], "title": "2.5.3. The truncate() method"}, {"refs": [{"id": "ref-for-this\u2461\u2464"}, {"id": "ref-for-this\u2461\u2465"}, {"id": "ref-for-this\u2461\u2466"}, {"id": "ref-for-this\u2461\u2467"}, {"id": "ref-for-this\u2461\u2468"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-this\u2462\u24ea"}, {"id": "ref-for-this\u2462\u2460"}, {"id": "ref-for-this\u2462\u2461"}, {"id": "ref-for-this\u2462\u2462"}, {"id": "ref-for-this\u2462\u2463"}, {"id": "ref-for-this\u2462\u2464"}, {"id": "ref-for-this\u2462\u2465"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-this\u2462\u2466"}, {"id": "ref-for-this\u2462\u2467"}, {"id": "ref-for-this\u2462\u2468"}, {"id": "ref-for-this\u2463\u24ea"}, {"id": "ref-for-this\u2463\u2460"}, {"id": "ref-for-this\u2463\u2461"}, {"id": "ref-for-this\u2463\u2462"}, {"id": "ref-for-this\u2463\u2463"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-this\u2463\u2464"}, {"id": "ref-for-this\u2463\u2465"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-this\u2463\u2466"}], "title": "2.6.5. The flush() method"}, {"refs": [{"id": "ref-for-this\u2463\u2467"}, {"id": "ref-for-this\u2463\u2468"}, {"id": "ref-for-this\u2464\u24ea"}], "title": "2.6.6. The close() method"}], "external": true}; window.dfnpanelData['b4cfa5ce'] = {"dfnID": "b4cfa5ce", "url": "https://webidl.spec.whatwg.org/#dfn-throw", "dfnText": "throw", "refSections": [{"refs": [{"id": "ref-for-dfn-throw"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-dfn-throw\u2460"}, {"id": "ref-for-dfn-throw\u2461"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-dfn-throw\u2462"}, {"id": "ref-for-dfn-throw\u2463"}, {"id": "ref-for-dfn-throw\u2464"}, {"id": "ref-for-dfn-throw\u2465"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-dfn-throw\u2466"}, {"id": "ref-for-dfn-throw\u2467"}, {"id": "ref-for-dfn-throw\u2468"}, {"id": "ref-for-dfn-throw\u2460\u24ea"}, {"id": "ref-for-dfn-throw\u2460\u2460"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-dfn-throw\u2460\u2461"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-dfn-throw\u2460\u2462"}], "title": "2.6.5. The flush() method"}], "external": true}; window.dfnpanelData['5f90bbfb'] = {"dfnID": "5f90bbfb", "url": "https://webidl.spec.whatwg.org/#idl-undefined", "dfnText": "undefined", "refSections": [{"refs": [{"id": "ref-for-idl-undefined"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-idl-undefined\u2460"}, {"id": "ref-for-idl-undefined\u2461"}, {"id": "ref-for-idl-undefined\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-idl-undefined\u2463"}, {"id": "ref-for-idl-undefined\u2464"}, {"id": "ref-for-idl-undefined\u2465"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['f32e046f'] = {"dfnID": "f32e046f", "url": "https://webidl.spec.whatwg.org/#buffersource-underlying-buffer", "dfnText": "underlying buffer", "refSections": [{"refs": [{"id": "ref-for-buffersource-underlying-buffer"}], "title": "2.6.1. The read() method"}], "external": true}; window.dfnpanelData['f14b47b8'] = {"dfnID": "f14b47b8", "url": "https://webidl.spec.whatwg.org/#idl-unsigned-long-long", "dfnText": "unsigned long long", "refSections": [{"refs": [{"id": "ref-for-idl-unsigned-long-long"}, {"id": "ref-for-idl-unsigned-long-long\u2460"}, {"id": "ref-for-idl-unsigned-long-long\u2461"}, {"id": "ref-for-idl-unsigned-long-long\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-idl-unsigned-long-long\u2463"}, {"id": "ref-for-idl-unsigned-long-long\u2464"}, {"id": "ref-for-idl-unsigned-long-long\u2465"}, {"id": "ref-for-idl-unsigned-long-long\u2466"}, {"id": "ref-for-idl-unsigned-long-long\u2467"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": true}; window.dfnpanelData['2d6ca7ca'] = {"dfnID": "2d6ca7ca", "url": "https://webidl.spec.whatwg.org/#arraybuffer-write", "dfnText": "write", "refSections": [{"refs": [{"id": "ref-for-arraybuffer-write"}], "title": "2.6.1. The read() method"}], "external": true}; window.dfnpanelData['entry'] = {"dfnID": "entry", "url": "#entry", "dfnText": "file system entry", "refSections": [{"refs": [{"id": "ref-for-entry"}, {"id": "ref-for-entry\u2460"}, {"id": "ref-for-entry\u2461"}, {"id": "ref-for-entry\u2462"}, {"id": "ref-for-entry\u2463"}, {"id": "ref-for-entry\u2464"}, {"id": "ref-for-entry\u2465"}, {"id": "ref-for-entry\u2466"}, {"id": "ref-for-entry\u2467"}, {"id": "ref-for-entry\u2468"}, {"id": "ref-for-entry\u2460\u24ea"}, {"id": "ref-for-entry\u2460\u2460"}, {"id": "ref-for-entry\u2460\u2461"}, {"id": "ref-for-entry\u2460\u2462"}, {"id": "ref-for-entry\u2460\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-entry\u2460\u2464"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-entry\u2460\u2465"}], "title": "2.4.4. The removeEntry() method"}], "external": false}; window.dfnpanelData['entry-query-access'] = {"dfnID": "entry-query-access", "url": "#entry-query-access", "dfnText": "query access", "refSections": [{"refs": [{"id": "ref-for-entry-query-access"}, {"id": "ref-for-entry-query-access\u2460"}, {"id": "ref-for-entry-query-access\u2461"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-entry-query-access\u2462"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-entry-query-access\u2463"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-entry-query-access\u2464"}, {"id": "ref-for-entry-query-access\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-entry-query-access\u2466"}, {"id": "ref-for-entry-query-access\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-entry-query-access\u2468"}, {"id": "ref-for-entry-query-access\u2460\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-entry-query-access\u2460\u2460"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['entry-request-access'] = {"dfnID": "entry-request-access", "url": "#entry-request-access", "dfnText": "request access", "refSections": [{"refs": [{"id": "ref-for-entry-request-access"}, {"id": "ref-for-entry-request-access\u2460"}, {"id": "ref-for-entry-request-access\u2461"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-entry-request-access\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-entry-request-access\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-entry-request-access\u2464"}, {"id": "ref-for-entry-request-access\u2465"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-entry-request-access\u2466"}, {"id": "ref-for-entry-request-access\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-entry-request-access\u2468"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-entry-request-access\u2460\u24ea"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['file-system-access-result'] = {"dfnID": "file-system-access-result", "url": "#file-system-access-result", "dfnText": "file system access result", "refSections": [{"refs": [{"id": "ref-for-file-system-access-result"}, {"id": "ref-for-file-system-access-result\u2460"}, {"id": "ref-for-file-system-access-result\u2461"}, {"id": "ref-for-file-system-access-result\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-access-result\u2463"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['file-system-access-result-permission-state'] = {"dfnID": "file-system-access-result-permission-state", "url": "#file-system-access-result-permission-state", "dfnText": "permission state", "refSections": [{"refs": [{"id": "ref-for-file-system-access-result-permission-state"}, {"id": "ref-for-file-system-access-result-permission-state\u2460"}, {"id": "ref-for-file-system-access-result-permission-state\u2461"}, {"id": "ref-for-file-system-access-result-permission-state\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2463"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2464"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2465"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2466"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2467"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2468"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2460\u24ea"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2460\u2460"}, {"id": "ref-for-file-system-access-result-permission-state\u2460\u2461"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file-system-access-result-permission-state\u2460\u2462"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['file-system-access-result-error-name'] = {"dfnID": "file-system-access-result-error-name", "url": "#file-system-access-result-error-name", "dfnText": "error name", "refSections": [{"refs": [{"id": "ref-for-file-system-access-result-error-name"}, {"id": "ref-for-file-system-access-result-error-name\u2460"}, {"id": "ref-for-file-system-access-result-error-name\u2461"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2462"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2463"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2464"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2465"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2466"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2468"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2460\u24ea"}, {"id": "ref-for-file-system-access-result-error-name\u2460\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file-system-access-result-error-name\u2460\u2461"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['entry-name'] = {"dfnID": "entry-name", "url": "#entry-name", "dfnText": "name", "refSections": [{"refs": [{"id": "ref-for-entry-name"}, {"id": "ref-for-entry-name\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-entry-name\u2461"}, {"id": "ref-for-entry-name\u2462"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-entry-name\u2463"}, {"id": "ref-for-entry-name\u2464"}, {"id": "ref-for-entry-name\u2465"}, {"id": "ref-for-entry-name\u2466"}, {"id": "ref-for-entry-name\u2467"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-entry-name\u2468"}, {"id": "ref-for-entry-name\u2460\u24ea"}, {"id": "ref-for-entry-name\u2460\u2460"}, {"id": "ref-for-entry-name\u2460\u2461"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-entry-name\u2460\u2462"}, {"id": "ref-for-entry-name\u2460\u2463"}, {"id": "ref-for-entry-name\u2460\u2464"}, {"id": "ref-for-entry-name\u2460\u2465"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-entry-name\u2460\u2466"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-entry-name\u2460\u2467"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['valid-file-name'] = {"dfnID": "valid-file-name", "url": "#valid-file-name", "dfnText": "valid file name", "refSections": [{"refs": [{"id": "ref-for-valid-file-name"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-valid-file-name\u2460"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-valid-file-name\u2461"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-valid-file-name\u2462"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-valid-file-name\u2463"}], "title": "2.4.4. The removeEntry() method"}], "external": false}; window.dfnpanelData['file'] = {"dfnID": "file", "url": "#file", "dfnText": "file entry", "refSections": [{"refs": [{"id": "ref-for-file"}, {"id": "ref-for-file\u2460"}, {"id": "ref-for-file\u2461"}, {"id": "ref-for-file\u2462"}, {"id": "ref-for-file\u2463"}, {"id": "ref-for-file\u2464"}, {"id": "ref-for-file\u2465"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file\u2466"}, {"id": "ref-for-file\u2467"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file\u2468"}, {"id": "ref-for-file\u2460\u24ea"}, {"id": "ref-for-file\u2460\u2460"}, {"id": "ref-for-file\u2460\u2461"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file\u2460\u2462"}, {"id": "ref-for-file\u2460\u2463"}, {"id": "ref-for-file\u2460\u2464"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-file\u2460\u2465"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-file\u2460\u2466"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-file\u2460\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-file\u2460\u2468"}, {"id": "ref-for-file\u2461\u24ea"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file\u2461\u2460"}, {"id": "ref-for-file\u2461\u2461"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": false}; window.dfnpanelData['file-entry-binary-data'] = {"dfnID": "file-entry-binary-data", "url": "#file-entry-binary-data", "dfnText": "binary data", "refSections": [{"refs": [{"id": "ref-for-file-entry-binary-data"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2460"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2461"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2462"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2464"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2465"}, {"id": "ref-for-file-entry-binary-data\u2466"}, {"id": "ref-for-file-entry-binary-data\u2467"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2468"}, {"id": "ref-for-file-entry-binary-data\u2460\u24ea"}, {"id": "ref-for-file-entry-binary-data\u2460\u2460"}, {"id": "ref-for-file-entry-binary-data\u2460\u2461"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-file-entry-binary-data\u2460\u2462"}], "title": "2.6.4. The getSize() method"}], "external": false}; window.dfnpanelData['file-entry-modification-timestamp'] = {"dfnID": "file-entry-modification-timestamp", "url": "#file-entry-modification-timestamp", "dfnText": "modification timestamp", "refSections": [{"refs": [{"id": "ref-for-file-entry-modification-timestamp"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-entry-modification-timestamp\u2460"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file-entry-modification-timestamp\u2461"}], "title": "2.4.2. The getFileHandle() method"}], "external": false}; window.dfnpanelData['file-entry-lock'] = {"dfnID": "file-entry-lock", "url": "#file-entry-lock", "dfnText": "lock", "refSections": [{"refs": [{"id": "ref-for-file-entry-lock"}, {"id": "ref-for-file-entry-lock\u2460"}, {"id": "ref-for-file-entry-lock\u2461"}, {"id": "ref-for-file-entry-lock\u2462"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['file-entry-shared-lock-count'] = {"dfnID": "file-entry-shared-lock-count", "url": "#file-entry-shared-lock-count", "dfnText": "shared lock count", "refSections": [{"refs": [{"id": "ref-for-file-entry-shared-lock-count"}, {"id": "ref-for-file-entry-shared-lock-count\u2460"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['file-system-queue'] = {"dfnID": "file-system-queue", "url": "#file-system-queue", "dfnText": "file system queue", "refSections": [{"refs": [{"id": "ref-for-file-system-queue"}, {"id": "ref-for-file-system-queue\u2460"}, {"id": "ref-for-file-system-queue\u2461"}, {"id": "ref-for-file-system-queue\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-queue\u2463"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2464"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2465"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2466"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2467"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-file-system-queue\u2468"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2460\u24ea"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2460\u2460"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-file-system-queue\u2460\u2461"}, {"id": "ref-for-file-system-queue\u2460\u2462"}, {"id": "ref-for-file-system-queue\u2460\u2463"}, {"id": "ref-for-file-system-queue\u2460\u2464"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file-system-queue\u2460\u2465"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['file-entry-lock-take'] = {"dfnID": "file-entry-lock-take", "url": "#file-entry-lock-take", "dfnText": "take", "refSections": [{"refs": [{"id": "ref-for-file-entry-lock-take"}, {"id": "ref-for-file-entry-lock-take\u2460"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-file-entry-lock-take\u2461"}, {"id": "ref-for-file-entry-lock-take\u2462"}], "title": "2.3.3. The createSyncAccessHandle() method"}], "external": false}; window.dfnpanelData['file-entry-lock-release'] = {"dfnID": "file-entry-lock-release", "url": "#file-entry-lock-release", "dfnText": "release", "refSections": [{"refs": [{"id": "ref-for-file-entry-lock-release"}, {"id": "ref-for-file-entry-lock-release\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-file-entry-lock-release\u2461"}, {"id": "ref-for-file-entry-lock-release\u2462"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['directory'] = {"dfnID": "directory", "url": "#directory", "dfnText": "directory entry", "refSections": [{"refs": [{"id": "ref-for-directory"}, {"id": "ref-for-directory\u2460"}, {"id": "ref-for-directory\u2461"}, {"id": "ref-for-directory\u2462"}, {"id": "ref-for-directory\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-directory\u2464"}, {"id": "ref-for-directory\u2465"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-directory\u2466"}, {"id": "ref-for-directory\u2467"}, {"id": "ref-for-directory\u2468"}, {"id": "ref-for-directory\u2460\u24ea"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-directory\u2460\u2460"}, {"id": "ref-for-directory\u2460\u2461"}, {"id": "ref-for-directory\u2460\u2462"}, {"id": "ref-for-directory\u2460\u2463"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-directory\u2460\u2464"}, {"id": "ref-for-directory\u2460\u2465"}, {"id": "ref-for-directory\u2460\u2466"}, {"id": "ref-for-directory\u2460\u2467"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-directory\u2460\u2468"}, {"id": "ref-for-directory\u2461\u24ea"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['directory-entry-children'] = {"dfnID": "directory-entry-children", "url": "#directory-entry-children", "dfnText": "children", "refSections": [{"refs": [{"id": "ref-for-directory-entry-children"}, {"id": "ref-for-directory-entry-children\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-directory-entry-children\u2461"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-directory-entry-children\u2462"}, {"id": "ref-for-directory-entry-children\u2463"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-directory-entry-children\u2464"}, {"id": "ref-for-directory-entry-children\u2465"}, {"id": "ref-for-directory-entry-children\u2466"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-directory-entry-children\u2467"}, {"id": "ref-for-directory-entry-children\u2468"}, {"id": "ref-for-directory-entry-children\u2460\u24ea"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-directory-entry-children\u2460\u2460"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['entry-parent'] = {"dfnID": "entry-parent", "url": "#entry-parent", "dfnText": "parent", "refSections": [{"refs": [{"id": "ref-for-entry-parent"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['file-system-entry-the-same-entry-as'] = {"dfnID": "file-system-entry-the-same-entry-as", "url": "#file-system-entry-the-same-entry-as", "dfnText": "the same entry as", "refSections": [{"refs": [{"id": "ref-for-file-system-entry-the-same-entry-as"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['locator-resolve'] = {"dfnID": "locator-resolve", "url": "#locator-resolve", "dfnText": "resolve", "refSections": [{"refs": [{"id": "ref-for-locator-resolve"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-locator-resolve\u2460"}], "title": "2.4.5. The resolve() method"}], "external": false}; window.dfnpanelData['file-system-locator'] = {"dfnID": "file-system-locator", "url": "#file-system-locator", "dfnText": "file system locator", "refSections": [{"refs": [{"id": "ref-for-file-system-locator"}, {"id": "ref-for-file-system-locator\u2460"}, {"id": "ref-for-file-system-locator\u2461"}, {"id": "ref-for-file-system-locator\u2462"}, {"id": "ref-for-file-system-locator\u2463"}, {"id": "ref-for-file-system-locator\u2464"}, {"id": "ref-for-file-system-locator\u2465"}, {"id": "ref-for-file-system-locator\u2466"}, {"id": "ref-for-file-system-locator\u2467"}, {"id": "ref-for-file-system-locator\u2468"}, {"id": "ref-for-file-system-locator\u2460\u24ea"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-locator\u2460\u2460"}, {"id": "ref-for-file-system-locator\u2460\u2461"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-file-system-locator\u2460\u2462"}, {"id": "ref-for-file-system-locator\u2460\u2463"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-file-system-locator\u2460\u2464"}, {"id": "ref-for-file-system-locator\u2460\u2465"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['locator-path'] = {"dfnID": "locator-path", "url": "#locator-path", "dfnText": "path", "refSections": [{"refs": [{"id": "ref-for-locator-path"}, {"id": "ref-for-locator-path\u2460"}, {"id": "ref-for-locator-path\u2461"}, {"id": "ref-for-locator-path\u2462"}, {"id": "ref-for-locator-path\u2463"}, {"id": "ref-for-locator-path\u2464"}, {"id": "ref-for-locator-path\u2465"}, {"id": "ref-for-locator-path\u2466"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-locator-path\u2467"}, {"id": "ref-for-locator-path\u2468"}, {"id": "ref-for-locator-path\u2460\u24ea"}, {"id": "ref-for-locator-path\u2460\u2460"}, {"id": "ref-for-locator-path\u2460\u2461"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-locator-path\u2460\u2462"}, {"id": "ref-for-locator-path\u2460\u2463"}, {"id": "ref-for-locator-path\u2460\u2464"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-locator-path\u2460\u2465"}, {"id": "ref-for-locator-path\u2460\u2466"}, {"id": "ref-for-locator-path\u2460\u2467"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['locator-kind'] = {"dfnID": "locator-kind", "url": "#locator-kind", "dfnText": "kind", "refSections": [{"refs": [{"id": "ref-for-locator-kind"}, {"id": "ref-for-locator-kind\u2460"}, {"id": "ref-for-locator-kind\u2461"}, {"id": "ref-for-locator-kind\u2462"}, {"id": "ref-for-locator-kind\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-locator-kind\u2464"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-locator-kind\u2465"}, {"id": "ref-for-locator-kind\u2466"}, {"id": "ref-for-locator-kind\u2467"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-locator-kind\u2468"}, {"id": "ref-for-locator-kind\u2460\u24ea"}, {"id": "ref-for-locator-kind\u2460\u2460"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['locator-root'] = {"dfnID": "locator-root", "url": "#locator-root", "dfnText": "root", "refSections": [{"refs": [{"id": "ref-for-locator-root"}, {"id": "ref-for-locator-root\u2460"}, {"id": "ref-for-locator-root\u2461"}, {"id": "ref-for-locator-root\u2462"}, {"id": "ref-for-locator-root\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-locator-root\u2464"}, {"id": "ref-for-locator-root\u2465"}, {"id": "ref-for-locator-root\u2466"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-locator-root\u2467"}, {"id": "ref-for-locator-root\u2468"}, {"id": "ref-for-locator-root\u2460\u24ea"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['file-locator'] = {"dfnID": "file-locator", "url": "#file-locator", "dfnText": "file locator", "refSections": [{"refs": [{"id": "ref-for-file-locator"}, {"id": "ref-for-file-locator\u2460"}, {"id": "ref-for-file-locator\u2461"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['directory-locator'] = {"dfnID": "directory-locator", "url": "#directory-locator", "dfnText": "directory locator", "refSections": [{"refs": [{"id": "ref-for-directory-locator"}, {"id": "ref-for-directory-locator\u2460"}, {"id": "ref-for-directory-locator\u2461"}, {"id": "ref-for-directory-locator\u2462"}, {"id": "ref-for-directory-locator\u2463"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-directory-locator\u2464"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-directory-locator\u2465"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['file-system-root'] = {"dfnID": "file-system-root", "url": "#file-system-root", "dfnText": "file system root", "refSections": [{"refs": [{"id": "ref-for-file-system-root"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-root\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-file-system-root\u2461"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['file-system-locator-the-same-locator-as'] = {"dfnID": "file-system-locator-the-same-locator-as", "url": "#file-system-locator-the-same-locator-as", "dfnText": "the same locator as", "refSections": [{"refs": [{"id": "ref-for-file-system-locator-the-same-locator-as"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-file-system-locator-the-same-locator-as\u2460"}], "title": "2.2.1. The isSameEntry() method"}], "external": false}; window.dfnpanelData['locating-an-entry'] = {"dfnID": "locating-an-entry", "url": "#locating-an-entry", "dfnText": "locate an entry", "refSections": [{"refs": [{"id": "ref-for-locating-an-entry"}, {"id": "ref-for-locating-an-entry\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-locating-an-entry\u2461"}, {"id": "ref-for-locating-an-entry\u2462"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2463"}, {"id": "ref-for-locating-an-entry\u2464"}, {"id": "ref-for-locating-an-entry\u2465"}, {"id": "ref-for-locating-an-entry\u2466"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2467"}, {"id": "ref-for-locating-an-entry\u2468"}, {"id": "ref-for-locating-an-entry\u2460\u24ea"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2460\u2460"}, {"id": "ref-for-locating-an-entry\u2460\u2461"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-locating-an-entry\u2460\u2462"}, {"id": "ref-for-locating-an-entry\u2460\u2463"}, {"id": "ref-for-locating-an-entry\u2460\u2464"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2460\u2465"}, {"id": "ref-for-locating-an-entry\u2460\u2466"}, {"id": "ref-for-locating-an-entry\u2460\u2467"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2460\u2468"}, {"id": "ref-for-locating-an-entry\u2461\u24ea"}, {"id": "ref-for-locating-an-entry\u2461\u2460"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-locating-an-entry\u2461\u2461"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['getting-the-locator'] = {"dfnID": "getting-the-locator", "url": "#getting-the-locator", "dfnText": "get the locator", "refSections": [{"refs": [{"id": "ref-for-getting-the-locator"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['file-system-path'] = {"dfnID": "file-system-path", "url": "#file-system-path", "dfnText": "file system path", "refSections": [{"refs": [{"id": "ref-for-file-system-path"}, {"id": "ref-for-file-system-path\u2460"}, {"id": "ref-for-file-system-path\u2461"}, {"id": "ref-for-file-system-path\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-file-system-path\u2463"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-file-system-path\u2464"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['file-system-path-the-same-path-as'] = {"dfnID": "file-system-path-the-same-path-as", "url": "#file-system-path-the-same-path-as", "dfnText": "the same path as", "refSections": [{"refs": [{"id": "ref-for-file-system-path-the-same-path-as"}, {"id": "ref-for-file-system-path-the-same-path-as\u2460"}], "title": "2.1. Concepts"}], "external": false}; window.dfnpanelData['enumdef-filesystemhandlekind'] = {"dfnID": "enumdef-filesystemhandlekind", "url": "#enumdef-filesystemhandlekind", "dfnText": "FileSystemHandleKind", "refSections": [{"refs": [{"id": "ref-for-enumdef-filesystemhandlekind"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-enumdef-filesystemhandlekind\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemhandlekind-file'] = {"dfnID": "dom-filesystemhandlekind-file", "url": "#dom-filesystemhandlekind-file", "dfnText": "\"file\"", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemhandlekind-file"}, {"id": "ref-for-dom-filesystemhandlekind-file\u2460"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-dom-filesystemhandlekind-file\u2461"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemhandlekind-file\u2462"}, {"id": "ref-for-dom-filesystemhandlekind-file\u2463"}, {"id": "ref-for-dom-filesystemhandlekind-file\u2464"}], "title": "2.3. The FileSystemFileHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemhandlekind-directory'] = {"dfnID": "dom-filesystemhandlekind-directory", "url": "#dom-filesystemhandlekind-directory", "dfnText": "\"directory\"", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemhandlekind-directory"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-dom-filesystemhandlekind-directory\u2460"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemhandlekind-directory\u2461"}, {"id": "ref-for-dom-filesystemhandlekind-directory\u2462"}, {"id": "ref-for-dom-filesystemhandlekind-directory\u2463"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['filesystemhandle'] = {"dfnID": "filesystemhandle", "url": "#filesystemhandle", "dfnText": "FileSystemHandle", "refSections": [{"refs": [{"id": "ref-for-filesystemhandle"}, {"id": "ref-for-filesystemhandle\u2460"}, {"id": "ref-for-filesystemhandle\u2461"}, {"id": "ref-for-filesystemhandle\u2462"}, {"id": "ref-for-filesystemhandle\u2463"}, {"id": "ref-for-filesystemhandle\u2464"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-filesystemhandle\u2465"}, {"id": "ref-for-filesystemhandle\u2466"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-filesystemhandle\u2467"}, {"id": "ref-for-filesystemhandle\u2468"}, {"id": "ref-for-filesystemhandle\u2460\u24ea"}, {"id": "ref-for-filesystemhandle\u2460\u2460"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['filesystemhandle-locator'] = {"dfnID": "filesystemhandle-locator", "url": "#filesystemhandle-locator", "dfnText": "locator", "refSections": [{"refs": [{"id": "ref-for-filesystemhandle-locator"}, {"id": "ref-for-filesystemhandle-locator\u2460"}, {"id": "ref-for-filesystemhandle-locator\u2461"}, {"id": "ref-for-filesystemhandle-locator\u2462"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2463"}, {"id": "ref-for-filesystemhandle-locator\u2464"}, {"id": "ref-for-filesystemhandle-locator\u2465"}, {"id": "ref-for-filesystemhandle-locator\u2466"}, {"id": "ref-for-filesystemhandle-locator\u2467"}, {"id": "ref-for-filesystemhandle-locator\u2468"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2460\u24ea"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2460"}], "title": "2.2.1. The isSameEntry() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2460\u2461"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2462"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2463"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2460\u2464"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2465"}], "title": "2.3.1. The getFile() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2460\u2466"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2467"}, {"id": "ref-for-filesystemhandle-locator\u2460\u2468"}, {"id": "ref-for-filesystemhandle-locator\u2461\u24ea"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2461\u2460"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2461"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2462"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2461\u2463"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2464"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2465"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2461\u2466"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2467"}, {"id": "ref-for-filesystemhandle-locator\u2461\u2468"}, {"id": "ref-for-filesystemhandle-locator\u2462\u24ea"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2462\u2460"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2461"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2462"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2462\u2463"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2464"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2465"}], "title": "2.4.3. The getDirectoryHandle() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2462\u2466"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2467"}, {"id": "ref-for-filesystemhandle-locator\u2462\u2468"}], "title": "2.4.4. The removeEntry() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2463\u24ea"}, {"id": "ref-for-filesystemhandle-locator\u2463\u2460"}], "title": "2.4.5. The resolve() method"}, {"refs": [{"id": "ref-for-filesystemhandle-locator\u2463\u2461"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['filesystemhandle-is-in-a-bucket-file-system'] = {"dfnID": "filesystemhandle-is-in-a-bucket-file-system", "url": "#filesystemhandle-is-in-a-bucket-file-system", "dfnText": "is in a bucket file system", "refSections": [{"refs": [{"id": "ref-for-filesystemhandle-is-in-a-bucket-file-system"}, {"id": "ref-for-filesystemhandle-is-in-a-bucket-file-system\u2460"}], "title": "2.3.3. The createSyncAccessHandle() method"}], "external": false}; window.dfnpanelData['dom-filesystemhandle-kind'] = {"dfnID": "dom-filesystemhandle-kind", "url": "#dom-filesystemhandle-kind", "dfnText": "kind", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemhandle-kind"}, {"id": "ref-for-dom-filesystemhandle-kind\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemhandle-name'] = {"dfnID": "dom-filesystemhandle-name", "url": "#dom-filesystemhandle-name", "dfnText": "name", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemhandle-name"}, {"id": "ref-for-dom-filesystemhandle-name\u2460"}], "title": "2.2. The FileSystemHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemhandle-issameentry'] = {"dfnID": "dom-filesystemhandle-issameentry", "url": "#dom-filesystemhandle-issameentry", "dfnText": "isSameEntry(other)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemhandle-issameentry"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemhandle-issameentry\u2460"}, {"id": "ref-for-dom-filesystemhandle-issameentry\u2461"}], "title": "2.2.1. The isSameEntry() method"}], "external": false}; window.dfnpanelData['dictdef-filesystemcreatewritableoptions'] = {"dfnID": "dictdef-filesystemcreatewritableoptions", "url": "#dictdef-filesystemcreatewritableoptions", "dfnText": "FileSystemCreateWritableOptions", "refSections": [{"refs": [{"id": "ref-for-dictdef-filesystemcreatewritableoptions"}], "title": "2.3. The FileSystemFileHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemcreatewritableoptions-keepexistingdata'] = {"dfnID": "dom-filesystemcreatewritableoptions-keepexistingdata", "url": "#dom-filesystemcreatewritableoptions-keepexistingdata", "dfnText": "keepExistingData", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemcreatewritableoptions-keepexistingdata"}, {"id": "ref-for-dom-filesystemcreatewritableoptions-keepexistingdata\u2460"}, {"id": "ref-for-dom-filesystemcreatewritableoptions-keepexistingdata\u2461"}], "title": "2.3.2. The createWritable() method"}], "external": false}; window.dfnpanelData['filesystemfilehandle'] = {"dfnID": "filesystemfilehandle", "url": "#filesystemfilehandle", "dfnText": "FileSystemFileHandle", "refSections": [{"refs": [{"id": "ref-for-filesystemfilehandle"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-filesystemfilehandle\u2460"}, {"id": "ref-for-filesystemfilehandle\u2461"}, {"id": "ref-for-filesystemfilehandle\u2462"}, {"id": "ref-for-filesystemfilehandle\u2463"}, {"id": "ref-for-filesystemfilehandle\u2464"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-filesystemfilehandle\u2465"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['creating-a-child-filesystemfilehandle'] = {"dfnID": "creating-a-child-filesystemfilehandle", "url": "#creating-a-child-filesystemfilehandle", "dfnText": "create a child FileSystemFileHandle", "refSections": [{"refs": [{"id": "ref-for-creating-a-child-filesystemfilehandle"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-creating-a-child-filesystemfilehandle\u2460"}, {"id": "ref-for-creating-a-child-filesystemfilehandle\u2461"}], "title": "2.4.2. The getFileHandle() method"}], "external": false}; window.dfnpanelData['dom-filesystemfilehandle-getfile'] = {"dfnID": "dom-filesystemfilehandle-getfile", "url": "#dom-filesystemfilehandle-getfile", "dfnText": "getFile()", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemfilehandle-getfile"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemfilehandle-getfile\u2460"}, {"id": "ref-for-dom-filesystemfilehandle-getfile\u2461"}], "title": "2.3.1. The getFile() method"}], "external": false}; window.dfnpanelData['dom-filesystemfilehandle-createwritable'] = {"dfnID": "dom-filesystemfilehandle-createwritable", "url": "#dom-filesystemfilehandle-createwritable", "dfnText": "createWritable(options)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemfilehandle-createwritable"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemfilehandle-createwritable\u2460"}, {"id": "ref-for-dom-filesystemfilehandle-createwritable\u2461"}, {"id": "ref-for-dom-filesystemfilehandle-createwritable\u2462"}], "title": "2.3.2. The createWritable() method"}], "external": false}; window.dfnpanelData['dom-filesystemfilehandle-createsyncaccesshandle'] = {"dfnID": "dom-filesystemfilehandle-createsyncaccesshandle", "url": "#dom-filesystemfilehandle-createsyncaccesshandle", "dfnText": "createSyncAccessHandle()", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemfilehandle-createsyncaccesshandle"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemfilehandle-createsyncaccesshandle\u2460"}, {"id": "ref-for-dom-filesystemfilehandle-createsyncaccesshandle\u2461"}], "title": "2.3.3. The createSyncAccessHandle() method"}], "external": false}; window.dfnpanelData['dictdef-filesystemgetfileoptions'] = {"dfnID": "dictdef-filesystemgetfileoptions", "url": "#dictdef-filesystemgetfileoptions", "dfnText": "FileSystemGetFileOptions", "refSections": [{"refs": [{"id": "ref-for-dictdef-filesystemgetfileoptions"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemgetfileoptions-create'] = {"dfnID": "dom-filesystemgetfileoptions-create", "url": "#dom-filesystemgetfileoptions-create", "dfnText": "create", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemgetfileoptions-create"}, {"id": "ref-for-dom-filesystemgetfileoptions-create\u2460"}, {"id": "ref-for-dom-filesystemgetfileoptions-create\u2461"}, {"id": "ref-for-dom-filesystemgetfileoptions-create\u2462"}, {"id": "ref-for-dom-filesystemgetfileoptions-create\u2463"}], "title": "2.4.2. The getFileHandle() method"}, {"refs": [{"id": "ref-for-dom-filesystemgetfileoptions-create\u2464"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": false}; window.dfnpanelData['dictdef-filesystemgetdirectoryoptions'] = {"dfnID": "dictdef-filesystemgetdirectoryoptions", "url": "#dictdef-filesystemgetdirectoryoptions", "dfnText": "FileSystemGetDirectoryOptions", "refSections": [{"refs": [{"id": "ref-for-dictdef-filesystemgetdirectoryoptions"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemgetdirectoryoptions-create'] = {"dfnID": "dom-filesystemgetdirectoryoptions-create", "url": "#dom-filesystemgetdirectoryoptions-create", "dfnText": "create", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemgetdirectoryoptions-create"}, {"id": "ref-for-dom-filesystemgetdirectoryoptions-create\u2460"}, {"id": "ref-for-dom-filesystemgetdirectoryoptions-create\u2461"}, {"id": "ref-for-dom-filesystemgetdirectoryoptions-create\u2462"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": false}; window.dfnpanelData['dictdef-filesystemremoveoptions'] = {"dfnID": "dictdef-filesystemremoveoptions", "url": "#dictdef-filesystemremoveoptions", "dfnText": "FileSystemRemoveOptions", "refSections": [{"refs": [{"id": "ref-for-dictdef-filesystemremoveoptions"}], "title": "2.4. The FileSystemDirectoryHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemremoveoptions-recursive'] = {"dfnID": "dom-filesystemremoveoptions-recursive", "url": "#dom-filesystemremoveoptions-recursive", "dfnText": "recursive", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemremoveoptions-recursive"}, {"id": "ref-for-dom-filesystemremoveoptions-recursive\u2460"}, {"id": "ref-for-dom-filesystemremoveoptions-recursive\u2461"}, {"id": "ref-for-dom-filesystemremoveoptions-recursive\u2462"}], "title": "2.4.4. The removeEntry() method"}], "external": false}; window.dfnpanelData['filesystemdirectoryhandle'] = {"dfnID": "filesystemdirectoryhandle", "url": "#filesystemdirectoryhandle", "dfnText": "FileSystemDirectoryHandle", "refSections": [{"refs": [{"id": "ref-for-filesystemdirectoryhandle"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-filesystemdirectoryhandle\u2460"}, {"id": "ref-for-filesystemdirectoryhandle\u2461"}, {"id": "ref-for-filesystemdirectoryhandle\u2462"}, {"id": "ref-for-filesystemdirectoryhandle\u2463"}, {"id": "ref-for-filesystemdirectoryhandle\u2464"}, {"id": "ref-for-filesystemdirectoryhandle\u2465"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-filesystemdirectoryhandle\u2466"}, {"id": "ref-for-filesystemdirectoryhandle\u2467"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-filesystemdirectoryhandle\u2468"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['creating-a-child-filesystemdirectoryhandle'] = {"dfnID": "creating-a-child-filesystemdirectoryhandle", "url": "#creating-a-child-filesystemdirectoryhandle", "dfnText": "create a child FileSystemDirectoryHandle", "refSections": [{"refs": [{"id": "ref-for-creating-a-child-filesystemdirectoryhandle"}], "title": "2.4.1. Directory iteration"}, {"refs": [{"id": "ref-for-creating-a-child-filesystemdirectoryhandle\u2460"}, {"id": "ref-for-creating-a-child-filesystemdirectoryhandle\u2461"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": false}; window.dfnpanelData['creating-a-new-filesystemdirectoryhandle'] = {"dfnID": "creating-a-new-filesystemdirectoryhandle", "url": "#creating-a-new-filesystemdirectoryhandle", "dfnText": "create a new FileSystemDirectoryHandle", "refSections": [{"refs": [{"id": "ref-for-creating-a-new-filesystemdirectoryhandle"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['filesystemdirectoryhandle-iterator-past-results'] = {"dfnID": "filesystemdirectoryhandle-iterator-past-results", "url": "#filesystemdirectoryhandle-iterator-past-results", "dfnText": "past results", "refSections": [{"refs": [{"id": "ref-for-filesystemdirectoryhandle-iterator-past-results"}, {"id": "ref-for-filesystemdirectoryhandle-iterator-past-results\u2460"}], "title": "2.4.1. Directory iteration"}], "external": false}; window.dfnpanelData['dom-filesystemdirectoryhandle-getfilehandle'] = {"dfnID": "dom-filesystemdirectoryhandle-getfilehandle", "url": "#dom-filesystemdirectoryhandle-getfilehandle", "dfnText": "getFileHandle(name, options)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-getfilehandle"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-getfilehandle\u2460"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getfilehandle\u2461"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getfilehandle\u2462"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getfilehandle\u2463"}], "title": "2.4.2. The getFileHandle() method"}], "external": false}; window.dfnpanelData['dom-filesystemdirectoryhandle-getdirectoryhandle'] = {"dfnID": "dom-filesystemdirectoryhandle-getdirectoryhandle", "url": "#dom-filesystemdirectoryhandle-getdirectoryhandle", "dfnText": "getDirectoryHandle(name, options)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-getdirectoryhandle"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-getdirectoryhandle\u2460"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getdirectoryhandle\u2461"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getdirectoryhandle\u2462"}, {"id": "ref-for-dom-filesystemdirectoryhandle-getdirectoryhandle\u2463"}], "title": "2.4.3. The getDirectoryHandle() method"}], "external": false}; window.dfnpanelData['dom-filesystemdirectoryhandle-removeentry'] = {"dfnID": "dom-filesystemdirectoryhandle-removeentry", "url": "#dom-filesystemdirectoryhandle-removeentry", "dfnText": "removeEntry(name, options)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-removeentry"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-removeentry\u2460"}, {"id": "ref-for-dom-filesystemdirectoryhandle-removeentry\u2461"}, {"id": "ref-for-dom-filesystemdirectoryhandle-removeentry\u2462"}, {"id": "ref-for-dom-filesystemdirectoryhandle-removeentry\u2463"}], "title": "2.4.4. The removeEntry() method"}], "external": false}; window.dfnpanelData['dom-filesystemdirectoryhandle-resolve'] = {"dfnID": "dom-filesystemdirectoryhandle-resolve", "url": "#dom-filesystemdirectoryhandle-resolve", "dfnText": "resolve(possibleDescendant)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-resolve"}], "title": "2.4. The FileSystemDirectoryHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemdirectoryhandle-resolve\u2460"}, {"id": "ref-for-dom-filesystemdirectoryhandle-resolve\u2461"}], "title": "2.4.5. The resolve() method"}], "external": false}; window.dfnpanelData['enumdef-writecommandtype'] = {"dfnID": "enumdef-writecommandtype", "url": "#enumdef-writecommandtype", "dfnText": "WriteCommandType", "refSections": [{"refs": [{"id": "ref-for-enumdef-writecommandtype"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['dom-writecommandtype-write'] = {"dfnID": "dom-writecommandtype-write", "url": "#dom-writecommandtype-write", "dfnText": "\"write\"", "refSections": [{"refs": [{"id": "ref-for-dom-writecommandtype-write"}, {"id": "ref-for-dom-writecommandtype-write\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writecommandtype-write\u2461"}, {"id": "ref-for-dom-writecommandtype-write\u2462"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writecommandtype-write\u2463"}], "title": "2.6.2. The write() method"}], "external": false}; window.dfnpanelData['dom-writecommandtype-seek'] = {"dfnID": "dom-writecommandtype-seek", "url": "#dom-writecommandtype-seek", "dfnText": "\"seek\"", "refSections": [{"refs": [{"id": "ref-for-dom-writecommandtype-seek"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writecommandtype-seek\u2460"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writecommandtype-seek\u2461"}], "title": "2.5.2. The seek() method"}], "external": false}; window.dfnpanelData['dom-writecommandtype-truncate'] = {"dfnID": "dom-writecommandtype-truncate", "url": "#dom-writecommandtype-truncate", "dfnText": "\"truncate\"", "refSections": [{"refs": [{"id": "ref-for-dom-writecommandtype-truncate"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writecommandtype-truncate\u2460"}, {"id": "ref-for-dom-writecommandtype-truncate\u2461"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writecommandtype-truncate\u2462"}, {"id": "ref-for-dom-writecommandtype-truncate\u2463"}], "title": "2.5.3. The truncate() method"}, {"refs": [{"id": "ref-for-dom-writecommandtype-truncate\u2464"}], "title": "2.6.3. The truncate() method"}], "external": false}; window.dfnpanelData['dictdef-writeparams'] = {"dfnID": "dictdef-writeparams", "url": "#dictdef-writeparams", "dfnText": "WriteParams", "refSections": [{"refs": [{"id": "ref-for-dictdef-writeparams"}, {"id": "ref-for-dictdef-writeparams\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['dom-writeparams-type'] = {"dfnID": "dom-writeparams-type", "url": "#dom-writeparams-type", "dfnText": "type", "refSections": [{"refs": [{"id": "ref-for-dom-writeparams-type"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writeparams-type\u2460"}, {"id": "ref-for-dom-writeparams-type\u2461"}, {"id": "ref-for-dom-writeparams-type\u2462"}, {"id": "ref-for-dom-writeparams-type\u2463"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writeparams-type\u2464"}], "title": "2.5.2. The seek() method"}, {"refs": [{"id": "ref-for-dom-writeparams-type\u2465"}], "title": "2.5.3. The truncate() method"}], "external": false}; window.dfnpanelData['dom-writeparams-size'] = {"dfnID": "dom-writeparams-size", "url": "#dom-writeparams-size", "dfnText": "size", "refSections": [{"refs": [{"id": "ref-for-dom-writeparams-size"}, {"id": "ref-for-dom-writeparams-size\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writeparams-size\u2461"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writeparams-size\u2462"}], "title": "2.5.3. The truncate() method"}], "external": false}; window.dfnpanelData['dom-writeparams-position'] = {"dfnID": "dom-writeparams-position", "url": "#dom-writeparams-position", "dfnText": "position", "refSections": [{"refs": [{"id": "ref-for-dom-writeparams-position"}, {"id": "ref-for-dom-writeparams-position\u2460"}, {"id": "ref-for-dom-writeparams-position\u2461"}, {"id": "ref-for-dom-writeparams-position\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writeparams-position\u2463"}, {"id": "ref-for-dom-writeparams-position\u2464"}], "title": "2.5.1. The write() method"}, {"refs": [{"id": "ref-for-dom-writeparams-position\u2465"}], "title": "2.5.2. The seek() method"}], "external": false}; window.dfnpanelData['dom-writeparams-data'] = {"dfnID": "dom-writeparams-data", "url": "#dom-writeparams-data", "dfnText": "data", "refSections": [{"refs": [{"id": "ref-for-dom-writeparams-data"}, {"id": "ref-for-dom-writeparams-data\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-writeparams-data\u2461"}, {"id": "ref-for-dom-writeparams-data\u2462"}], "title": "2.5.1. The write() method"}], "external": false}; window.dfnpanelData['typedefdef-filesystemwritechunktype'] = {"dfnID": "typedefdef-filesystemwritechunktype", "url": "#typedefdef-filesystemwritechunktype", "dfnText": "FileSystemWriteChunkType", "refSections": [{"refs": [{"id": "ref-for-typedefdef-filesystemwritechunktype"}, {"id": "ref-for-typedefdef-filesystemwritechunktype\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['filesystemwritablefilestream'] = {"dfnID": "filesystemwritablefilestream", "url": "#filesystemwritablefilestream", "dfnText": "FileSystemWritableFileStream", "refSections": [{"refs": [{"id": "ref-for-filesystemwritablefilestream"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-filesystemwritablefilestream\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-filesystemwritablefilestream\u2461"}, {"id": "ref-for-filesystemwritablefilestream\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-filesystemwritablefilestream\u2463"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-filesystemwritablefilestream\u2464"}, {"id": "ref-for-filesystemwritablefilestream\u2465"}, {"id": "ref-for-filesystemwritablefilestream\u2466"}, {"id": "ref-for-filesystemwritablefilestream\u2467"}, {"id": "ref-for-filesystemwritablefilestream\u2468"}, {"id": "ref-for-filesystemwritablefilestream\u2460\u24ea"}, {"id": "ref-for-filesystemwritablefilestream\u2460\u2460"}, {"id": "ref-for-filesystemwritablefilestream\u2460\u2461"}, {"id": "ref-for-filesystemwritablefilestream\u2460\u2462"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['filesystemwritablefilestream-file'] = {"dfnID": "filesystemwritablefilestream-file", "url": "#filesystemwritablefilestream-file", "dfnText": "[[file]]", "refSections": [{"refs": [{"id": "ref-for-filesystemwritablefilestream-file"}, {"id": "ref-for-filesystemwritablefilestream-file\u2460"}, {"id": "ref-for-filesystemwritablefilestream-file\u2461"}, {"id": "ref-for-filesystemwritablefilestream-file\u2462"}, {"id": "ref-for-filesystemwritablefilestream-file\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['filesystemwritablefilestream-buffer'] = {"dfnID": "filesystemwritablefilestream-buffer", "url": "#filesystemwritablefilestream-buffer", "dfnText": "[[buffer]]", "refSections": [{"refs": [{"id": "ref-for-filesystemwritablefilestream-buffer"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-filesystemwritablefilestream-buffer\u2460"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2461"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2462"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2463"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2464"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2465"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2466"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2467"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2468"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2460\u24ea"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2460\u2460"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2460\u2461"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2460\u2462"}, {"id": "ref-for-filesystemwritablefilestream-buffer\u2460\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['filesystemwritablefilestream-seekoffset'] = {"dfnID": "filesystemwritablefilestream-seekoffset", "url": "#filesystemwritablefilestream-seekoffset", "dfnText": "[[seekOffset]]", "refSections": [{"refs": [{"id": "ref-for-filesystemwritablefilestream-seekoffset"}, {"id": "ref-for-filesystemwritablefilestream-seekoffset\u2460"}, {"id": "ref-for-filesystemwritablefilestream-seekoffset\u2461"}, {"id": "ref-for-filesystemwritablefilestream-seekoffset\u2462"}, {"id": "ref-for-filesystemwritablefilestream-seekoffset\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['create-a-new-filesystemwritablefilestream'] = {"dfnID": "create-a-new-filesystemwritablefilestream", "url": "#create-a-new-filesystemwritablefilestream", "dfnText": "create a new FileSystemWritableFileStream", "refSections": [{"refs": [{"id": "ref-for-create-a-new-filesystemwritablefilestream"}], "title": "2.3.2. The createWritable() method"}], "external": false}; window.dfnpanelData['write-a-chunk'] = {"dfnID": "write-a-chunk", "url": "#write-a-chunk", "dfnText": "write a chunk", "refSections": [{"refs": [{"id": "ref-for-write-a-chunk"}], "title": "2.5. The FileSystemWritableFileStream interface"}], "external": false}; window.dfnpanelData['dom-filesystemwritablefilestream-write'] = {"dfnID": "dom-filesystemwritablefilestream-write", "url": "#dom-filesystemwritablefilestream-write", "dfnText": "write(data)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-write"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2460"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-write\u2461"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2462"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2463"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2464"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2465"}, {"id": "ref-for-dom-filesystemwritablefilestream-write\u2466"}], "title": "2.5.1. The write() method"}], "external": false}; window.dfnpanelData['dom-filesystemwritablefilestream-seek'] = {"dfnID": "dom-filesystemwritablefilestream-seek", "url": "#dom-filesystemwritablefilestream-seek", "dfnText": "seek(position)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-seek"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-seek\u2460"}, {"id": "ref-for-dom-filesystemwritablefilestream-seek\u2461"}], "title": "2.5.2. The seek() method"}], "external": false}; window.dfnpanelData['dom-filesystemwritablefilestream-truncate'] = {"dfnID": "dom-filesystemwritablefilestream-truncate", "url": "#dom-filesystemwritablefilestream-truncate", "dfnText": "truncate(size)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-truncate"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-dom-filesystemwritablefilestream-truncate\u2460"}, {"id": "ref-for-dom-filesystemwritablefilestream-truncate\u2461"}], "title": "2.5.3. The truncate() method"}], "external": false}; window.dfnpanelData['dictdef-filesystemreadwriteoptions'] = {"dfnID": "dictdef-filesystemreadwriteoptions", "url": "#dictdef-filesystemreadwriteoptions", "dfnText": "FileSystemReadWriteOptions", "refSections": [{"refs": [{"id": "ref-for-dictdef-filesystemreadwriteoptions"}, {"id": "ref-for-dictdef-filesystemreadwriteoptions\u2460"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-dictdef-filesystemreadwriteoptions\u2461"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-dictdef-filesystemreadwriteoptions\u2462"}], "title": "2.6.2. The write() method"}], "external": false}; window.dfnpanelData['dom-filesystemreadwriteoptions-at'] = {"dfnID": "dom-filesystemreadwriteoptions-at", "url": "#dom-filesystemreadwriteoptions-at", "dfnText": "at", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemreadwriteoptions-at"}, {"id": "ref-for-dom-filesystemreadwriteoptions-at\u2460"}, {"id": "ref-for-dom-filesystemreadwriteoptions-at\u2461"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-dom-filesystemreadwriteoptions-at\u2462"}, {"id": "ref-for-dom-filesystemreadwriteoptions-at\u2463"}, {"id": "ref-for-dom-filesystemreadwriteoptions-at\u2464"}], "title": "2.6.2. The write() method"}], "external": false}; window.dfnpanelData['filesystemsyncaccesshandle'] = {"dfnID": "filesystemsyncaccesshandle", "url": "#filesystemsyncaccesshandle", "dfnText": "FileSystemSyncAccessHandle", "refSections": [{"refs": [{"id": "ref-for-filesystemsyncaccesshandle"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle\u2460"}], "title": "2.3. The FileSystemFileHandle interface"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle\u2461"}, {"id": "ref-for-filesystemsyncaccesshandle\u2462"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle\u2463"}, {"id": "ref-for-filesystemsyncaccesshandle\u2464"}, {"id": "ref-for-filesystemsyncaccesshandle\u2465"}, {"id": "ref-for-filesystemsyncaccesshandle\u2466"}], "title": "2.3.3. The createSyncAccessHandle() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle\u2467"}, {"id": "ref-for-filesystemsyncaccesshandle\u2468"}, {"id": "ref-for-filesystemsyncaccesshandle\u2460\u24ea"}, {"id": "ref-for-filesystemsyncaccesshandle\u2460\u2460"}, {"id": "ref-for-filesystemsyncaccesshandle\u2460\u2461"}, {"id": "ref-for-filesystemsyncaccesshandle\u2460\u2462"}, {"id": "ref-for-filesystemsyncaccesshandle\u2460\u2463"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-read'] = {"dfnID": "dom-filesystemsyncaccesshandle-read", "url": "#dom-filesystemsyncaccesshandle-read", "dfnText": "read", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-read"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-read\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-read\u2461"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-read\u2462"}], "title": "2.6.1. The read() method"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-write'] = {"dfnID": "dom-filesystemsyncaccesshandle-write", "url": "#dom-filesystemsyncaccesshandle-write", "dfnText": "write", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-write"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-write\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-write\u2461"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-write\u2462"}], "title": "2.6.5. The flush() method"}], "external": false}; window.dfnpanelData['filesystemsyncaccesshandle-file'] = {"dfnID": "filesystemsyncaccesshandle-file", "url": "#filesystemsyncaccesshandle-file", "dfnText": "[[file]]", "refSections": [{"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file\u2460"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file\u2461"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2462"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2463"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file\u2464"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2465"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2466"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2467"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2468"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2460\u24ea"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file\u2460\u2460"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file\u2460\u2461"}, {"id": "ref-for-filesystemsyncaccesshandle-file\u2460\u2462"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['filesystemsyncaccesshandle-state'] = {"dfnID": "filesystemsyncaccesshandle-state", "url": "#filesystemsyncaccesshandle-state", "dfnText": "[[state]]", "refSections": [{"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2460"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2461"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2462"}], "title": "2.6.3. The truncate() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2463"}], "title": "2.6.4. The getSize() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2464"}], "title": "2.6.5. The flush() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-state\u2465"}, {"id": "ref-for-filesystemsyncaccesshandle-state\u2466"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['filesystemsyncaccesshandle-file-position-cursor'] = {"dfnID": "filesystemsyncaccesshandle-file-position-cursor", "url": "#filesystemsyncaccesshandle-file-position-cursor", "dfnText": "file position cursor", "refSections": [{"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor"}, {"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2460"}, {"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2461"}], "title": "2.6.1. The read() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2462"}, {"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2463"}, {"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2464"}], "title": "2.6.2. The write() method"}, {"refs": [{"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2465"}, {"id": "ref-for-filesystemsyncaccesshandle-file-position-cursor\u2466"}], "title": "2.6.3. The truncate() method"}], "external": false}; window.dfnpanelData['create-a-new-filesystemsyncaccesshandle'] = {"dfnID": "create-a-new-filesystemsyncaccesshandle", "url": "#create-a-new-filesystemsyncaccesshandle", "dfnText": "create a new FileSystemSyncAccessHandle", "refSections": [{"refs": [{"id": "ref-for-create-a-new-filesystemsyncaccesshandle"}], "title": "2.3.3. The createSyncAccessHandle() method"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-truncate'] = {"dfnID": "dom-filesystemsyncaccesshandle-truncate", "url": "#dom-filesystemsyncaccesshandle-truncate", "dfnText": "truncate(newSize)", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-truncate"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-truncate\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-truncate\u2461"}], "title": "2.6.3. The truncate() method"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-getsize'] = {"dfnID": "dom-filesystemsyncaccesshandle-getsize", "url": "#dom-filesystemsyncaccesshandle-getsize", "dfnText": "getSize()", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-getsize"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-getsize\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-getsize\u2461"}], "title": "2.6.4. The getSize() method"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-flush'] = {"dfnID": "dom-filesystemsyncaccesshandle-flush", "url": "#dom-filesystemsyncaccesshandle-flush", "dfnText": "flush()", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-flush"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-flush\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-flush\u2461"}], "title": "2.6.5. The flush() method"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-flush\u2462"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['dom-filesystemsyncaccesshandle-close'] = {"dfnID": "dom-filesystemsyncaccesshandle-close", "url": "#dom-filesystemsyncaccesshandle-close", "dfnText": "close()", "refSections": [{"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-close"}], "title": "2.6. The FileSystemSyncAccessHandle interface"}, {"refs": [{"id": "ref-for-dom-filesystemsyncaccesshandle-close\u2460"}, {"id": "ref-for-dom-filesystemsyncaccesshandle-close\u2461"}], "title": "2.6.6. The close() method"}], "external": false}; window.dfnpanelData['origin-private-file-system'] = {"dfnID": "origin-private-file-system", "url": "#origin-private-file-system", "dfnText": "bucket file system", "refSections": [{"refs": [{"id": "ref-for-origin-private-file-system"}], "title": "2.1. Concepts"}, {"refs": [{"id": "ref-for-origin-private-file-system\u2460"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-origin-private-file-system\u2461"}], "title": "2.3.2. The createWritable() method"}, {"refs": [{"id": "ref-for-origin-private-file-system\u2462"}, {"id": "ref-for-origin-private-file-system\u2463"}], "title": "2.5. The FileSystemWritableFileStream interface"}, {"refs": [{"id": "ref-for-origin-private-file-system\u2464"}, {"id": "ref-for-origin-private-file-system\u2465"}, {"id": "ref-for-origin-private-file-system\u2466"}], "title": "3. Accessing the Bucket File System"}], "external": false}; window.dfnpanelData['dom-storagemanager-getdirectory'] = {"dfnID": "dom-storagemanager-getdirectory", "url": "#dom-storagemanager-getdirectory", "dfnText": "getDirectory()", "refSections": [{"refs": [{"id": "ref-for-dom-storagemanager-getdirectory"}], "title": "1. Introduction"}, {"refs": [{"id": "ref-for-dom-storagemanager-getdirectory\u2460"}], "title": "2.2. The FileSystemHandle interface"}, {"refs": [{"id": "ref-for-dom-storagemanager-getdirectory\u2461"}, {"id": "ref-for-dom-storagemanager-getdirectory\u2462"}], "title": "3. Accessing the Bucket File System"}], "external": false}; /* Boilerplate: script-dom-helper */ function query(sel) { return document.querySelector(sel); } function queryAll(sel) { return [...document.querySelectorAll(sel)]; } function iter(obj) { if(!obj) return []; var it = obj[Symbol.iterator]; if(it) return it; return Object.entries(obj); } function mk(tagname, attrs, ...children) { const el = document.createElement(tagname); for(const [k,v] of iter(attrs)) { if(k.slice(0,3) == "_on") { const eventName = k.slice(3); el.addEventListener(eventName, v); } else if(k[0] == "_") { // property, not attribute el[k.slice(1)] = v; } else { if(v === false || v == null) { continue; } else if(v === true) { el.setAttribute(k, ""); continue; } else { el.setAttribute(k, v); } } } append(el, children); return el; } /* Create shortcuts for every known HTML element */ [ "a", "abbr", "acronym", "address", "applet", "area", "article", "aside", "audio", "b", "base", "basefont", "bdo", "big", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "font", "footer", "form", "frame", "frameset", "head", "header", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "link", "main", "map", "mark", "meta", "meter", "nav", "nobr", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "pre", "progress", "q", "s", "samp", "script", "section", "select", "small", "source", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "u", "ul", "var", "video", "wbr", "xmp", ].forEach(tagname=> { mk[tagname] = (...args) => mk(tagname, ...args); }); function* nodesFromChildList(children) { for(const child of children.flat(Infinity)) { if(child instanceof Node) { yield child; } else { yield new Text(child); } } } function append(el, ...children) { for(const child of nodesFromChildList(children)) { if(el instanceof Node) el.appendChild(child); else el.push(child); } return el; } function insertAfter(el, ...children) { for(const child of nodesFromChildList(children)) { el.parentNode.insertBefore(child, el.nextSibling); } return el; } function clearContents(el) { el.innerHTML = ""; return el; } function parseHTML(markup) { if(markup.toLowerCase().trim().indexOf(' /* Boilerplate: script-var-click-highlighting */ /* Color-choosing design: Colors are ordered by goodness. Each color has a usage count (initially zero). Each variable has a last-used color. * If the var has a last-used color, and that color's usage is 0, return that color. * Otherwise, return the lowest-indexed color with the lowest usage. Increment the color's usage and set it as the last-used color for that var. * On unclicking, decrement usage of the color. */ "use strict"; { document.addEventListener("click", e=> { if(e.target.nodeName == "VAR") { highlightSameAlgoVars(e.target); } }); const indexCounts = new Map(); const indexNames = new Map(); function highlightSameAlgoVars(v) { // Find the algorithm container. let algoContainer = null; let searchEl = v; while(algoContainer == null && searchEl != document.body) { searchEl = searchEl.parentNode; if(searchEl.hasAttribute("data-algorithm")) { algoContainer = searchEl; } } // Not highlighting document-global vars, // too likely to be unrelated. if(algoContainer == null) return; const algoName = algoContainer.getAttribute("data-algorithm"); const varName = getVarName(v); const addClass = !v.classList.contains("selected"); let highlightClass = null; if(addClass) { const index = chooseHighlightIndex(algoName, varName); indexCounts.get(algoName)[index] += 1; indexNames.set(algoName+"///"+varName, index); highlightClass = nameFromIndex(index); } else { const index = previousHighlightIndex(algoName, varName); indexCounts.get(algoName)[index] -= 1; highlightClass = nameFromIndex(index); } // Find all same-name vars, and toggle their class appropriately. for(const el of algoContainer.querySelectorAll("var")) { if(getVarName(el) == varName) { el.classList.toggle("selected", addClass); el.classList.toggle(highlightClass, addClass); } } } function getVarName(el) { return el.textContent.replace(/(\s|\xa0)+/, " ").trim(); } function chooseHighlightIndex(algoName, varName) { let indexes = null; if(indexCounts.has(algoName)) { indexes = indexCounts.get(algoName); } else { // 7 classes right now indexes = [0,0,0,0,0,0,0]; indexCounts.set(algoName, indexes); } // If the element was recently unclicked, // *and* that color is still unclaimed, // give it back the same color. const lastIndex = previousHighlightIndex(algoName, varName); if(indexes[lastIndex] === 0) return lastIndex; // Find the earliest index with the lowest count. const minCount = Math.min.apply(null, indexes); let index = null; for(var i = 0; i