Search completed in 1.37 seconds.
DeferredTask.jsm
the
deferredtask.jsm javascript code module offers utility routines for a task that will run after a delay.
...to use it, you first need to import the code module into your javascript scope: components.utils.import("resource://gre/modules/
deferredtask.jsm"); use this, for instance, if you write data to a file and you expect that you may have to rewrite data very soon afterwards.
... with
deferredtask, the task is delayed by a few milliseconds and, should a new change to the data occur during this period, only the final version of the data is actually written; a further grace delay is added to take into account other changes.
...And 7 more matches
Deferred
a
deferred object is returned by the obsolete promise.
defer() method to provide a new promise along with methods to change its state.
...use the new promise() constructor instead (or use the above backwards/forwards compatible
deferred function given below).
... for example, the equivalent of var
deferred = promise.
defer(); dosomething(function cb(good) { if (good)
deferred.resolve(); else
deferred.reject(); }); return
deferred.promise; would be return new promise(function(resolve, reject) { dosomething(function cb(good) { if (good) resolve(); else reject(); }); }); method overview void resolve([optional] avalue); void reject([optional] areason); properties attribute type description promise read only promise a newly created promise, initially in the pending state.
...And 6 more matches
Deferred
a
deferred object is returned by the promiseutils.
defer() method to provide a new promise along with methods to change its state.
What is JavaScript? - Learn web development
replace your current <script> element with the following: <script src="script.js"
defer></script> inside script.js, add the following script: function createparagraph() { let para = document.createelement('p'); para.textcontent = 'you clicked the button!'; document.body.appendchild(para); } const buttons = document.queryselectorall('button'); for(let i = 0; i < buttons.length ; i++) { buttons[i].addeventlistener('click', createparagraph); } save and refresh your br...
... in the external example, we use a more modern javascript feature to solve the problem, the
defer attribute, which tells the browser to continue downloading the html content once the <script> tag element has been reached.
... <script src="script.js"
defer></script> in this case both the script and the html will load simultaneously and the code will work.
...And 6 more matches
Examples
function promisevalueaftertimeout(avalue, atimeout) { let
deferred = promise.
defer(); try { // an asynchronous operation will trigger the resolution of the promise.
... settimeout(function () {
deferred.resolve('rawr my success value'); }, atimeout); } catch (ex) { // generally, functions returning promises propagate exceptions through // the returned promise, though they may also choose to fail early.
...
deferred.reject(ex); } // we don't return the
deferred to the caller, but only the contained // promise, so that the caller cannot accidentally change its state.
...And 5 more matches
<script>: The Script element - HTML: Hypertext Markup Language
for module scripts, if the async attribute is present then the scripts and all their dependencies will be executed in the
defer queue, therefore they will get fetched in parallel to parsing and evaluated as soon as they are available.
...
defer has a similar effect in this case.
...
defer this boolean attribute is set to indicate to a browser that the script is meant to be executed after the document has been parsed, but before firing domcontentloaded.
...And 5 more matches
core/promise - Archive of obsolete content
defer module exports
defer function, which is where all promises ultimately come from.
... lets see the implementation of readasync that we used in several of the examples above: const {
defer } = require('sdk/core/promise'); function readasync(url) { var
deferred =
defer(); let xhr = new xmlhttprequest(); xhr.open("get", url, true); xhr.onload = function() {
deferred.resolve(xhr.responsetext); }; xhr.onerror = function(event) {
deferred.reject(event); }; xhr.send(); return
deferred.promise; } so
defer returns an object that contains a promise and two resolve, reject functions that can be used to resolve / reject that promise.
... another simple example may be a delay function that returns a promise which is fulfilled with a given value after a given time ms -- kind of promise based alternative to settimeout: function delay(ms, value) { let { promise, resolve } =
defer(); settimeout(resolve, ms, value); return promise; } delay(10, 'hello world').then(console.log); // after 10ms => 'helo world' advanced usage if general
defer and promised should be enough to doing almost anything you may think of with promises, but once you start using promises extensively you may discover some missing pieces and this section of documentation may help you to discover them.
...And 4 more matches
Add to Home screen - Progressive web apps (PWAs)
first of all, we declare a
deferredprompt variable (which we'll explain later on), get a reference to our install button, and set it to display: none initially: let
deferredprompt; const addbtn = document.queryselector('.add-button'); addbtn.style.display = 'none'; we hide the button initially because the pwa will not be available for install until it follows the a2hs criteria.
...
deferredprompt = e; // update ui to notify the user they can add to home screen addbtn.style.display = 'block'; addbtn.addeventlistener('click', (e) => { // hide our user interface that shows our a2hs button addbtn.style.display = 'none'; // show the prompt
deferredprompt.prompt(); // wait for the user to respond to the prompt
deferredprompt.userchoice.then((choiceresult) => { if (choiceresult.outcome === ...
...'accepted') { console.log('user accepted the a2hs prompt'); } else { console.log('user dismissed the a2hs prompt'); }
deferredprompt = null; }); }); }); so here we: call event.preventdefault() to stop chrome 67 and earlier from calling the install prompt automatically (this behavior changed in chrome 68).
...And 3 more matches
PromiseUtils.jsm
to use it, you first need to import the code module into your javascript scope: components.utils.import("resource://gre/modules/promiseutils.jsm"); method overview
deferred
defer(); methods
defer() creates a new pending promise and provides methods to resolve or reject this promise.
... this method was previously implemented as promise.
defer(), which is obsolete since gecko 30.
... and promiseutils.
defer uses dom promise instead of promise.jsm's promise.
...And 2 more matches
HTMLScriptElement - Web APIs
htmlscriptelement.async htmlscriptelement.
defer the async and
defer attributes are boolean attributes that control how the script should be executed.
... the
defer and async attributes must not be specified if the src attribute is absent.
... if the async attribute is absent but the
defer attribute is present, then the script is executed when the page has finished parsing.
...And 2 more matches
lang/functional - Archive of obsolete content
defer(fn) takes a function and returns a wrapped version of the function.
... let {
defer } = require("sdk/lang/functional"); let fn =
defer(function myevent (event, value) { console.log(event + " : " + value); }); fn("click", "#home"); console.log("done"); // this will print 'done' before 'click : #home' since // we
deferred the execution of the wrapped `myevent` // function, making it non-blocking and executing on the // next event loop parameters fn : function the function to be
deferred.
... returns function : the new,
deferred function.
... remit() an alias for
defer.
MMgc - Archive of obsolete content
class mymanagedclass : public mmgc::gcobject { // mymanagedclass is a gcobject, and // avmplus::hashtable is a gcobject, so use dwb dwb(avmplus::hashtable*) mytable; }; drc drc stands for
deferred reference counted.
...class myunmanagedclass { // myunmanagedclass is not a gcobject, and // avmplus::stringp is a rcobject, so use drc drc(stringp) mystring; }; drcwb drcwb stands for
deferred reference counted, with write barrier.
...
deferred reference counting (drc) mmgc uses
deferred reference counting (drc).
...enter
deferred reference counting in
deferred reference counting, a distinction is made between heap and stack references.
Promise.jsm
if you need a
deferred, because you want to create a promise and manually resolve or reject it, consider using promiseutils.jsm instead.
... method overview
deferred
defer(); obsolete since gecko 30 promise resolve([optional] avalue); promise reject([optional] areason); methods
defer() creates a new pending promise and provides methods to resolve or reject it.
...
deferred
defer(); obsolete since gecko 30 parameters none.
...see the
deferred documentation for details.
Tracing JIT
this is the same as normal recording mode, except that the outermost recorder is placed on a
deferred-abort stack.
... when the innermost recorder completes -- successfully or otherwise -- every recorder on the
deferred abort stack is aborted.
...write flushing is necessary because all writes to imported values in the native stack are
deferred until trace-exit, as an optimization.
...a deep bail is special only insofar as it requires flushing the full set of
deferred writes in the trace if it occurs (and further, requires that all registers holding temporary trace operands have flushed to the native stack before execution).
mozIStorageConnection
constant value description transaction_
deferred 0 no database lock is obtained until the first statement is run.
... begintransaction() starts a new transaction
deferred transaction.
... this is the same as calling mozistorageconnection with mozistorageconnection.transaction_
deferred.
... void begintransactionas( in print32 transactiontype ); parameters transactiontype one of the transaction constants (mozistorageconnection.transaction_
deferred, mozistorageconnection.transaction_immediate, mozistorageconnection.transaction_exclusive) clone() clones a database connection, optionally making the new connection read only.
Sqlite.jsm
valid values are transaction_
deferred, transaction_immediate, transaction_exclusive.
...the default is transaction_
deferred.
... conn.executetransaction(async function simpletransaction() { await conn.execute("insert into mytable values (?, ?)", ["foo", "bar"]); await conn.execute("insert into mytable values (?, ?)", ["biz", "baz"]); }); the above will result in 2 insert statements being committed in a
deferred transaction (assuming the inserts proceed without error, of course).
Populating the page: how browsers work - Web Performance
parsing can continue when a css file is encountered, but <script> tags—particularly those without an async or
defer attribute—block rendering, and pause the parsing of html.
...to ensure the script doesn't block the process, add the async attribute, or the
defer attribute if javascript parsing and execution order is not important.
...if the load includes javascript, that was correctly
deferred, and only executed after the onload event fires, the main thread might be busy, and not available for scrolling, touch, and other interactions.
Performance best practices in extensions - Archive of obsolete content
code should be modularized to the extent that doing so increases clarity, and loading of large or expensive chunks of code fragments can be significantly
deferred.
...
defer everything that you can most extensions have a load event listener in the main overlay that runs their startup functions.
Promises - Archive of obsolete content
components.utils.import("resource://gre/modules/
deferredsave.jsm"); /** * handles the asynchronous reading and writing of add-on-specific json * data files.
... this.saver = new
deferredsave(this.path, () => json.stringify(this.data), 1000); return this; }.bind(this)); } /** * immediately save the data to disk.
What’s in the head? Metadata in HTML - Learn web development
this takes two attributes, rel="stylesheet", which indicates that it is the document's stylesheet, and href, which contains the path to the stylesheet file: <link rel="stylesheet" href="my-css-file.css"> the <script> element should also go into the head, and should include a src attribute containing the path to the javascript you want to load, and
defer, which basically instructs the browser to load the javascript at the same time as the page's html.
... <script src="my-js-file.js"
defer></script> note: the <script> element may look like an empty element, but it's not, and so needs a closing tag.
HTML parser threading
(only the already executed ops are destructed and the rest are left in the queue.) the last op in the queue may be an op for attempting to execute a script that may block the parser (ops for attempting to execute async and
defer scripts are normal tree ops and don't need to be the last op in a queue).
...preparing the parser thread for script execution when the parser thread sees that it has generated a tree op that attempts to execute a (non-async, non-
defer) script, it starts speculating.
FileUtils.jsm
the stream is opened with the
defer_open nsifileoutputstream.behavior flag constant this means the file is not actually opened until the first time it's accessed.
... remarks note: starting in gecko 6 the stream is opened with the
defer_open nsifileoutputstream behavior flag constant; this means the file is not actually opened until the first time it's accessed.
nsIFileOutputStream
inherits from: nsioutputstream last changed in gecko 1.7 method overview void init(in nsifile file, in long ioflags, in long perm, in long behaviorflags); constants behavior flag constants constant value description
defer_open 1<<0 see the same constant in nsifileinputstream.
... the
deferred open will be performed when one of the following is called: seek() tell() write() flush()
defer_open is useful if we use the stream on a background thread, so that the opening and possible stating of the file happens there as well.
nsITraceableChannel
holds chunks as they come, onstoprequest we join these junks to get the full source this.responsebody; // we'll set this to the this.responsestatuscode; this.
deferreddone = { promise: null, resolve: null, reject: null }; this.
deferreddone.promise = new promise(function(resolve, reject) { this.resolve = resolve; this.reject = reject; }.bind(this.
deferreddone)); object.freeze(this.
deferreddone); this.promisedone = this.
deferreddone.promise; } tracinglistener.prototype = { ondataavailable: function(arequest, acontext, ainputstream, aoffset, aco...
...am(0), aoffset, acount); }, onstartrequest: function(arequest, acontext) { this.originallistener.onstartrequest(arequest, acontext); }, onstoprequest: function(arequest, acontext, astatuscode) { this.responsebody = this.receivedchunks.join(""); delete this.receivedchunks; this.responsestatus = astatuscode; this.originallistener.onstoprequest(arequest, acontext, astatuscode); this.
deferreddone.resolve(); }, queryinterface: function(aiid) { if (aiid.equals(ci.nsistreamlistener) || aiid.equals(ci.nsisupports)) { return this; } throw cr.ns_nointerface; } }; var httpresponseobserver = { observe: function(asubject, atopic, adata) { var newlistener = new tracinglistener(); asubject.queryinterface(ci.nsitraceablechannel); newlistener.originallistener = asubject.setn...
Index - Web APIs
the notification provides read-only access to many properties that were set at the instantiation time of the notification such as tag and data attributes that allow you to store information for
defered use in the notificationclick event.
... 4567 webgl_draw_buffers api, reference, webgl, webgl extension the webgl_draw_buffers extension is part of the webgl api and enables a fragment shader to write to several textures, which is useful for
deferred shading, for example.
WindowOrWorkerGlobalScope.setTimeout() - Web APIs
deferral of timeouts during pageload starting in firefox 66, firefox will
defer firing settimeout and setinterval timers while the current tab is loading.
... firing is
deferred until the mainthread is deemed idle (similar to window.requestidlecallback()), or until the load event is fired.
At-rules - CSS: Cascading Style Sheets
(
deferred to level 4 of css spec) @page — describes the aspect of layout changes that will be applied when printing the document.
...(
deferred to level 4 of css spec) since each conditional group may also contain nested statements, there may be an unspecified amount of nesting.
HTML5 Parser - Developer guides
in html5, document.write() can only be called from a script that is created by a <script> tag that does not have the async or
defer attributes set.
... some contexts from which you should not call document.write() include: scripts created using document.createelement() event handlers settimeout() setinterval() <script async src="..."> <script
defer src="..."> if you use the same mechanism for loading script libraries for all browsers including ie, then your code probably will not be affected by this change.
Preloading content with rel="preload" - HTML: Hypertext Markup Language
a simple example might look like this (see our js and css example source, and also live): <head> <meta charset="utf-8"> <title>js and css preload example</title> <link rel="preload" href="style.css" as="style"> <link rel="preload" href="main.js" as="script"> <link rel="stylesheet" href="style.css"> </head> <body> <h1>bouncing balls</h1> <canvas></canvas> <script src="main.js"
defer></script> </body> here we preload our css and javascript files so they will be available as soon as they are required for the rendering of the page later on.
...to use it, you could do this: var preloadedscript = document.createelement("script"); preloadedscript.src = "myscript.js"; document.body.appendchild(preloadedscript); this is useful when you want to preload a script, but then
defer execution until exactly when you need it.
await - JavaScript
an await can split execution flow, allowing the caller of the await's function to resume execution before the
deferred continuation of the await's function.
... after the await
defers the continuation of its function, if this is the first await executed by the function, immediate execution also continues by returning to the function's caller a pending promise for the completion of the await's function and resuming execution of that caller.
Critical rendering path - Web Performance
there are other ways to optimize css, such as minification, and separating
defered css into non-blocking requests by using media queries.
...performance tips include 1) minimizing the number of critical resources by
deferring their download, marking them as async, or eliminating them altogether, 2) optimizing the number of requests required along with the file size of each request, and 3) optimizing the order in which critical resources are loaded by prioritizing the downloading critical assets, shorten the critical path length.
Lazy loading - Web Performance
entry point splitting: separates code by entry point(s) in the app dynamic splitting: separates code where dynamic import() statements are used javascript script type module any script tag with type="module" is treated like a javascript module and is
deferred by default.
... loading attribute the loading attribute on an <img> element (or the loading attribute on an <iframe>) can be used to instruct the browser to
defer loading of images/iframes that are off-screen until the user scrolls near them.
Progressive loading - Progressive web apps (PWAs)
this is all about
deferring loading of as many resources as possible (html, css, javascript), and only loading those immediately that are really needed for the very first experience.
... to fix that we can, for example, add
defer to javascript files: <script src="app.js"
defer></script> they will be downloaded and executed after the document itself has been parsed, so it won't block rendering the html structure.
JavaScript Client API - Archive of obsolete content
lection, id); } foorecord.prototype = { __proto__: cryptowrapper.prototype, _logname: "record.foo", ttl: foo_ttl, // optional get bar() this.cleartext.bar, set bar(value) { this.cleartext.bar = value; }, get baz() this.cleartext.baz, set baz(value) { this.cleartext.baz = value; } }; to save all that typing for declaring the getters and setters, you can also use utils.
defergetset: function foorecord(collection, id) { cryptowrapper.call(this, collection, id); } foorecord.prototype = { __proto__: cryptowrapper.prototype, _logname: "record.foo", ttl: foo_ttl // optional }; utils.
defergetset(foorec, "cleartext", ["bar", "baz"]); the store object the store object (which extends store, as defined in services/sync/modules/engines.js) has the job of creating an...
jspage - Archive of obsolete content
(o,r); }q.push(o);}o=o[l];}return(p)?new elements(q,{ddup:false,cash:!r}):null;};var e={html:"innerhtml","class":"classname","for":"htmlfor",defaultvalue:"defaultvalue",text:(browser.engine.trident||(browser.engine.webkit&&browser.engine.version<420))?"innertext":"textcontent"}; var b=["compact","nowrap","ismap","declare","noshade","checked","disabled","readonly","multiple","selected","noresize","
defer"];var k=["value","type","defaultvalue","accesskey","cellpadding","cellspacing","colspan","frameborder","maxlength","readonly","rowspan","tabindex","usemap"]; b=b.associate(b);hash.extend(e,b);hash.extend(e,k.associate(k.map(string.tolowercase)));var a={before:function(m,l){if(l.parentnode){l.parentnode.insertbefore(m,l); }},after:function(m,l){if(!l.parentnode){return;}var n=l.nextsibling;(n)?l.p...
Index - Learn web development
53 graceful asynchronous programming with promises beginner, codingscripting, guide, javascript, learn, promises, async, asynchronous, catch, finally, then promises are a comparatively new feature of the javascript language that allow you to
defer further actions until after a previous action has completed, or respond to its failure.
Asynchronous JavaScript - Learn web development
handling async operations gracefully with promises promises are a comparatively new feature of the javascript language that allow you to
defer further actions until after the previous action has completed, or respond to its failure.
Client-side storage - Learn web development
note: in the line <script src="index.js"
defer></script> of the source for our finished version, the
defer attribute specifies that the contents of the <script> element will not execute until the page has finished loading.
HTML performance features - Learn web development
elements & attributes impacting performance the <picture> element the <video> element the <source> element the <img> srcset attribute responsive images preloading content with rel="preload" - (https://w3c.github.io/preload/ ) async /
defer attributes <iframe> <object> <script> rel attribute conclusion previous overview: performance next in this module the "why" of web performance what is web performance?
Deployment and next steps - Learn web development
to do this, we just remove the leading slashes (/) from the /global.css, /build/bundle.css, and /build/bundle.js urls, like this: <title>svelte to-do list</title> <link rel='icon' type='image/png' href='favicon.png'> <link rel='stylesheet' href='global.css'> <link rel='stylesheet' href='build/bundle.css'> <script
defer src='build/bundle.js'></script> do this now.
Getting started with Svelte - Learn web development
lic/index.html includes the generated bundle.css and bundle.js files: <!doctype html> <html lang="en"> <head> <meta charset='utf-8'> <meta name='viewport' content='width=device-width,initial-scale=1'> <title>svelte app</title> <link rel='icon' type='image/png' href='/favicon.png'> <link rel='stylesheet' href='/global.css'> <link rel='stylesheet' href='/build/bundle.css'> <script
defer src='/build/bundle.js'></script> </head> <body> </body> </html> the minified version of bundle.js weighs a little more than 3kb, which includes the "svelte runtime" (just 300 lines of javascript code) and the app.svelte compiled component.
Gecko Logging
logging framework declaring a log module lazylogmodule
defers the creation the backing logmodule in a thread-safe manner and is the preferred method to declare a log module.
mach
instead,
defer your import until inside the @command decorated method.
Addon
operations are generally
deferred when a restart is necessary to accomplish them.
XPCOMUtils.jsm
a getter
defers the cost of calculating the value until the value is needed, and if it is never needed, you never pay the cost.
nsIClipboard
forcedatatoclipboard() obsolete since gecko 1.8 (firefox 1.5 / thunderbird 1.5 / seamonkey 1.0) some platforms support
deferred notification for putting data on the clipboard this method forces the data onto the clipboard in its various formats this may be used if the application going away.
nsIFileInputStream
(the file will only be reopened if it is closed for some reason.)
defer_open 1<<4 if this is set, the file will be opened (i.e., a call to pr_open() done) only when we do an actual operation on the stream, or more specifically, when one of the following is called: seek() tell() available() read() readline()
defer_open is useful if we use the stream on a background thread, so that the opening and possible stating of the f...
nsISessionStartup
defer_session 3 the previous session is viable but shouldn't be restored without explicit action (with the exception of app tabs, which are always restored in this case).
nsIXPConnect
deferreleasesuntilaftergarbagecollection prbool obsolete since gecko 1.9 pendingexception nsiexception constants constant value description init_js_standard_classes 1 << 0 flag_system_global_object 1 << 1 omit_components_object 1 << 2 xpc_xow_clearscope 1 tells updatexows() to clear the scope of...
Storage
the latter takes one of three constants to describe the type of transaction: mozistorageconnection.transaction_
deferred mozistorageconnection.transaction_immediate mozistorageconnection.transaction_exclusive mozistorageconnection.begintransaction() is equivalent to calling mozistorageconnection.begintransactionas() and passing mozistorageconnection.transaction_
deferred.
Address book sync client design
a ui ab sync logic mork ab database sync protocol encoding sync protocol decoding http "post" api mozilla networking client side sync logic the client synchronization logic
defers to the server peforming some intelligence in handling duplicate entries for the sync process.
Document.write() - Web APIs
note: using document.write() in
deferred or asynchronous scripts will be ignored and you'll get a message like "a call to document.write() from an asynchronously-loaded external script was ignored" in the error console.
HTMLImageElement.loading - Web APIs
by establishing the intrinsic aspect ratio in this manner, you prevent elements from shifting around while the document loads, which can be disconcerting or offputting at best and can cause users to click the wrong thing at worst, depending on the exact timing of the
deferred loads and reflows.
NotificationEvent.notification - Web APIs
the notification provides read-only access to many properties that were set at the instantiation time of the notification such as tag and data attributes that allow you to store information for
defered use in the notificationclick event.
WEBGL_draw_buffers - Web APIs
the webgl_draw_buffers extension is part of the webgl api and enables a fragment shader to write to several textures, which is useful for
deferred shading, for example.
WebGL best practices - Web APIs
don't check shader compile status until linking fails there are very few errors that are guaranteed to cause shader compilation failure, but cannot be
deferred to link time.
Window.open() - Web APIs
the actual fetching of the url is
deferred and starts after the current script block finishes executing.
JavaScript modules - JavaScript
there is no need to use the
defer attribute (see <script> attributes) when loading a module script; modules are
deferred automatically.
getter - JavaScript
a getter
defers the cost of calculating the value until the value is needed.
Promise - JavaScript
not to be confused with: several other languages have mechanisms for lazy evaluation and
deferring a computation, which they also call "promises", e.g.
Optimizing startup performance - Web Performance
getting asynchronous here are some suggestions for how to build your startup process to be as asynchronous as possible (whether it's a new app or a port): use the
defer or async attribute on script tags needed by the web application.
Web Performance
lazy loading is
deferring the loading of assets on a page, such as scripts, images, etc., on a page to a later point in time i.e when those assets are actually needed.
Progressive web app structure - Progressive web apps (PWAs)
gressive web apps."> <meta name="author" content="end3r"> <meta name="theme-color" content="#b12a34"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta property="og:image" content="icons/icon-512.png"> <link rel="shortcut icon" href="favicon.ico"> <link rel="stylesheet" href="style.css"> <link rel="manifest" href="js13kpwa.webmanifest"> <script src="data/games.js"
defer></script> <script src="app.js"
defer></script> </head> <body> <header> <p><a class="logo" href="http://js13kgames.com"><img src="img/js13kgames.png" alt="js13kgames"></a></p> </header> <main> <h1>js13kgames a-frame entries</h1> <p class="description">list of games submitted to the <a href="http://js13kgames.com/aframe">a-frame category</a> in the <a href="http://2017.js13kgames.com">js13kgame...
Structural overview of progressive web apps - Progressive web apps (PWAs)
gressive web apps."> <meta name="author" content="end3r"> <meta name="theme-color" content="#b12a34"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta property="og:image" content="icons/icon-512.png"> <link rel="shortcut icon" href="favicon.ico"> <link rel="stylesheet" href="style.css"> <link rel="manifest" href="js13kpwa.webmanifest"> <script src="data/games.js"
defer></script> <script src="app.js"
defer></script> </head> <body> <header> <p><a class="logo" href="http://js13kgames.com"><img src="img/js13kgames.png" alt="js13kgames"></a></p> </header> <main> <h1>js13kgames a-frame entries</h1> <p class="description">list of games submitted to the <a href="http://js13kgames.com/aframe"> a-frame category</a> in the <a href="http://2017.js13kgames.com">j...
SVG 2 support in Mozilla - SVG: Scalable Vector Graphics
atus unknown auto value of width and height computes to 0 but 100% on <svg> not implemented coordinate systems, transformations and units change notes exception for bad values on svgmatrix.skewx() and svgmatrix.skewy() implementation status unknown bounding box for element with no position at (0, 0) implementation status unknown
defer keyword removed from preserveaspectratio attribute removed (bug 1280425) added non-scaling-size, non-rotation and fixed-position keywords for vector-effect property not implemented yet (bug 1318208) vector-effect has no effect within 3d rendering context implementation status unknown consider clip and overflow on svg document referenced by <image> implementa...